diff --git a/.gitattributes b/.gitattributes
index a6344aac8c09253b3b630fb776ae94478aa0275b..9af8aeca0a61e191b0ae35413b74900a775e3828 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.woff2 filter=lfs diff=lfs merge=lfs -text
diff --git a/.gitignore b/.gitignore
index 7a60b85e148f80966a550e5ab6a762a907c69ca6..91f0a8e93fbf87317901ee98da29d693be4c7bf9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,7 @@
 __pycache__/
 *.pyc
+
+# the console builds its example database at image build time
+viewer/data/*.sqlite
+viewer/data/*.sqlite-*
+viewer/data/*.building
diff --git a/Dockerfile b/Dockerfile
index 85156734038425d7e00fdafe8af1d8fa3338c74b..392bd1cb282d6da50182f71894af535b7192cd2c 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -3,6 +3,7 @@ RUN useradd -m -u 1000 user
 WORKDIR /app
 COPY --chown=user:user . /app
 RUN pip install --no-cache-dir fastapi==0.141.1 uvicorn==0.53.0 websockets==15.0.1 huggingface_hub==1.32.0 tomli-w==1.2.0 './pipeline[hf]'
+RUN python -m viewer.build && chown -R user:user /app/viewer/data   # the console's example database
 USER user
 ENV HOME=/home/user
 EXPOSE 7860
diff --git a/app.py b/app.py
index 2be2267a9f4e17d14315eccbca6325b40e083f2b..d2cc2be6f970cdcb3c5b74bc50db44e7270ef315 100644
--- a/app.py
+++ b/app.py
@@ -123,8 +123,8 @@ class Selection(BaseModel):
     rank: int = 16
 @app.get('/')
 def home(): return FileResponse(ROOT/'index.html')   # the submission board: what participants use
-@app.get('/dashboard', include_in_schema=False)
-def dashboard_page(): return FileResponse(ROOT/'dashboard.html')   # the organizers' and researchers' dashboard
+@app.get('/dashboard/previous', include_in_schema=False)
+def dashboard_page(): return FileResponse(ROOT/'dashboard.html')   # the previous organizers' dashboard, kept reachable
 DASHBOARD_API = {'title': 'PostTrain API', 'version': '2.0.0', 'description': 'The routes the PostTrain dashboard reads: projects, training runs and their records, evaluations, datasets, jobs, the model registry, deployments, inference, usage, reports and Ari\'s findings. Every route is a read-only GET.'}
 def dashboard_routes():
     """The routes the dashboard reads (results_api, run_api, the run records under /api/app/fwruns, sign-in state and the build), and no others."""
@@ -151,6 +151,15 @@ def dashboard_openapi():
 def dashboard_docs():
     from fastapi.openapi.docs import get_swagger_ui_html
     return get_swagger_ui_html(openapi_url='/dashboard/openapi.json', title='PostTrain API')
+# The PostTrain console at /dashboard (API under /api/v3), read-only here: the example projects built from
+# published post-training programs, no workspace and no write API (viewer/README in benchflow-ai/pta-dash apps/console).
+# Registered after /dashboard/openapi.json, /dashboard/docs and /dashboard/previous so its page catch-all doesn't shadow them.
+os.environ.setdefault('POSTTRAIN_READONLY', '1')
+import viewer.server as viewer_server
+import viewer.api_ui as viewer_ui
+app.include_router(viewer_server.router)
+app.include_router(viewer_ui.router)
+viewer_server.mount_static(app)
 @app.get('/board', include_in_schema=False)
 def board_page(): return FileResponse(ROOT/'board.html')
 @app.get('/icon.svg', include_in_schema=False)
diff --git a/viewer/DESIGN.md b/viewer/DESIGN.md
new file mode 100644
index 0000000000000000000000000000000000000000..f05833a245704fcef1f231bae2fc345b2dd0e43f
--- /dev/null
+++ b/viewer/DESIGN.md
@@ -0,0 +1,22 @@
+# Viewer design
+
+A console for post-training teams: the runs they train, the data and environments those runs learn from, and the held-out evals that say whether it worked. It is built from what those teams have to decide, not from another product's layout.
+
+## The questions, in the order people ask them
+
+1. **What is running, and does anything need me?** Project overview: runs with their progress, training curve and held-out change; a list of failing checks (from the runs' own metrics and task validation); recent restarts, notices and completions.
+2. **Is this run learning?** Run page, first screen: the training curve with restarts and notices marked, and one small chart per held-out benchmark (score ± SE by step) beside it.
+3. **Is it healthy?** The checks panel explains in one sentence each why a signal is fine or not (entropy, gradient spikes, trainer–sampler KL, truncation, groups with no learning signal, infrastructure errors, staleness). Below it, the signals themselves as small charts, each named in words with the framework's own tag underneath.
+4. **Where does the signal come from?** "By environment": batch share, pass rate first → last step, change, infrastructure errors, per data source.
+5. **What is the model actually doing?** Steps expand to their stored groups; a group shows every attempt at one task as a row of cells coloured by outcome; any cell opens the rollout: where it sits (run, step, task, attempt i/n), why its advantage is what it is, the score with the rule that produced it, and the transcript with collapsible tool calls and search.
+6. **Did the evals move beyond noise?** Evals page: a matrix of benchmarks × models with standard errors, curves during training, and per-eval pages with the distribution of per-task results and a task-by-task comparison with any other eval (gained, lost, still solved, still unsolved).
+7. **Are the environments and data any good?** Environments list every task with its validation result (oracle, no-op, rerun agreement, hack probe, overlap with evals) and its pass rate under the base and the latest policy, so too-easy and too-hard tasks are visible before they waste a step. Datasets show composition, processing funnel, sample rows and the runs that used them.
+8. **What did it cost, and what was learned?** Jobs (every attempt of every workload), usage by day and run, and reports written as claims with verdicts.
+
+## Rules the pages follow
+
+- Every number has its denominator (tasks × attempts, stored of total) and every score its standard error.
+- Infrastructure failures are shown and excluded, never scored as zero.
+- Colour only encodes meaning: outcome and status (always with an icon or label), train vs held-out, and run identity when runs are compared. Everything else is ink on white with hairlines.
+- Data comes from one SQLite protocol (`PROTOCOL.md`) whether it is the demo world or our own runs, and published numbers are labelled apart from simulated ones.
+- Every object links to the objects it came from: run → inputs → tasks → attempts; eval → model → run that produced it.
diff --git a/viewer/PROTOCOL.md b/viewer/PROTOCOL.md
new file mode 100644
index 0000000000000000000000000000000000000000..5f7294e949abea71dea9b97b8f31cba94931a1d7
--- /dev/null
+++ b/viewer/PROTOCOL.md
@@ -0,0 +1,57 @@
+# Viewer data protocol
+
+The viewer reads one SQLite database at a time. `data/demo.sqlite` is built by `python -m viewer.build` from public post-training recipes; `data/live.sqlite` is built from our own runs. Both follow this protocol, and the API and pages read them through the same code, so anything the demo shows, a live source can fill.
+
+Every record answers one question a post-training team asks. The tables below say which.
+
+## Scope
+
+- **org**: a team (a lab). **project**: one model program inside it, such as "MiMo-V2.6 RL" or "Nemotron 3 Nano post-training". Every other record belongs to a project.
+
+## Models
+
+- **models**: base models, intermediate checkpoints that were promoted, teachers, reward models and judges. `parent_id` + `run_id` give lineage: which run turned which model into which. Answers "what did each stage produce, and from what?"
+- **checkpoints**: every saved step of a run, with its eval summary. Answers "which step do we ship?"
+
+## Data
+
+- **datasets**: SFT, preference, RL prompt pools and eval sets, versioned (`parent_id` points at the version it was derived from). `processing` is the funnel from raw to final (`[{step, rows_in, rows_out, note}]`).
+- **dataset_sources**: the composition: each upstream source with category, rows, tokens, whether it is synthetic and which model generated it, and its license.
+- **dataset_rows**: a sample of rows for reading.
+
+## Environments
+
+- **environments**: an RL environment: domain, harness (the agent loop), tools, sandbox, grader, reward kind (binary, partial, scalar).
+- **graders**: how a rollout becomes a reward: components with weights and the rule for each, and the formula that combines them.
+- **tasks**: every task of an environment with its validation result (oracle score, no-op score, agreement across reruns), status (`ok`, `flaky`, `invalid`, `leaky`, `hackable`, `too_easy`, `too_hard`, `excluded`) with a reason, and pass rates for the base model and the latest policy.
+
+## Runs
+
+- **runs**: one training run of any kind (`sft`, `dpo`, `rl`, `distill`, `rm`). Holds the recipe (`algorithm`, `framework`, `hyperparams`, raw `config`), the models in and out, state, progress, compute and cost, and `provenance` (`published`, `simulated` or `mixed`).
+- **run_inputs**: datasets and environments a run trained on, with their weight in the mix.
+- **metrics**: every logged scalar, `(run, tag, step) → value`. Tag names are the framework's own (`actor/entropy_loss`, `dynsam/avg@n`, `train/loss`); **metric_defs** gives each tag a label, a description, a unit, which direction is better, and whether it is pinned.
+- **run_steps**: per-step facts derived from rollouts: prompts, rollouts, how many were stored, mean reward, pass rate, groups where every attempt passed / failed / differed, infrastructure errors, truncations.
+- **run_events**: restarts, notices, checkpoints, data changes, config changes and alerts, placed on the run's timeline.
+
+## Rollouts
+
+- **rollouts**: one attempt at one task by one policy version: step, group and sample index, task and environment, harness, reward, advantage, score components, outcome (`passed`, `failed`, `partial`, `infra_error`, `timeout`, `truncated`), stop reason, turns, tool calls, tokens (in, out, cached), time by phase, staleness (policy versions between sampling and training) and flags (`possible_leak`, `reward_hack_suspect`). Training rollouts carry `run_id`; evaluation rollouts carry `eval_id`. Large runs store a sample; `run_steps.rollouts_stored` says how many.
+- **transcripts**: the messages of a rollout when a source stores them. When absent, the demo source renders a transcript from the rollout's own fields and seed, so it always agrees with the stored reward, turns and stop reason.
+
+## Evals
+
+- **benchmarks**: a held-out suite: version, harness, metric (`avg@3`, `pass@1`), tasks and attempts per task.
+- **evals**: one model (or run step) on one benchmark: score with its standard error, tasks × attempts, infrastructure errors excluded from the score, the recorded command and config, status.
+- **eval_tasks**: per-task results of an eval, so two evals can be compared task by task (gained, lost, still passing, still failing).
+
+## Operations
+
+- **jobs**: every workload (train, rollout workers, eval, data processing, validation, serving) with cluster, GPUs, state, cost and the tail of its log.
+- **clusters**, **usage** (spend per day and category), **deployments** (a model served as an endpoint).
+- **reports**: written findings about runs, as claims with a verdict (`upheld`, `rejected`, `open`) and evidence links.
+
+## Rules
+
+- Numbers carry their denominators: a pass rate comes with tasks × attempts; a score with its standard error.
+- Infrastructure failures are never scored as zero: they are counted separately and excluded.
+- Every published number keeps its source URL; simulated records say so through `provenance`.
diff --git a/viewer/__init__.py b/viewer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/viewer/api_ui.py b/viewer/api_ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea9c205764b66bd096d70b980fa6bf65d73e5973
--- /dev/null
+++ b/viewer/api_ui.py
@@ -0,0 +1,457 @@
+"""Read endpoints the website needs to do work, not only to look at it: where a project stands stage
+by stage, what a launch can use, and the state of the jobs behind queued and running runs.
+
+Writes stay in api_write.py; these only read. Runs, datasets and the rest are read from the source
+that holds the project (`?source=`); jobs, runners and compute targets always live in the workspace.
+"""
+import shlex
+import time
+
+from fastapi import APIRouter, HTTPException
+
+from . import api_write, db, workspace
+
+router = APIRouter(prefix="/api/v3")
+ONLINE = 90          # seconds since a runner's last heartbeat, the same window as api_write.list_compute
+ACTIVE_RUN = {"queued", "starting", "running", "stopping", "stalled"}
+ACTIVE_JOB = ("queued", "starting", "running")
+STAGES = ["data", "environments", "sft", "preference", "rl", "eval", "deploy"]
+RUN_KIND = {"sft": "sft", "preference": "dpo", "rl": "rl"}
+FEEDS = {"data": "sft", "environments": "rl"}   # an input counts as skipped only once the stage it feeds is passed
+
+
+def conn_for(source):
+    try:
+        return db.connect(source or "workspace")
+    except (KeyError, FileNotFoundError):
+        raise HTTPException(404, f"Data source '{source}' is not available.")
+
+
+def project_or_404(c, org, project):
+    p = db.one(c, "SELECT p.*, o.slug AS org_slug, o.name AS org_name FROM projects p JOIN orgs o ON o.id=p.org_id "
+                  "WHERE o.slug=? AND p.slug=?", (org, project))
+    if not p:
+        raise HTTPException(404, "No such project.")
+    return p
+
+
+def q(v):
+    """Shell-quote a value for a CLI line; <placeholders> stay as they are."""
+    s = str(v)
+    return s if s.startswith("<") and s.endswith(">") else shlex.quote(s)
+
+
+def compute_state(org):
+    """The org's compute targets (plus the built-in `local`) with runners online and jobs waiting, and its runners."""
+    c = workspace.connect()
+    o = db.one(c, "SELECT id FROM orgs WHERE slug=?", (org,))
+    if not o:
+        return {"targets": [{"name": "local", "kind": "local", "config": {}, "builtin": True, "runners": [], "queued": 0, "active": 0}],
+                "runners": []}
+    listed = api_write.list_compute(org)
+    targets, runners = listed["targets"], listed["runners"]
+    counts = {}
+    for row in c.execute("SELECT j.target, j.status, count(*) FROM jobs j JOIN projects p ON p.id=j.project_id "
+                         "WHERE p.org_id=? AND j.status IN ('queued','starting','running') GROUP BY j.target, j.status", (o["id"],)):
+        counts.setdefault(row[0], {})[row[1]] = row[2]
+    if not any(t["name"] == "local" for t in targets):
+        now = time.time()
+        targets.insert(0, {"name": "local", "kind": "local", "config": {}, "builtin": True,
+                           "runners": [r["name"] for r in runners if "local" in (r.get("targets") or []) and now - (r["last_seen"] or 0) < ONLINE]})
+    for t in targets:
+        n = counts.get(t["name"], {})
+        t["queued"] = n.get("queued", 0)
+        t["active"] = n.get("starting", 0) + n.get("running", 0)
+    return {"targets": targets, "runners": runners}
+
+
+# ------------------------------------------------------------------ environment readiness
+
+NOT_USABLE = ("invalid", "leaky", "flaky", "hackable", "excluded")
+
+
+def env_readiness(c, env_ids):
+    """PRD 4.2, from the stored task results: an environment is ready when validation ran, at least 16
+    tasks are usable, a difficulty profile exists, and at least one usable task is learnable."""
+    if not env_ids:
+        return {}
+    q = ",".join("?" for _ in env_ids)
+    bad = ",".join(f"'{x}'" for x in NOT_USABLE)
+    out = {}
+    for r in db.rows(c, f"SELECT env_id, count(*) AS n, sum(oracle_score IS NOT NULL) AS validated, sum(status NOT IN ({bad})) AS usable, "
+                        f"sum(base_pass IS NOT NULL) AS profiled, sum(status NOT IN ({bad}) AND base_pass > 0.02 AND base_pass < 0.98) AS learnable, "
+                        f"sum(status='flaky') AS flaky FROM tasks WHERE env_id IN ({q}) GROUP BY env_id", env_ids):
+        usable, learnable = r["usable"] or 0, r["learnable"] or 0
+        reason = ("not validated" if not r["validated"] else f"{usable} usable tasks (needs 16)" if usable < 16
+                  else "no difficulty profile" if not r["profiled"] else "no learnable task" if not learnable else None)
+        out[r["env_id"]] = {"tasks": r["n"], "usable": usable, "learnable": learnable, "profiled": r["profiled"] or 0,
+                            "flaky": r["flaky"] or 0, "ready": reason is None, "reason": reason}
+    for e in env_ids:
+        out.setdefault(e, {"tasks": 0, "usable": 0, "learnable": 0, "profiled": 0, "flaky": 0, "ready": False, "reason": "no tasks"})
+    return out
+
+
+# ------------------------------------------------------------------ stages
+
+@router.get("/p/{org}/{project}/stages")
+def stages(org: str, project: str, source: str = "workspace"):
+    """The Overview's Stages table (PRD 6.3): each stage's status (not started, in progress, blocked, done,
+    skipped), what exists, and the next action with its CLI line. Done criteria follow PRD section 4 as far as
+    the workspace records them; promotion, suites and acknowledgements are approximated (see `approx`)."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    pid = p["id"]
+    datasets = db.rows(c, "SELECT id, name, kind, rows, tokens, created_at FROM datasets WHERE project_id=? ORDER BY created_at DESC", (pid,))
+    envs = db.rows(c, "SELECT id, name, domain, task_count, created_at FROM environments WHERE project_id=? ORDER BY created_at DESC", (pid,))
+    ready = env_readiness(c, [e["id"] for e in envs])
+    runs = db.rows(c, "SELECT r.id, r.name, r.kind, r.status, r.status_reason, r.framework, r.algorithm, r.steps_done, r.steps_planned, "
+                      "r.started_at, r.updated_at, r.ended_at, r.base_model_id, r.output_model_id, m.name AS output_model, b.name AS base_model "
+                      "FROM runs r LEFT JOIN models m ON m.id=r.output_model_id LEFT JOIN models b ON b.id=r.base_model_id "
+                      "WHERE r.project_id=? ORDER BY coalesce(r.updated_at, r.started_at) DESC", (pid,))
+    evals = db.rows(c, "SELECT e.id, e.status, e.score, e.stderr, e.step, e.n_tasks, e.k, e.started_at, e.model_id, e.benchmark_id, "
+                       "b.name AS benchmark, b.metric, m.name AS model_name, r.name AS run_name FROM evals e JOIN benchmarks b ON b.id=e.benchmark_id "
+                       "LEFT JOIN models m ON m.id=e.model_id LEFT JOIN runs r ON r.id=e.run_id WHERE e.project_id=? "
+                       "ORDER BY e.started_at DESC", (pid,))
+    deps = db.rows(c, "SELECT d.id, d.name, d.status, d.endpoint, d.created_at, m.name AS model_name FROM deployments d "
+                      "LEFT JOIN models m ON m.id=d.model_id WHERE d.project_id=? ORDER BY d.created_at DESC", (pid,))
+    models = db.rows(c, "SELECT id, name, kind, hf_repo, created_at FROM models WHERE project_id=? ORDER BY created_at DESC", (pid,))
+    benches = [r["name"] for r in db.rows(c, "SELECT name FROM benchmarks WHERE project_id=? ORDER BY name", (pid,))]
+    evaluated = {}                                  # model id -> benchmark ids with a completed eval
+    for e in evals:
+        if e["status"] == "completed" and e["model_id"]:
+            evaluated.setdefault(e["model_id"], set()).add(e["benchmark_id"])
+
+    comp = compute_state(org) if source == "workspace" else {"targets": [], "runners": []}
+    served = [t["name"] for t in comp["targets"] if t.get("runners")]
+    target = served[0] if served else next((t["name"] for t in comp["targets"] if not t.get("builtin")), "local")
+    base = next((m["hf_repo"] or m["name"] for m in models if m["kind"] == "base"), "<model>")
+    bench = benches[0] if benches else "gsm8k"
+
+    def run_obj(r):
+        return {"type": "run", "id": r["id"], "name": r["name"], "status": r["status"], "reason": r["status_reason"],
+                "framework": r["framework"], "algorithm": r["algorithm"], "steps_done": r["steps_done"], "steps_planned": r["steps_planned"],
+                "output_model": r["output_model"], "evaluated": bool(r["output_model_id"] and evaluated.get(r["output_model_id"]))}
+
+    def act(label, cli, kind, arg=None):
+        return {"label": label, "cli": cli, "kind": kind, "arg": arg}
+
+    rows = {}
+    # data
+    by_kind = {}
+    for d in datasets:
+        by_kind.setdefault(d["kind"], []).append(d)
+    rows["data"] = {"status": "done" if datasets else "not_started",
+                    "objects": [{"type": "dataset", "id": d["id"], "name": d["name"], "kind": d["kind"], "rows": d["rows"]} for d in datasets],
+                    "next": None if datasets else act("Add dataset", "posttrain data add ./train.jsonl --kind sft", "add", "dataset")}
+    # environments
+    env_objs = [{"type": "environment", "id": e["id"], "name": e["name"], "domain": e["domain"], **ready[e["id"]]} for e in envs]
+    unready = [e for e in env_objs if not e["ready"]]
+    rows["environments"] = {
+        "status": "not_started" if not envs else "in_progress" if unready else "done", "objects": env_objs,
+        "next": act("Add environment", "posttrain env add ./my-env", "add", "environment") if not envs
+        else act("Validate", f"posttrain env validate {q(unready[0]['name'])} --on {q(target)}", "env", unready[0]["id"]) if unready else None}
+
+    # training stages: done when a model trained in the stage has an eval (PRD: "a model promoted from an ... run has a quick eval")
+    NEEDS = {"sft": ("sft", "needs an SFT dataset"), "preference": ("preference", "needs a preference dataset")}
+    LAUNCH = {"sft": "Launch SFT", "preference": "Launch preference", "rl": "Launch RL"}
+    CLI_STAGE = {"sft": "sft", "preference": "dpo", "rl": "rl"}
+
+    def latest_output(kinds):
+        return next((r["output_model"] for r in runs if r["kind"] in kinds and r["status"] == "completed" and r["output_model"]), None)
+    start_from = {"sft": base, "preference": latest_output(("sft",)) or base, "rl": latest_output(("dpo", "sft")) or base}
+    for st, kind in RUN_KIND.items():
+        rs = [r for r in runs if r["kind"] == kind]
+        active = [r for r in rs if r["status"] in ACTIVE_RUN]
+        trained = [r for r in rs if r["status"] == "completed" and r["output_model_id"]]
+        done = [r for r in trained if evaluated.get(r["output_model_id"])]
+        unevaluated = [r for r in trained if not evaluated.get(r["output_model_id"])]
+        if st == "rl":
+            missing = None if envs or by_kind.get("rl") else "needs an environment or an RL dataset"
+            ranked = sorted(envs, key=lambda e: not ready[e["id"]]["ready"])
+            inputs = f"--env {q(','.join(e['name'] for e in (([e for e in ranked if ready[e['id']]['ready']] or ranked)[:3])))}" if envs else f"--data {q(by_kind['rl'][0]['name'])}" if by_kind.get("rl") else "--env <environment>"
+        else:
+            dk, msg = NEEDS[st]
+            missing = None if by_kind.get(dk) else msg
+            inputs = f"--data {q(by_kind[dk][0]['name'])}" if by_kind.get(dk) else f"--data <{'pairs' if st == 'preference' else 'dataset'}>"
+        launch_cli = f"posttrain train {CLI_STAGE[st]} --base {q(start_from[st])} {inputs} --on {q(target)}"
+        if done:
+            status, nxt = "done", None
+        elif active:
+            status, nxt = "in_progress", act("Watch", f"posttrain runs watch {q(active[0]['name'])}", "run", active[0]["id"])
+        elif unevaluated:
+            m = unevaluated[0]["output_model"]
+            status, nxt = "in_progress", act("Run eval", f"posttrain eval {q(m)} --bench {q(bench)} --on {q(target)}", "eval", m)
+        elif missing:
+            status = "not_started"
+            nxt = act("Add dataset" if st != "rl" else ("Add environment"), f"posttrain data add ./{'pairs' if st == 'preference' else 'train'}.jsonl --kind {NEEDS[st][0]}"
+                      if st != "rl" else "posttrain env add ./my-env", "add", "dataset" if st != "rl" else "environment")
+            nxt["needs"] = missing
+        else:
+            status, nxt = "not_started", act(LAUNCH[st], launch_cli, "launch", CLI_STAGE[st])
+        rows[st] = {"status": status, "objects": [run_obj(r) for r in rs], "next": nxt, "launch": act(LAUNCH[st], launch_cli, "launch", CLI_STAGE[st])}
+
+    # eval: a trained model evaluated next to the model it started from (PRD: a release eval compared with the baseline)
+    eval_runs = [r for r in runs if r["kind"] == "eval"]
+    trained = [r for r in runs if r["kind"] in ("sft", "dpo", "rl") and r["status"] == "completed" and r["output_model_id"]]
+    compared = [r for r in trained if evaluated.get(r["output_model_id"]) and evaluated.get(r["base_model_id"])
+                and evaluated[r["output_model_id"]] & evaluated[r["base_model_id"]]]
+    newest = trained[0]["output_model"] if trained else None
+    missing_baseline = next((r for r in trained if evaluated.get(r["output_model_id"]) and not evaluated.get(r["base_model_id"])), None)
+    ev_objs = [run_obj(r) for r in eval_runs if r["status"] in ACTIVE_RUN or r["status"] == "failed"] + [
+        {"type": "eval", "id": e["id"], "name": e["benchmark"], "status": e["status"], "score": e["score"], "stderr": e["stderr"],
+         "metric": e["metric"], "model": e["run_name"] or e["model_name"], "step": e["step"], "n_tasks": e["n_tasks"], "k": e["k"]}
+        for e in evals]
+    if compared:
+        ev_status, ev_next = "done", None
+    elif any(r["status"] in ACTIVE_RUN for r in eval_runs) or any(e["status"] == "running" for e in evals):
+        ev_status, ev_next = "in_progress", act("Watch", "posttrain evals", "page", "/evals")
+    elif missing_baseline:
+        ev_status = "in_progress"
+        ev_next = act("Run baseline eval", f"posttrain eval {q(missing_baseline['base_model'] or base)} --bench {q(bench)} --on {q(target)}",
+                      "eval", missing_baseline["base_model"] or base)
+    elif not trained:
+        ev_status, ev_next = "not_started", {"needs": "needs a trained model", "label": "Run eval", "cli": f"posttrain eval {q(base)} --bench {q(bench)} --on {q(target)}",
+                                             "kind": "eval", "arg": None if base == "<model>" else base}
+    else:
+        ev_status, ev_next = "not_started", act("Run eval", f"posttrain eval {q(newest)} --bench {q(bench)} --on {q(target)}", "eval", newest)
+    rows["eval"] = {"status": ev_status, "objects": ev_objs, "next": ev_next}
+
+    live_deps = [d for d in deps if (d["status"] or "") not in ("failed", "stopped", "deleted")]
+    rows["deploy"] = {"status": "done" if live_deps else "not_started",
+                      "objects": [{"type": "deployment", "id": d["id"], "name": d["name"], "status": d["status"], "model": d["model_name"],
+                                   "endpoint": d["endpoint"]} for d in deps],
+                      "next": None if live_deps else {"needs": "needs the Eval stage"} if ev_status != "done"
+                      else act("Deploy", f"posttrain models deploy {q(newest or '<model>')} --on {q(target)}", "page", "/models")}
+
+    # a stage nobody did while a later one went ahead is skipped (RL straight from a base model skips SFT and preference)
+    reached = max((i for i, s in enumerate(STAGES) if rows[s]["status"] in ("done", "in_progress")), default=-1)
+    for s in STAGES:
+        if rows[s]["status"] == "not_started" and STAGES.index(FEEDS.get(s, s)) < reached:
+            rows[s]["status"] = "skipped"
+            if rows[s].get("launch"):
+                rows[s]["next"] = rows[s]["launch"]
+    nxt = next((s for s in STAGES if rows[s]["status"] in ("not_started", "in_progress") and rows[s]["next"] and rows[s]["next"].get("label")), None)
+    out = [{"key": s, "status": rows[s]["status"], "objects": rows[s]["objects"][:6], "total": len(rows[s]["objects"]), "next": rows[s]["next"]}
+           for s in STAGES]
+
+    # runs that wait for a runner nobody is serving
+    online = {t["name"]: t.get("runners") or [] for t in comp["targets"]}
+    waiting = []
+    if source == "workspace":
+        for j in db.rows(c, "SELECT j.id, j.run_id, j.target, j.created_at, r.name AS run_name FROM jobs j JOIN runs r ON r.id=j.run_id "
+                            "WHERE j.project_id=? AND j.status='queued' ORDER BY j.created_at", (pid,)):
+            if not online.get(j["target"]):
+                waiting.append(j)
+    counts = {"datasets": len(datasets), "environments": len(envs), "runs": len(runs), "evals": len(evals), "models": len(models),
+              "deployments": len(deps)}
+    return {"project": p, "stages": out, "next": nxt, "empty": not any(v for k, v in counts.items() if k != "models"), "counts": counts, "waiting": waiting,
+            "active": any(s["status"] == "in_progress" for s in out) or bool(waiting),
+            "approx": {"promoted": "a completed run's output model", "quick eval": "any completed eval of that model",
+                       "release eval": "a trained model and the model it started from evaluated on a common benchmark"},
+            "compute": [{"name": t["name"], "kind": t["kind"], "runners": t.get("runners") or [], "builtin": bool(t.get("builtin"))}
+                        for t in comp["targets"]]}
+
+
+# ------------------------------------------------------------------ launch
+
+def P(key, label, default, typ="float", help="", **kw):
+    return {"key": key, "label": label, "default": default, "type": typ, "help": help, **kw}
+
+
+def METHOD(default):
+    return [P("method", "Method", default, "choice", "LoRA trains a small adapter and needs far less memory; full updates every weight.",
+              choices=["lora", "full"]),
+            P("lora.r", "LoRA rank", 16, "int", "Adapter rank; 8 to 64 is typical.", when=["method", "lora"])]
+
+
+RL_KEYS = [P("prompts_per_step", "Prompts per step", 64, "int", "Each prompt gets a group of completions."),
+           P("group_size", "Group size", 8, "int", "Completions per prompt; each is scored against its group."),
+           P("lr", "Learning rate", 1e-6), P("max_tokens", "Max tokens", 8192, "int", "Per completion; longer ones are cut off and count as truncated."),
+           P("temperature", "Temperature", 1.0, help="Sampling temperature for training attempts.")]
+
+# The launch form's key settings (PRD 6.4) for each recipe and stage, under the recipes' own setting
+# names (PRD section 4; posttrain.recipes checks them and rejects names it doesn't know). Defaults and help
+# come from posttrain.recipes when this server can import it; `lr_by_method` holds the PRD's rates.
+RECIPES = [
+    {"id": "trl", "label": "TRL", "framework": {"sft": "trl_sft", "dpo": "trl_dpo"}, "stages": {"sft": "SFT", "dpo": "DPO"},
+     "about": "Hugging Face TRL on one node: full fine-tuning or LoRA.",
+     "params": {
+         "sft": [*METHOD("lora"), P("lr", "Learning rate", None, lr_by_method={"lora": 1e-4, "full": 1e-5}),
+                 P("epochs", "Epochs", 1, help="Passes over the data when steps is blank."),
+                 P("batch_size", "Batch size", 32, "int", "Examples per optimizer step, across GPUs."),
+                 P("max_seq_len", "Max length", 8192, "int", "Tokens per example; longer ones are truncated.")],
+         "dpo": [*METHOD("full"), P("beta", "β", 0.1, help="How far the policy may move from the reference; 0.01 to 0.5 is usual."),
+                 P("lr", "Learning rate", None, lr_by_method={"lora": 5e-6, "full": 5e-7}),
+                 P("epochs", "Epochs", 1, help="Passes over the pairs when steps is blank.")]}},
+    {"id": "trl-grpo", "label": "TRL GRPO", "framework": {"rl": "trl_grpo"}, "stages": {"rl": "GRPO"},
+     "about": "TRL's GRPO trainer on one node, with built-in verifiable rewards.",
+     "params": {"rl": [*METHOD("lora"), *[dict(x, lr_by_method={"lora": 1e-5, "full": 1e-6}, default=None) if x["key"] == "lr" else x for x in RL_KEYS]]}},
+    {"id": "prime-rl", "label": "prime-rl", "framework": {"rl": "prime_rl"}, "stages": {"rl": "GRPO"},
+     "about": "Prime Intellect's asynchronous RL trainer on your GPUs, with verifiers environments.", "params": {"rl": RL_KEYS}},
+    {"id": "verl", "label": "verl", "framework": {"rl": "verl"}, "stages": {"rl": "GRPO"},
+     "about": "ByteDance's verl: FSDP or Megatron training with vLLM or SGLang sampling; scales past one node.",
+     "params": {"rl": [*RL_KEYS, P("kl_coef", "KL coefficient", 0.0)]}},
+    {"id": "prime-hosted", "label": "Prime hosted RL", "framework": {"rl": "prime_rl"}, "stages": {"rl": "GRPO"},
+     "about": "Prime Intellect runs the training (LoRA) on its GPUs; the target is a Prime target in hosted mode.",
+     "note": "The model must be one Prime serves (prime train models), and each environment must be on the Prime Environments Hub.",
+     "params": {"rl": [*[dict(x, default=1e-5) if x["key"] == "lr" else x for x in RL_KEYS]]}},
+    {"id": "lm-eval", "label": "lm-evaluation-harness", "framework": {"eval": "lm_eval"}, "stages": {"eval": None},
+     "about": "EleutherAI's harness: standard benchmarks by task name (gsm8k, ifeval, mmlu, …).",
+     "params": {"eval": [P("limit", "Examples per task", None, "int", "Blank runs every example; a small number makes a smoke test."),
+                         P("num_fewshot", "Few-shot examples", None, "int", "Blank uses each task's default."),
+                         P("apply_chat_template", "Chat template", False, "bool", "Format prompts with the model's chat template (instruct models)."),
+                         P("batch_size", "Batch size", "auto", "str", "An integer, or auto.")]}},
+]
+STAGE_RECIPES = {"sft": ["trl"], "dpo": ["trl"], "rl": ["trl-grpo", "prime-rl", "verl", "prime-hosted"], "eval": ["lm-eval"]}
+DEFAULT_RECIPE = {"sft": "trl", "dpo": "trl", "rl": "trl-grpo", "eval": "lm-eval"}
+STRUCTURAL = {"base", "data", "env", "steps", "name", "model", "benchmarks"}   # set by the form's own fields
+
+
+def _typed(v):
+    return "bool" if isinstance(v, bool) else "int" if isinstance(v, int) else "float" if isinstance(v, float) else "str"
+
+
+def _metric_defs(framework):
+    try:
+        from .build.signals import FRAMEWORK_TAGS, SIGNALS
+    except Exception:
+        return []
+    out = []
+    for signal, tag in FRAMEWORK_TAGS.get(framework, {}).items():
+        label, unit, fmt, better, grp, desc = SIGNALS[signal]
+        out.append({"tag": tag, "label": label, "description": desc, "unit": unit, "format": fmt, "grp": grp,
+                    "better": better, "pinned": 0, "signal": signal})
+    return out
+
+
+def _recipe_source(stage, recipe):
+    """({setting: (default, help)}, framework) from posttrain.recipes, or (None, None) when this server lacks it."""
+    try:
+        from posttrain import recipes as R
+        table = R.params(stage, recipe)
+        mod = R.REGISTRY.get(recipe)
+        fw = getattr(mod, "FRAMEWORK", None)
+        fw = (fw.get(stage) or fw.get(recipe)) if isinstance(fw, dict) else fw
+        return table, fw
+    except Exception:
+        return None, None
+
+
+def recipe_catalog():
+    """RECIPES with each stage's settings checked against posttrain.recipes where this server has it:
+    defaults and help from the recipe's own table, settings it doesn't know dropped, the rest listed."""
+    out = []
+    for r in RECIPES:
+        entry = {k: v for k, v in r.items() if k != "params"}
+        entry["params"], entry["more"], entry["checked"], entry["metric_defs"] = {}, {}, {}, {}
+        for stage, keys in r["params"].items():
+            table, fw = _recipe_source(stage, r["id"])
+            fw = fw or r["framework"].get(stage)
+            entry["framework"] = {**entry["framework"], stage: fw}
+            entry["metric_defs"][stage] = _metric_defs(fw)
+            if not table:
+                entry["params"][stage], entry["more"][stage], entry["checked"][stage] = keys, [], False
+                continue
+            shown = []
+            for prm in keys:
+                if prm["key"] in table:
+                    default, help_ = table[prm["key"]]
+                    shown.append({**prm, "default": prm["default"] if default is None else default, "help": prm["help"] or help_})
+            listed = {x["key"] for x in shown} | STRUCTURAL
+            entry["params"][stage] = shown
+            entry["more"][stage] = [{"key": k, "default": v[0], "type": _typed(v[0]), "help": v[1]} for k, v in table.items() if k not in listed]
+            entry["checked"][stage] = True
+        out.append(entry)
+    return out
+
+
+@router.get("/p/{org}/{project}/launch")
+def launch_options(org: str, project: str, source: str = "workspace"):
+    """What a run launched from the website can use: models and checkpoints, datasets, environments,
+    benchmarks, the org's compute targets with the runners serving them, and the recipes."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    pid = p["id"]
+    models = db.rows(c, "SELECT m.id, m.name, m.kind, m.hf_repo, m.stage, m.status, m.run_id, m.created_at, r.name AS run_name, "
+                        "r.kind AS run_kind, r.status AS run_status FROM models m LEFT JOIN runs r ON r.id=m.run_id "
+                        "WHERE m.project_id=? AND coalesce(m.kind,'') NOT IN ('external','judge','reward') ORDER BY m.created_at DESC", (pid,))
+    made_by = {r["output_model_id"]: r for r in db.rows(c, "SELECT id, name, kind, status, output_model_id FROM runs WHERE project_id=? "
+                                                         "AND output_model_id IS NOT NULL", (pid,))}
+    for m in models:
+        r = made_by.get(m["id"])
+        if r and not m["run_id"]:
+            m.update(run_id=r["id"], run_name=r["name"], run_kind=r["kind"], run_status=r["status"])
+    ckpts = db.rows(c, "SELECT k.id, k.run_id, k.step, k.path, k.created_at, r.name AS run_name, r.kind AS run_kind FROM checkpoints k "
+                       "JOIN runs r ON r.id=k.run_id WHERE r.project_id=? ORDER BY k.created_at DESC LIMIT 60", (pid,))
+    datasets = db.rows(c, "SELECT id, name, kind, rows, tokens, version, hf_repo FROM datasets WHERE project_id=? ORDER BY created_at DESC", (pid,))
+    envs = db.rows(c, "SELECT id, name, domain, task_count, reward_kind FROM environments WHERE project_id=? ORDER BY name", (pid,))
+    readiness = env_readiness(c, [e["id"] for e in envs])
+    for e in envs:
+        e.update(readiness[e["id"]])
+    has_eval = {r[0] for r in c.execute("SELECT DISTINCT model_id FROM evals WHERE project_id=? AND status='completed' AND model_id IS NOT NULL", (pid,))}
+    for m in models:
+        m["evaluated"] = m["id"] in has_eval
+    benches = db.rows(c, "SELECT id, name, metric, n_tasks, k, harness FROM benchmarks WHERE project_id=? ORDER BY name", (pid,))
+    runs = db.rows(c, "SELECT id, name, kind, status, group_name FROM runs WHERE project_id=? ORDER BY started_at DESC LIMIT 500", (pid,))
+    comp = compute_state(org) if source == "workspace" else {"targets": [], "runners": []}
+    return {"project": p, "models": models, "checkpoints": ckpts, "datasets": datasets, "environments": envs,
+            "benchmarks": benches, "runs": runs, "compute": comp, "recipes": recipe_catalog(), "default_recipe": DEFAULT_RECIPE,
+            "stage_recipes": STAGE_RECIPES}
+
+
+# ------------------------------------------------------------------ jobs behind runs
+
+def _runner_view(r, now):
+    return {"id": r["id"], "name": r["name"], "hostname": r["hostname"], "last_seen": r["last_seen"], "version": r["version"],
+            "online": now - (r["last_seen"] or 0) < ONLINE} if r else None
+
+
+@router.get("/runs/{run_id}/jobs")
+def run_jobs(run_id: str):
+    """The jobs behind a workspace run: where each waits or runs, the runner that has it, what is
+    ahead of it in the queue, and how much log it has written."""
+    c = workspace.connect()
+    r = db.one(c, "SELECT r.id, r.name, r.status, r.status_reason, r.steps_done, r.steps_planned, r.started_at, r.updated_at, "
+                  "r.ended_at, r.last_seen, p.org_id, o.slug AS org FROM runs r JOIN projects p ON p.id=r.project_id JOIN orgs o ON o.id=p.org_id "
+                  "WHERE r.id=?", (run_id,))
+    if not r:
+        raise HTTPException(404, f"No run {run_id} in the workspace.")
+    now = time.time()
+    jobs = db.rows(c, "SELECT id, name, kind, status, target, spec, runner_id, external_id, created_at, claimed_at, started_at, "
+                      "ended_at, cancel, message, exit FROM jobs WHERE run_id=? ORDER BY created_at", (run_id,))
+    runners = db.rows(c, "SELECT id, name, hostname, targets, version, last_seen FROM runners WHERE org_id=?", (r["org_id"],))
+    targets = {t["name"]: t for t in db.rows(c, "SELECT name, kind, config FROM compute_targets WHERE org_id=?", (r["org_id"],))}
+    by_id = {x["id"]: x for x in runners}
+    for j in jobs:
+        j["runner"] = _runner_view(by_id.get(j["runner_id"]), now)
+        j["runners_online"] = [x["name"] for x in runners if j["target"] in (x.get("targets") or []) and now - (x["last_seen"] or 0) < ONLINE]
+        t = targets.get(j["target"])
+        j["target_kind"] = t["kind"] if t else ("local" if j["target"] == "local" else None)
+        j["target_registered"] = bool(t) or j["target"] == "local"
+        j["ahead"] = c.execute("SELECT count(*) FROM jobs j2 JOIN projects p ON p.id=j2.project_id WHERE p.org_id=? AND j2.status='queued' "
+                               "AND j2.target=? AND j2.created_at < ?", (r["org_id"], j["target"], j["created_at"] or now)).fetchone()[0] \
+            if j["status"] == "queued" else 0
+    n, last_seq, last_t = c.execute("SELECT count(*), max(seq), max(t) FROM logs WHERE run_id=?", (run_id,)).fetchone()
+    ev = db.one(c, "SELECT t, kind, title, body FROM run_events WHERE run_id=? ORDER BY t DESC LIMIT 1", (run_id,))
+    return {"run": {k: v for k, v in r.items() if k != "org_id"}, "jobs": jobs, "now": now,
+            "logs": {"lines": n, "last_seq": last_seq or 0, "last_t": last_t}, "last_event": ev}
+
+
+@router.get("/orgs/{org}/jobs")
+def org_jobs(org: str, status: str = "queued,starting,running", limit: int = 200):
+    """Jobs across the org's projects (queued, starting and running by default), with where they run."""
+    c = workspace.connect()
+    wanted = [s for s in status.split(",") if s]
+    if not wanted:
+        return []
+    now = time.time()
+    rows = db.rows(c, f"SELECT j.id, j.name, j.kind, j.status, j.target, j.runner_id, j.created_at, j.claimed_at, j.started_at, "
+                      f"j.ended_at, j.cancel, j.message, j.run_id, r.name AS run_name, r.kind AS run_kind, p.slug AS project, "
+                      f"p.name AS project_name FROM jobs j JOIN projects p ON p.id=j.project_id JOIN orgs o ON o.id=p.org_id "
+                      f"LEFT JOIN runs r ON r.id=j.run_id WHERE o.slug=? AND j.status IN ({','.join('?' for _ in wanted)}) "
+                      f"ORDER BY j.created_at DESC LIMIT ?", (org, *wanted, limit))
+    runners = {x["id"]: x for x in db.rows(c, "SELECT r.id, r.name, r.hostname, r.version, r.last_seen FROM runners r JOIN orgs o "
+                                              "ON o.id=r.org_id WHERE o.slug=?", (org,))}
+    for j in rows:
+        j["runner"] = _runner_view(runners.get(j["runner_id"]), now)
+    return rows
diff --git a/viewer/api_write.py b/viewer/api_write.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7f562b75821ed6ca039089894823c977ac6c85b
--- /dev/null
+++ b/viewer/api_write.py
@@ -0,0 +1,1028 @@
+"""Write API for the workspace: what the CLI, the SDK, trainers and runners call.
+
+Every call needs `Authorization: Bearer <token>` (see `posttrain login`), except when the server
+runs with POSTTRAIN_OPEN=1 (a single-user local server; `posttrain server` sets it on localhost).
+Reads go through the same endpoints as every other source, with `?source=workspace`.
+"""
+import json
+import os
+import re
+import secrets
+import time
+
+from fastapi import APIRouter, Body, Header, HTTPException, Request
+
+from . import db, workspace
+from . import stages as S
+
+router = APIRouter(prefix="/api/v3")
+TERMINAL = {"completed", "failed", "stopped"}
+KINDS = {"sft", "dpo", "rl", "distill", "rm", "eval"}
+
+
+def new_id(prefix):
+    return f"{prefix}_{secrets.token_hex(6)}"
+
+
+def user(authorization: str = Header(default="")):
+    token = authorization.split(" ", 1)[1].strip() if authorization.lower().startswith("bearer ") else ""
+    u = workspace.check_token(token) if token else None
+    if u:
+        return u
+    if os.environ.get("POSTTRAIN_OPEN") == "1":
+        return {"id": "local", "name": "local"}
+    raise HTTPException(401, "Missing or invalid API token. Run `posttrain login` or pass Authorization: Bearer <token>.")
+
+
+def auth(request: Request, run_id=None, allow_run_token=False, allow_runner=False):
+    """The caller; run-scoped tokens may only touch their own run, runner tokens only runner/job/run endpoints."""
+    u = user(request.headers.get("authorization", ""))
+    scope = u.get("scope") or ""
+    if scope.startswith("run:"):
+        if not (allow_run_token and run_id and scope == f"run:{run_id}"):
+            raise HTTPException(403, "This token belongs to one run and can only report for that run.")
+    elif scope.startswith("runner:") and not (allow_runner or allow_run_token):
+        raise HTTPException(403, "Runner tokens can only claim, watch and report runs.")
+    return u
+
+
+def eval_caller(request):
+    """The caller of an eval write, and the run its token is scoped to (an eval job holds its run's token), if any."""
+    u = user(request.headers.get("authorization", ""))
+    scope = u.get("scope") or ""
+    if scope.startswith("run:"):
+        return u, scope[4:]
+    auth(request)  # user tokens (and open mode); runner tokens are refused as elsewhere
+    return u, None
+
+
+def dumps(v):
+    return json.dumps(v, separators=(",", ":")) if isinstance(v, (dict, list)) else v
+
+
+def project_row(conn, org, project):
+    p = db.one(conn, "SELECT p.* FROM projects p JOIN orgs o ON o.id=p.org_id WHERE o.slug=? AND p.slug=?", (org, project))
+    if not p:
+        raise HTTPException(404, f"No project {org}/{project} in the workspace. Create it with `posttrain init`.")
+    return p
+
+
+def run_row(conn, run_id):
+    r = db.one(conn, "SELECT * FROM runs WHERE id=?", (run_id,))
+    if not r:
+        raise HTTPException(404, f"No run {run_id}.")
+    return r
+
+
+def insert(conn, table, rec):
+    rec = {k: dumps(v) for k, v in rec.items()}
+    conn.execute(f"INSERT OR REPLACE INTO {table} ({','.join(rec)}) VALUES ({','.join('?' for _ in rec)})", tuple(rec.values()))
+
+
+HF_REPO = re.compile(r"[A-Za-z0-9][\w.-]*/[\w.-]+")
+
+
+def resolve_model(conn, pid, ref, kind="base"):
+    """A model id for a model id, name or HF repo; a checkpoint this project saved (its path, or RUN:STEP);
+    or a run (its output model). Anything else is registered as a new model, so lineage is kept."""
+    if not ref:
+        return None
+    m = db.one(conn, "SELECT id FROM models WHERE project_id=? AND (id=? OR name=? OR hf_repo=?)", (pid, ref, ref, ref))
+    if m:
+        return m["id"]
+    run_ref, _, step = ref.rpartition(":") if re.search(r":\d+$", ref) else (ref, "", "")
+    c = db.one(conn, "SELECT c.* FROM checkpoints c JOIN runs r ON r.id=c.run_id WHERE r.project_id=? AND "
+                     "(c.path=? OR ((r.id=? OR r.name=?) AND c.step=?)) ORDER BY c.created_at DESC LIMIT 1",
+               (pid, ref, run_ref, run_ref, int(step) if step else -1))
+    if c:
+        if c["model_id"]:
+            return c["model_id"]
+        r = run_row(conn, c["run_id"])
+        mid = new_id("model")
+        insert(conn, "models", {"id": mid, "project_id": pid, "name": f"{r['name']} step {c['step']}", "kind": "checkpoint",
+                                "hf_repo": None, "parent_id": r["base_model_id"], "run_id": r["id"], "step": c["step"],
+                                "stage": r["stage"], "created_at": time.time(), "status": "available", "notes": c["path"], "source": ""})
+        conn.execute("UPDATE checkpoints SET model_id=? WHERE id=?", (mid, c["id"]))
+        return mid
+    r = db.one(conn, "SELECT output_model_id FROM runs WHERE project_id=? AND (id=? OR name=?) AND output_model_id IS NOT NULL "
+                     "ORDER BY started_at DESC LIMIT 1", (pid, ref, ref))
+    if r:
+        return r["output_model_id"]
+    hub = bool(HF_REPO.fullmatch(ref)) and not ref.startswith((".", "~"))
+    mid = new_id("model")
+    insert(conn, "models", {"id": mid, "project_id": pid, "name": ref, "kind": kind if hub else "checkpoint",
+                            "hf_repo": ref if hub else None, "notes": "" if hub else ref,
+                            "created_at": time.time(), "status": "available"})
+    return mid
+
+
+def resolve_input(conn, pid, kind, ref):
+    table = "datasets" if kind == "dataset" else "environments"
+    r = db.one(conn, f"SELECT id FROM {table} WHERE project_id=? AND (id=? OR name=?)", (pid, ref, ref))
+    if not r:
+        raise HTTPException(404, f"No {kind} named {ref!r} in this project. Add it first (`posttrain {'data' if kind == 'dataset' else 'env'} add`).")
+    return r["id"]
+
+
+EVENT_BODY_MAX = 1500
+
+
+def event(conn, run_id, kind, title, body="", severity="info", step=None, t=None):
+    body = body or ""
+    if len(body) > EVENT_BODY_MAX:   # whole configs or tracebacks belong in Config and Logs, not in the activity feed
+        body = body[:EVENT_BODY_MAX].rstrip() + f"… ({len(body) - EVENT_BODY_MAX:,} more characters in the run's Logs or Config)"
+    insert(conn, "run_events", {"run_id": run_id, "t": t or time.time(), "step": step, "kind": kind, "severity": severity,
+                                "title": title, "body": body})
+
+
+def summarize_reason(conn, run_id, reason):
+    """A one-line reason for the run header and the activity feed. A multi-line reason (a traceback, the last lines
+    of a log) goes to the run's Logs in full, and the summary keeps its last meaningful line."""
+    reason = (reason or "").strip()
+    if "\n" not in reason and len(reason) <= 300:
+        return reason
+    lines = [ln.rstrip() for ln in reason.splitlines() if ln.strip()]
+    seq = conn.execute("SELECT coalesce(max(seq), 0) FROM logs WHERE run_id=?", (run_id,)).fetchone()[0]
+    conn.executemany("INSERT INTO logs (run_id, seq, t, stream, text) VALUES (?,?,?,?,?)",
+                     [(run_id, seq + i + 1, time.time(), "stderr", ln[:4000]) for i, ln in enumerate(lines[-200:])])
+    last = next((ln.strip() for ln in reversed(lines) if not ln.strip().startswith(("File ", "^", "~"))), lines[-1].strip())
+    first = lines[0].strip().rstrip(":")
+    # wrap's reasons start with a summary ("exited with code 3"); a bare traceback starts with "Traceback"
+    head = last if first.startswith("Traceback") or first == last else f"{first}: {last}"
+    return (head[:280] + ("…" if len(head) > 280 else "")) + " (full output in the Logs tab)"
+
+
+def seen(conn, r):
+    """Any report from the job (metrics, logs, steps...) proves it is alive, not only heartbeats."""
+    now = time.time()
+    conn.execute("UPDATE runs SET last_seen=?, updated_at=? WHERE id=?", (now, now, r["id"]))
+    if r["status"] == "stalled":
+        conn.execute("UPDATE runs SET status='running', status_reason='' WHERE id=? AND status='stalled'", (r["id"],))
+        event(conn, r["id"], "notice", "Reporting", "Reports resumed.")
+
+
+# ------------------------------------------------------------------ identity and tokens
+
+@router.get("/whoami")
+def whoami(request: Request):
+    u = auth(request)
+    return {"user": u, "open": os.environ.get("POSTTRAIN_OPEN") == "1", "workspace": str(workspace.path())}
+
+
+@router.post("/tokens")
+def create_token(request: Request, payload: dict = Body(default={})):
+    """A user token, or with {"runner": true, "targets": [...]} a runner token."""
+    u = auth(request)
+    scope = f"runner:{','.join(payload.get('targets', []))}" if payload.get("runner") else None
+    expires = None if payload.get("expires") == "never" or scope else time.time() + 90 * 86400
+    return {"token": workspace.issue_token(payload.get("name", "cli"), payload.get("user") or u["name"], payload.get("email", ""), scope, expires),
+            "expires": expires, "scope": scope}
+
+
+@router.post("/tokens/revoke")
+def revoke_token(request: Request, payload: dict = Body(...)):
+    auth(request)
+    return {"revoked": workspace.revoke_token(payload["prefix"])}
+
+
+@router.get("/tokens")
+def tokens(request: Request):
+    auth(request)
+    return workspace.list_tokens()
+
+
+# ------------------------------------------------------------------ projects and inputs
+
+def _settings_payload(payload):
+    """Validated project settings from a request (PRD 3: base model, planned stages, quick and release suites, budget)."""
+    out, suites = {}, {}
+    try:
+        if payload.get("base_model"):
+            out["base_model"] = str(payload["base_model"]).strip()
+        if payload.get("stages") is not None:
+            out["stages"] = S.normalize_stages(payload["stages"])
+        budget = payload.get("budget_usd", payload.get("budget"))
+        if budget not in (None, ""):
+            try:
+                out["budget_usd"] = float(budget)
+            except (TypeError, ValueError):
+                raise S.Problem(422, f"budget must be a number of US dollars, not {budget!r}")
+            if out["budget_usd"] < 0:
+                raise S.Problem(422, "budget must be 0 or more")
+        for name in ("quick", "release"):
+            if payload.get(name) not in (None, "", []):
+                suites[name] = [b["spec"] for b in S.parse_benches(payload[name])]
+        for name, benches in (payload.get("suites") or {}).items():
+            if benches not in (None, "", []):
+                if not S.SUITE_NAME.fullmatch(str(name)):
+                    raise S.Problem(422, f"suite name {name!r}: lowercase letters, digits, - and _")
+                suites[name] = [b["spec"] for b in S.parse_benches(benches)]
+    except S.Problem as e:
+        raise HTTPException(e.status, str(e))
+    return out, suites
+
+
+def _apply_settings(conn, pid, settings, suites, user):
+    changed = S.put_settings(conn, pid, settings, user)
+    if settings.get("base_model"):
+        resolve_model(conn, pid, settings["base_model"], kind="base")     # the base model is a model of the project
+    for name, benches in suites.items():
+        S.set_suite(conn, pid, name, benches, user)
+    if changed or suites:
+        S.audit(conn, pid, user, "settings", pid, {"changed": changed, "suites": suites})
+
+
+def settings_response(conn, org, project, p):
+    s = S.get_settings(conn, p["id"])
+    su = S.get_suites(conn, p["id"])
+    return {"schema": "posttrain.v1.project_settings", "id": p["id"], "url": f"/dashboard/{org}/{project}/settings",
+            "project": f"{org}/{project}", "name": p.get("name"), **s,
+            "suites": {k: {"benchmarks": [b["spec"] for b in v["benchmarks"]], "defined": v["defined"], "inherits": v["inherits"]}
+                       for k, v in su.items()},
+            "aliases": S.aliases(conn, p["id"])}
+
+
+@router.post("/projects")
+def create_project(request: Request, payload: dict = Body(...)):
+    """Create (or join) a project. Optional settings (PRD 3, 5.2 `init`): base_model, stages (["sft", "dpo", "rl"] or
+    "sft,dpo,rl"; "none" plans none), quick and release (benchmark lists, or suites: {name: [...]}), budget_usd."""
+    u = auth(request)
+    org, slug = payload.get("org"), payload.get("slug")
+    if not org or not slug:
+        raise HTTPException(422, "org and slug are required.")
+    settings, suites = _settings_payload(payload)
+
+    def fn(conn):
+        o = db.one(conn, "SELECT id FROM orgs WHERE slug=?", (org,))
+        oid = o["id"] if o else new_id("org")
+        if not o:
+            insert(conn, "orgs", {"id": oid, "slug": org, "name": payload.get("org_name") or org, "about": "", "url": ""})
+        p = db.one(conn, "SELECT id FROM projects WHERE org_id=? AND slug=?", (oid, slug))
+        created = not p
+        pid = p["id"] if p else new_id("proj")
+        if created:
+            insert(conn, "projects", {"id": pid, "org_id": oid, "slug": slug, "name": payload.get("name") or slug,
+                                      "summary": payload.get("summary", ""), "created_at": time.time(), "sources": [],
+                                      "data_note": f"Created by {u['name']}.", "pins": []})
+            S.audit(conn, pid, u["name"], "create_project", pid, {"org": org, "slug": slug})
+        _apply_settings(conn, pid, settings, suites, u["name"])
+        row = db.one(conn, "SELECT * FROM projects WHERE id=?", (pid,))
+        return {"project_id": pid, "created": created, "settings": settings_response(conn, org, slug, row)}
+    res = workspace.write(fn)
+    return {**res, "id": res["project_id"], "schema": "posttrain.v1.project", "project": f"{org}/{slug}", "url": f"/dashboard/{org}/{slug}"}
+
+
+@router.post("/p/{org}/{project}/settings")
+def update_settings(org: str, project: str, request: Request, payload: dict = Body(...)):
+    """Change a project's base model, planned stages, budget or suites (only the keys given)."""
+    u = auth(request)
+    settings, suites = _settings_payload(payload)
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        _apply_settings(conn, p["id"], settings, suites, u["name"])
+        return settings_response(conn, org, project, p)
+    return workspace.write(fn)
+
+
+def _write(fn):
+    """workspace.write, with the rules' Problems (viewer/stages.py) answered as HTTP errors."""
+    try:
+        return workspace.write(fn)
+    except S.Problem as e:
+        raise HTTPException(e.status, str(e))
+
+
+@router.post("/p/{org}/{project}/suites")
+def set_suite(org: str, project: str, request: Request, payload: dict = Body(...)):
+    """{"name": "release", "benchmarks": ["arc_easy?limit=200", "env:arith-heldout?k=4"]} (or "a,b"). Replaces the suite."""
+    u = auth(request)
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        parsed, warnings = S.set_suite(conn, p["id"], payload.get("name"), payload.get("benchmarks") or payload.get("bench") or [], u["name"])
+        S.audit(conn, p["id"], u["name"], "suite", payload.get("name"), {"benchmarks": [b["spec"] for b in parsed]})
+        su = S.get_suites(conn, p["id"])[str(payload.get("name")).strip().lower()]
+        return {**S.suite_object(org, project, p["id"], su), "warnings": warnings}
+    return _write(fn)
+
+
+def _stage_table(conn, org, project, p):
+    from . import api_ui          # lazy: api_ui imports this module
+    return S.stage_table(conn, org, project, p, "workspace", api_ui.compute_state(org))
+
+
+@router.post("/p/{org}/{project}/stages/{stage}/skip")
+def skip_stage(org: str, project: str, stage: str, request: Request, payload: dict = Body(default={})):
+    """Mark a stage skipped (`posttrain status --skip STAGE`), recorded with the user, the time and an optional note."""
+    u = auth(request)
+    if stage not in S.STAGES:
+        raise HTTPException(422, f"stage must be one of {', '.join(S.STAGES)}")
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        note = str(payload.get("note") or "").strip()
+        conn.execute("INSERT OR REPLACE INTO stage_state (project_id, stage, skipped, note, by, at) VALUES (?,?,?,?,?,?)",
+                     (p["id"], stage, 1, note, u["name"], time.time()))
+        S.audit(conn, p["id"], u["name"], "skip", stage, {"note": note})
+        return _stage_table(conn, org, project, p)
+    return _write(fn)
+
+
+@router.post("/p/{org}/{project}/stages/{stage}/unskip")
+def unskip_stage(org: str, project: str, stage: str, request: Request):
+    u = auth(request)
+    if stage not in S.STAGES:
+        raise HTTPException(422, f"stage must be one of {', '.join(S.STAGES)}")
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        conn.execute("INSERT OR REPLACE INTO stage_state (project_id, stage, skipped, note, by, at) VALUES (?,?,?,?,?,?)",
+                     (p["id"], stage, 0, "", u["name"], time.time()))
+        S.audit(conn, p["id"], u["name"], "unskip", stage, {})
+        return _stage_table(conn, org, project, p)
+    return _write(fn)
+
+
+@router.post("/p/{org}/{project}/acks")
+def acknowledge(org: str, project: str, request: Request, payload: dict = Body(...)):
+    """Acknowledge a regression: {"model", "suite", "benchmark", "note"} (note required), recorded with the user."""
+    u = auth(request)
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        return S.acknowledge(conn, p["id"], org, project, payload.get("model"), payload.get("suite") or "release",
+                             payload.get("benchmark") or payload.get("bench"), payload.get("note"), u["name"])
+    return _write(fn)
+
+
+@router.post("/p/{org}/{project}/models/promote")
+def promote(org: str, project: str, request: Request, payload: dict = Body(...)):
+    """Promote a checkpoint: {"ref": "RUN[:STEP]", "name", "notes", "replace", "dry_run"} (PRD 4.7)."""
+    u = auth(request)
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        return S.promote(conn, p["id"], org, project, payload.get("ref") or payload.get("run"), payload.get("name") or payload.get("as"),
+                         u["name"], notes=payload.get("notes"), replace=bool(payload.get("replace")), dry_run=bool(payload.get("dry_run")))
+    return _write(fn)
+
+
+@router.post("/p/{org}/{project}/aliases")
+def set_alias(org: str, project: str, request: Request, payload: dict = Body(...)):
+    """Point an alias at a model: {"alias": "production", "model": NAME}. `production` needs a model that passes the
+    model-level deploy checks (promoted, release eval complete, regressions acknowledged)."""
+    u = auth(request)
+    alias = str(payload.get("alias") or "").strip()
+    if not S.SUITE_NAME.fullmatch(alias):
+        raise HTTPException(422, "alias: lowercase letters, digits, - and _")
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        sel = S.resolve_ref(conn, p["id"], payload.get("model"))
+        if not sel or not sel["model"]:
+            raise S.Problem(404, f"No model {payload.get('model')!r} in this project.")
+        if alias == "production":
+            ok, why = S.model_gate(conn, p["id"], sel)
+            if not ok:
+                raise S.Problem(409, f"production can't point at {sel['name']}: {why}")
+        S.set_alias(conn, p["id"], alias, sel["model"]["id"], u["name"])
+        return {"schema": "posttrain.v1.alias", "id": f"{p['id']}:{alias}", "url": f"/dashboard/{org}/{project}/models",
+                "alias": alias, "model": sel["name"], "model_id": sel["model"]["id"], "set_by": u["name"]}
+    return _write(fn)
+
+
+DEPLOYMENT_STATUSES = {"starting", "healthy", "failed", "stopped", "pushed"}
+
+
+def _dep_row(conn, dep_id):
+    d = db.one(conn, "SELECT d.*, m.name AS model_name, p.slug AS project_slug, o.slug AS org_slug FROM deployments d "
+                     "LEFT JOIN models m ON m.id=d.model_id JOIN projects p ON p.id=d.project_id JOIN orgs o ON o.id=p.org_id "
+                     "WHERE d.id=?", (dep_id,))
+    if not d:
+        raise S.Problem(404, f"No deployment {dep_id}.")
+    return d
+
+
+def _deployed(conn, d, user):
+    """A deployment that became healthy (or a Hub push): record the weights' new home, and point production at the
+    model when it passes the model-level deploy checks. Returns what happened to production."""
+    sel = S.resolve_ref(conn, d["project_id"], d["model_id"]) if d.get("model_id") else None
+    if d.get("kind") == "hub" and (d.get("endpoint") or "").startswith("hf://"):
+        repo = d["endpoint"][len("hf://"):]
+        conn.execute("UPDATE models SET hf_repo=coalesce(hf_repo, ?) WHERE id=?", (repo, d["model_id"]))
+        conn.execute("UPDATE promotions SET pushed_to=? WHERE model_id=?", (d["endpoint"], d["model_id"]))
+    if not sel or not sel["model"]:
+        return {"set": False, "reason": "unknown model"}
+    ok, why = S.model_gate(conn, d["project_id"], sel)
+    if not ok:
+        return {"set": False, "model": sel["name"], "reason": why}
+    S.set_alias(conn, d["project_id"], "production", sel["model"]["id"], user)
+    return {"set": True, "model": sel["name"]}
+
+
+@router.post("/p/{org}/{project}/deployments")
+def create_deployment(org: str, project: str, request: Request, payload: dict = Body(...)):
+    """Record a deployment the CLI starts (kind vllm) or a Hub push (kind hub, status pushed): {"name", "model",
+    "target", "kind", "gpus", "gpu", "serving", "command", "checks", "endpoint", "status", "handle", "message"}."""
+    u = auth(request)
+    status = payload.get("status") or "starting"
+    if status not in DEPLOYMENT_STATUSES:
+        raise HTTPException(422, f"status must be one of {', '.join(sorted(DEPLOYMENT_STATUSES))}")
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        sel = S.resolve_ref(conn, p["id"], payload.get("model"))
+        if not sel or not sel["model"]:
+            raise S.Problem(404, f"No model {payload.get('model')!r} in this project.")
+        name = S.slug(payload.get("name") or sel["name"])
+        live = db.one(conn, "SELECT id, status FROM deployments WHERE project_id=? AND name=? AND status IN ('starting','healthy','serving')",
+                      (p["id"], name))
+        if live and payload.get("kind", "vllm") != "hub":
+            raise S.Problem(409, f"deployment {name} is {live['status']}; stop it first (posttrain deployments stop {name}) or pick another --name")
+        did = new_id("dep")
+        now = time.time()
+        insert(conn, "deployments", {"id": did, "project_id": p["id"], "model_id": sel["model"]["id"], "name": name, "status": status,
+                                     "endpoint": payload.get("endpoint"), "gpu": payload.get("gpu") or "GPU", "replicas": 1,
+                                     "created_at": now, "kind": payload.get("kind") or "vllm", "target": payload.get("target"),
+                                     "handle": payload.get("handle"), "serving": payload.get("serving"), "smoke": payload.get("smoke"),
+                                     "message": payload.get("message") or "", "command": payload.get("command"),
+                                     "checks": payload.get("checks"), "created_by": u["name"], "updated_at": now})
+        S.audit(conn, p["id"], u["name"], "deploy", did, {"name": name, "model": sel["name"], "target": payload.get("target"),
+                                                          "kind": payload.get("kind") or "vllm", "status": status})
+        d = _dep_row(conn, did)
+        production = _deployed(conn, d, u["name"]) if status in ("healthy", "pushed") else None
+        return {**S.deployment_object(org, project, _dep_row(conn, did)), "production": production}
+    return _write(fn)
+
+
+@router.post("/deployments/{dep_id}/status")
+def deployment_status(dep_id: str, request: Request, payload: dict = Body(...)):
+    """Update a deployment: {"status": starting|healthy|failed|stopped|pushed, "endpoint", "handle", "smoke", "message"}."""
+    u = auth(request)
+    status = payload.get("status")
+    if status is not None and status not in DEPLOYMENT_STATUSES:
+        raise HTTPException(422, f"status must be one of {', '.join(sorted(DEPLOYMENT_STATUSES))}")
+
+    def fn(conn):
+        d = _dep_row(conn, dep_id)
+        sets = {k: dumps(payload[k]) for k in ("status", "endpoint", "handle", "smoke", "message", "serving", "command") if k in payload}
+        sets["updated_at"] = time.time()
+        conn.execute(f"UPDATE deployments SET {','.join(k + '=?' for k in sets)} WHERE id=?", (*sets.values(), d["id"]))
+        d = _dep_row(conn, d["id"])
+        production = _deployed(conn, d, u["name"]) if status in ("healthy", "pushed") else None
+        if status:
+            S.audit(conn, d["project_id"], u["name"], f"deployment_{status}", d["id"], {"message": payload.get("message")})
+        return {**S.deployment_object(d["org_slug"], d["project_slug"], _dep_row(conn, d["id"])), "production": production}
+    return _write(fn)
+
+
+@router.post("/deployments/{dep_id}/stop")
+def deployment_stop(dep_id: str, request: Request, payload: dict = Body(default={})):
+    """Mark a deployment stopped (the CLI has ended the server process), recorded with the user."""
+    u = auth(request)
+
+    def fn(conn):
+        d = _dep_row(conn, dep_id)
+        now = time.time()
+        conn.execute("UPDATE deployments SET status='stopped', stopped_at=?, stopped_by=?, updated_at=?, message=? WHERE id=?",
+                     (now, u["name"], now, payload.get("message") or f"stopped by {u['name']}", d["id"]))
+        S.audit(conn, d["project_id"], u["name"], "deployment_stop", d["id"], {"name": d["name"]})
+        return S.deployment_object(d["org_slug"], d["project_slug"], _dep_row(conn, d["id"]))
+    return _write(fn)
+
+
+@router.post("/p/{org}/{project}/datasets")
+def add_dataset(org: str, project: str, request: Request, payload: dict = Body(...)):
+    auth(request)
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        existing = db.one(conn, "SELECT id FROM datasets WHERE project_id=? AND name=? AND coalesce(version,'')=?",
+                          (p["id"], payload["name"], payload.get("version", "")))
+        did = existing["id"] if existing else new_id("ds")
+        if existing:
+            for t in ("dataset_sources", "dataset_rows"):
+                conn.execute(f"DELETE FROM {t} WHERE dataset_id=?", (did,))
+        insert(conn, "datasets", {"id": did, "project_id": p["id"], "name": payload["name"], "kind": payload.get("kind", "sft"),
+                                  "version": payload.get("version", ""), "parent_id": payload.get("parent_id"),
+                                  "rows": payload.get("rows"), "tokens": payload.get("tokens"), "license": payload.get("license"),
+                                  "hf_repo": payload.get("hf_repo"), "description": payload.get("description", ""),
+                                  "created_at": time.time(), "processing": payload.get("processing", []),
+                                  "fields": payload.get("fields"), "source": payload.get("source", ""), "provenance": "published"})
+        for s in payload.get("sources", []):
+            insert(conn, "dataset_sources", {"dataset_id": did, "name": s.get("name"), "category": s.get("category"),
+                                             "rows": s.get("rows"), "tokens": s.get("tokens"), "synthetic": s.get("synthetic"),
+                                             "generator": s.get("generator"), "license": s.get("license"), "url": s.get("url")})
+        for i, r in enumerate(payload.get("samples", [])[:200]):
+            insert(conn, "dataset_rows", {"dataset_id": did, "idx": i, "source": r.get("source"), "category": r.get("category"),
+                                          "data": r.get("data", r), "tokens": r.get("tokens")})
+        return {"dataset_id": did, "updated": bool(existing)}
+    return workspace.write(fn)
+
+
+@router.post("/p/{org}/{project}/environments")
+def add_environment(org: str, project: str, request: Request, payload: dict = Body(...)):
+    auth(request)
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        existing = db.one(conn, "SELECT id FROM environments WHERE project_id=? AND name=?", (p["id"], payload["name"]))
+        eid = existing["id"] if existing else new_id("env")
+        gid = None
+        if payload.get("grader"):
+            g = payload["grader"]
+            gid = new_id("grader")
+            insert(conn, "graders", {"id": gid, "project_id": p["id"], "name": g.get("name", payload["name"] + "-grader"),
+                                     "kind": g.get("kind", "unit_tests"), "description": g.get("description", ""),
+                                     "components": g.get("components", []), "formula": g.get("formula", "")})
+        if existing:
+            conn.execute("DELETE FROM tasks WHERE env_id=?", (eid,))
+        tasks = payload.get("tasks", [])
+        insert(conn, "environments", {"id": eid, "project_id": p["id"], "name": payload["name"], "domain": payload.get("domain", "other"),
+                                      "version": payload.get("version", ""), "description": payload.get("description", ""),
+                                      "harness": payload.get("harness"), "tools": payload.get("tools", []), "grader_id": gid,
+                                      "reward_kind": payload.get("reward_kind", "binary"), "sandbox": payload.get("sandbox"),
+                                      "task_count": payload.get("task_count") or len(tasks), "created_at": time.time(),
+                                      "source": payload.get("source", ""), "provenance": "published", "checks": payload.get("checks")})
+        for t in tasks[:5000]:
+            insert(conn, "tasks", {"id": t.get("id") or new_id("task"), "env_id": eid, "name": t["name"],
+                                   "instruction": t.get("instruction", ""), "difficulty": t.get("difficulty"), "tags": t.get("tags", []),
+                                   "status": t.get("status", "ok"), "status_reason": t.get("status_reason", ""),
+                                   "oracle_score": t.get("oracle_score"), "noop_score": t.get("noop_score"),
+                                   "reruns": t.get("reruns"), "rerun_agree": t.get("rerun_agree"), "base_pass": t.get("base_pass"),
+                                   "latest_pass": t.get("latest_pass"), "attempts": t.get("attempts")})
+        return {"environment_id": eid, "updated": bool(existing), "tasks": min(len(tasks), 5000)}
+    return workspace.write(fn)
+
+
+@router.post("/p/{org}/{project}/models")
+def add_model(org: str, project: str, request: Request, payload: dict = Body(...)):
+    auth(request)
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        mid = new_id("model")
+        parent = resolve_model(conn, p["id"], payload.get("parent")) if payload.get("parent") else None
+        insert(conn, "models", {"id": mid, "project_id": p["id"], "name": payload["name"], "kind": payload.get("kind", "checkpoint"),
+                                "hf_repo": payload.get("hf_repo"), "arch": payload.get("arch"), "params_total": payload.get("params_total"),
+                                "params_active": payload.get("params_active"), "context_len": payload.get("context_len"),
+                                "parent_id": parent, "run_id": payload.get("run_id"), "step": payload.get("step"),
+                                "stage": payload.get("stage"), "created_at": time.time(), "status": payload.get("status", "available"),
+                                "notes": payload.get("notes", ""), "source": payload.get("source", "")})
+        return {"model_id": mid}
+    return workspace.write(fn)
+
+
+# ------------------------------------------------------------------ runs
+
+@router.post("/p/{org}/{project}/runs")
+def create_run(org: str, project: str, request: Request, payload: dict = Body(...)):
+    """Create a run. launch="runner" queues a job for a runner on `target`; otherwise the caller
+    (the CLI or a trainer via the SDK) executes it and reports progress."""
+    u = auth(request)
+    kind = payload.get("kind", "sft")
+    if kind not in KINDS:
+        raise HTTPException(422, f"kind must be one of {sorted(KINDS)}")
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        run_id = payload.get("id") or new_id("run")
+        base = resolve_model(conn, p["id"], payload.get("base_model"))
+        queued = payload.get("launch") == "runner"
+        now = time.time()
+        insert(conn, "runs", {
+            "id": run_id, "project_id": p["id"], "name": payload.get("name") or run_id, "kind": kind,
+            "stage": payload.get("stage") or {"sft": "SFT", "dpo": "Preference", "rl": "RL", "distill": "Distillation", "eval": "Eval"}.get(kind),
+            "algorithm": payload.get("algorithm"), "framework": payload.get("framework"),
+            "status": "queued" if queued else payload.get("status", "running"), "status_reason": "",
+            "base_model_id": base, "output_model_id": None, "started_at": now, "ended_at": None, "updated_at": now,
+            "steps_planned": payload.get("steps_planned"), "steps_done": 0, "primary_metric": payload.get("primary_metric"),
+            "gpu": payload.get("gpu"), "gpus": payload.get("gpus"), "cost_usd": None, "cost_rate": payload.get("cost_rate"),
+            "owner": u["name"], "tags": payload.get("tags", []), "code_ref": payload.get("code_ref", ""),
+            "config": payload.get("config", ""), "config_format": payload.get("config_format", "toml"),
+            "hyperparams": payload.get("hyperparams", {}), "parent_run_id": payload.get("parent_run_id"),
+            "group_name": payload.get("group"), "description": payload.get("description", ""), "source": payload.get("target", ""),
+            "provenance": "published"})
+        for inp in payload.get("inputs", []):
+            ref_id = resolve_input(conn, p["id"], inp.get("kind", "dataset"), inp["ref"])
+            insert(conn, "run_inputs", {"run_id": run_id, "kind": inp.get("kind", "dataset"), "ref_id": ref_id, "weight": inp.get("weight", 1.0)})
+        if payload.get("metric_defs"):
+            for d in payload["metric_defs"]:
+                insert(conn, "metric_defs", dict({"project_id": p["id"], "label": d.get("tag"), "description": "", "unit": "", "format": "num3",
+                                                  "grp": d.get("tag", "").split("/")[0], "better": "none", "pinned": 0, "signal": None}, **d))
+        job_id = None
+        if queued or payload.get("target"):
+            job_id = new_id("job")
+            insert(conn, "jobs", {"id": job_id, "project_id": p["id"], "run_id": run_id, "eval_id": None,
+                                  "name": f"{payload.get('name') or run_id}", "kind": "train" if kind != "eval" else "eval",
+                                  "status": "queued" if queued else "running", "cluster_id": None, "gpu": payload.get("gpu"),
+                                  "gpus": payload.get("gpus"), "nodes": payload.get("nodes"), "started_at": None if queued else now,
+                                  "ended_at": None, "cost_usd": None, "exit": None, "log_tail": "", "target": payload.get("target", "local"),
+                                  "spec": payload.get("spec", {}), "runner_id": None, "external_id": payload.get("external_id"),
+                                  "created_at": now, "claimed_at": None, "cancel": 0, "message": ""})
+        event(conn, run_id, "start" if not queued else "config", "Run created" if not queued else "Queued",
+              f"{kind.upper()} on {payload.get('target') or 'the caller'}" + (f", waiting for a runner" if queued else ""))
+        return {"run_id": run_id, "job_id": job_id, "url": f"/dashboard/{org}/{project}/runs/{run_id}"}
+    res = workspace.write(fn)
+    res["run_token"] = workspace.issue_token(f"run {res['run_id']}", u["name"], scope=f"run:{res['run_id']}", expires=time.time() + 7 * 86400 * 4)
+    return res
+
+
+@router.post("/runs/{run_id}/status")
+def run_status(run_id: str, request: Request, payload: dict = Body(...)):
+    auth(request, run_id, allow_run_token=True)
+    status = payload.get("status")
+    if status not in {"queued", "starting", "running", "stopping", "stalled", "completed", "failed", "stopped"}:
+        raise HTTPException(422, "status must be queued, starting, running, stopping, stalled, completed, failed or stopped")
+
+    def fn(conn):
+        r = run_row(conn, run_id)
+        now = time.time()
+        if r["status"] in TERMINAL and status != r["status"]:
+            # e.g. a runner starting a run that was canceled while it was being picked up: keep the end, tell the job to stop
+            return {"run_id": run_id, "status": r["status"], "ignored": True, "stop": True}
+        if r["status"] == "stopping" and status in ("queued", "starting", "running", "stalled"):
+            # a stop was requested: the job reporting that it runs does not undo it
+            conn.execute("UPDATE runs SET last_seen=?, updated_at=? WHERE id=?", (now, now, run_id))
+            return {"run_id": run_id, "status": "stopping", "ignored": True, "stop": True}
+        reason = summarize_reason(conn, run_id, payload.get("reason", ""))
+        sets = {"status": status, "status_reason": reason, "updated_at": now, "last_seen": now}
+        if status in TERMINAL:
+            sets["ended_at"] = now
+        if status == "running" and r["status"] == "queued":
+            sets["started_at"] = now
+        if payload.get("cost_usd") is not None:
+            sets["cost_usd"] = payload["cost_usd"]
+        if payload.get("output_model"):
+            mid = new_id("model")
+            insert(conn, "models", {"id": mid, "project_id": r["project_id"], "name": payload["output_model"], "kind": "checkpoint",
+                                    "hf_repo": payload.get("output_repo"), "parent_id": r["base_model_id"], "run_id": run_id,
+                                    "step": r["steps_done"], "stage": r["stage"], "created_at": now, "status": "available",
+                                    "notes": "", "source": ""})
+            sets["output_model_id"] = mid
+        conn.execute(f"UPDATE runs SET {','.join(k + '=?' for k in sets)} WHERE id=?", (*sets.values(), run_id))
+        if status in TERMINAL or status == "running":
+            conn.execute("UPDATE jobs SET status=?, ended_at=CASE WHEN ? THEN ? ELSE ended_at END, "
+                         "started_at=coalesce(started_at, ?) WHERE run_id=? AND status NOT IN ('completed','failed','stopped')",
+                         (status, status in TERMINAL, now, now, run_id))
+        if status in TERMINAL:
+            event(conn, run_id, "end", {"completed": "Run completed", "failed": "Run failed", "stopped": "Run stopped"}[status],
+                  reason, "error" if status == "failed" else "info", r["steps_done"])
+        elif status == "running" and r["status"] != "running":
+            event(conn, run_id, "start", "Running", reason)
+        return {"run_id": run_id, "status": status}
+    return workspace.write(fn)
+
+
+@router.post("/runs/{run_id}/heartbeat")
+def run_heartbeat(run_id: str, request: Request, payload: dict = Body(default={})):
+    """Sent every 30 s by the job (posttrain wrap / the SDK). Returns whether someone asked to stop the run."""
+    auth(request, run_id, allow_run_token=True)
+
+    def fn(conn):
+        r = run_row(conn, run_id)
+        now = time.time()
+        status = r["status"]
+        if status in TERMINAL:
+            return {"stop": True, "status": status}
+        if status in ("queued", "starting", "stalled"):
+            status = "running"
+            event(conn, run_id, "notice", "Reporting" if r["status"] == "stalled" else "Running",
+                  "Reports resumed." if r["status"] == "stalled" else "The job started reporting.")
+        conn.execute("UPDATE runs SET last_seen=?, updated_at=?, status=CASE WHEN status IN ('queued','starting','stalled') THEN ? ELSE status END, "
+                     "started_at=CASE WHEN status='queued' THEN ? ELSE started_at END WHERE id=?", (now, now, status, now, run_id))
+        conn.execute("UPDATE jobs SET status='running', started_at=coalesce(started_at, ?) WHERE run_id=? AND status IN ('queued','starting')", (now, run_id))
+        stop = conn.execute("SELECT max(coalesce(cancel,0)) FROM jobs WHERE run_id=?", (run_id,)).fetchone()[0]
+        return {"stop": bool(stop) or r["status"] == "stopping", "status": status}
+    return workspace.write(fn)
+
+
+@router.post("/runs/{run_id}/metrics")
+def run_metrics(run_id: str, request: Request, payload: dict = Body(...)):
+    """{"points": [[tag, step, value], ...]} or {"step": n, "values": {tag: value}}."""
+    auth(request, run_id, allow_run_token=True)
+    pts = [tuple(x) for x in payload.get("points", [])]
+    if "values" in payload:
+        pts += [(k, payload["step"], v) for k, v in payload["values"].items()]
+
+    def fn(conn):
+        r = run_row(conn, run_id)
+        seen(conn, r)
+        good = [(run_id, str(t), int(s), float(v)) for t, s, v in pts if isinstance(v, (int, float)) and v == v]
+        conn.executemany("INSERT OR REPLACE INTO metrics (run_id, tag, step, value) VALUES (?,?,?,?)", good)
+        if good:
+            top = max(s for _, _, s, _ in good)
+            conn.execute("UPDATE runs SET steps_done=max(coalesce(steps_done,0), ?), updated_at=?, "
+                         "primary_metric=coalesce(primary_metric, ?) WHERE id=?", (top, time.time(), payload.get("primary") or good[0][1], run_id))
+        return {"stored": len(good)}
+    return workspace.write(fn)
+
+
+@router.post("/runs/{run_id}/steps")
+def run_steps(run_id: str, request: Request, payload: dict = Body(...)):
+    auth(request, run_id, allow_run_token=True)
+
+    def fn(conn):
+        seen(conn, run_row(conn, run_id))
+        for row in payload.get("rows", []):
+            insert(conn, "run_steps", dict({"run_id": run_id, "phase": "train"}, **row))
+        return {"stored": len(payload.get("rows", []))}
+    return workspace.write(fn)
+
+
+@router.post("/runs/{run_id}/rollouts")
+def run_rollouts(run_id: str, request: Request, payload: dict = Body(...)):
+    """{"rows": [protocol rollout fields...], "transcripts": {rollout_id: messages}}"""
+    auth(request, run_id, allow_run_token=True)
+
+    def fn(conn):
+        r = run_row(conn, run_id)
+        seen(conn, r)
+        ids = []
+        for row in payload.get("rows", [])[:5000]:
+            rid = row.get("id") or new_id("roll")
+            ids.append(rid)
+            insert(conn, "rollouts", dict({"id": rid, "run_id": run_id, "phase": "train", "model_id": r["base_model_id"],
+                                           "trained": 1, "seed": 0}, **row))
+        for rid, msgs in (payload.get("transcripts") or {}).items():
+            insert(conn, "transcripts", {"rollout_id": rid, "messages": json.dumps(msgs)})
+        return {"stored": len(ids), "ids": ids}
+    return workspace.write(fn)
+
+
+@router.post("/runs/{run_id}/events")
+def run_events(run_id: str, request: Request, payload: dict = Body(...)):
+    auth(request, run_id, allow_run_token=True)
+
+    def fn(conn):
+        seen(conn, run_row(conn, run_id))
+        for e in payload.get("events", []):
+            event(conn, run_id, e.get("kind", "notice"), e.get("title", ""), e.get("body", ""), e.get("severity", "info"),
+                  e.get("step"), e.get("t"))
+        return {"stored": len(payload.get("events", []))}
+    return workspace.write(fn)
+
+
+@router.post("/runs/{run_id}/checkpoints")
+def run_checkpoint(run_id: str, request: Request, payload: dict = Body(...)):
+    auth(request, run_id, allow_run_token=True)
+
+    def fn(conn):
+        seen(conn, run_row(conn, run_id))
+        cid = new_id("ckpt")
+        insert(conn, "checkpoints", {"id": cid, "run_id": run_id, "step": payload.get("step"), "model_id": None,
+                                     "path": payload.get("path", ""), "size_gb": payload.get("size_gb"), "created_at": time.time(), "kept": 1})
+        event(conn, run_id, "checkpoint", f"Checkpoint step {payload.get('step')}", payload.get("path", ""), step=payload.get("step"))
+        return {"checkpoint_id": cid}
+    return workspace.write(fn)
+
+
+@router.post("/runs/{run_id}/logs")
+def post_logs(run_id: str, request: Request, payload: dict = Body(...)):
+    auth(request, run_id, allow_run_token=True)
+
+    def fn(conn):
+        seen(conn, run_row(conn, run_id))
+        seq = conn.execute("SELECT coalesce(max(seq), 0) FROM logs WHERE run_id=?", (run_id,)).fetchone()[0]
+        lines = payload.get("lines", [])
+        conn.executemany("INSERT INTO logs (run_id, seq, t, stream, text) VALUES (?,?,?,?,?)",
+                         [(run_id, seq + i + 1, x.get("t") or time.time(), x.get("stream", "stdout"), str(x.get("text", ""))[:4000])
+                          for i, x in enumerate(lines)])
+        return {"stored": len(lines), "last_seq": seq + len(lines)}
+    return workspace.write(fn)
+
+
+@router.get("/runs/{run_id}/logs")
+def get_logs(run_id: str, after: int = 0, limit: int = 2000):
+    conn = workspace.connect()
+    return db.rows(conn, "SELECT seq, t, stream, text FROM logs WHERE run_id=? AND seq>? ORDER BY seq LIMIT ?", (run_id, after, limit))
+
+
+@router.post("/runs/{run_id}/cancel")
+def cancel_run(run_id: str, request: Request):
+    auth(request, run_id, allow_runner=True)
+
+    def fn(conn):
+        r = run_row(conn, run_id)
+        if r["status"] in TERMINAL:
+            return {"run_id": run_id, "status": r["status"]}
+        queued = db.rows(conn, "SELECT id FROM jobs WHERE run_id=? AND status='queued'", (run_id,))
+        claimed = db.rows(conn, "SELECT id FROM jobs WHERE run_id=? AND status IN ('starting','running')", (run_id,))
+        conn.execute("UPDATE jobs SET cancel=1 WHERE run_id=? AND status NOT IN ('completed','failed','stopped')", (run_id,))
+        if not claimed and (queued or r["status"] == "queued"):
+            conn.execute("UPDATE jobs SET status='stopped', ended_at=? WHERE run_id=? AND status='queued'", (time.time(), run_id))
+            conn.execute("UPDATE runs SET status='stopped', status_reason='Canceled before it started.', ended_at=?, updated_at=? WHERE id=?",
+                         (time.time(), time.time(), run_id))
+            event(conn, run_id, "end", "Run stopped", "Canceled before it started.")
+            return {"run_id": run_id, "status": "stopped"}
+        conn.execute("UPDATE runs SET status='stopping', updated_at=? WHERE id=?", (time.time(), run_id))
+        if not db.one(conn, "SELECT id FROM jobs WHERE run_id=?", (run_id,)):
+            # a run reported by the SDK or wrap without a job row: record the stop request on a job so heartbeats see it
+            conn.execute("INSERT INTO jobs (id, project_id, run_id, status, cancel, created_at) VALUES (?,?,?,?,?,?)",
+                         (new_id("job"), r["project_id"], run_id, "running", 1, time.time()))
+        event(conn, run_id, "notice", "Stop requested", "The job will see it at its next heartbeat (within 30 s), save a checkpoint and exit.", "warning", r["steps_done"])
+        return {"run_id": run_id, "status": "stopping"}
+    return workspace.write(fn)
+
+
+@router.get("/runs/{run_id}/cancel")
+def cancel_requested(run_id: str, request: Request):
+    """Polled by a CLI that executes a run directly."""
+    conn = workspace.connect()
+    j = conn.execute("SELECT max(coalesce(cancel,0)) FROM jobs WHERE run_id=?", (run_id,)).fetchone()[0]
+    st = conn.execute("SELECT status FROM runs WHERE id=?", (run_id,)).fetchone()
+    return {"cancel": bool(j) or bool(st and st[0] == "stopping")}
+
+
+# ------------------------------------------------------------------ evals
+
+@router.post("/p/{org}/{project}/evals")
+def create_eval(org: str, project: str, request: Request, payload: dict = Body(...)):
+    """Create (or complete) an eval: benchmark by name (registered if new), model by name or HF id.
+    An eval job may call this with its own run token; the eval is then attached to that run."""
+    u, scoped = eval_caller(request)
+    if scoped:
+        if payload.get("run_id") not in (None, "", scoped):
+            raise HTTPException(403, "This token belongs to one run and can only record evals for that run.")
+        payload = dict(payload, run_id=scoped)
+
+    def fn(conn):
+        p = project_row(conn, org, project)
+        if scoped and run_row(conn, scoped)["project_id"] != p["id"]:
+            raise HTTPException(403, "This token's run is in another project.")
+        b = db.one(conn, "SELECT id FROM benchmarks WHERE project_id=? AND name=?", (p["id"], payload["benchmark"]))
+        if b:
+            bid = b["id"]
+        else:
+            bid = new_id("bench")
+            insert(conn, "benchmarks", {"id": bid, "project_id": p["id"], "name": payload["benchmark"], "version": payload.get("version", ""),
+                                        "category": payload.get("category", ""), "metric": payload.get("metric", "avg@1"),
+                                        "harness": payload.get("harness"), "n_tasks": payload.get("n_tasks"), "k": payload.get("k", 1),
+                                        "description": payload.get("description", ""), "source": payload.get("source", "")})
+        mid = resolve_model(conn, p["id"], payload.get("model"), kind="checkpoint") if payload.get("model") else None
+        eid = new_id("eval")
+        insert(conn, "evals", {"id": eid, "project_id": p["id"], "benchmark_id": bid, "model_id": mid, "run_id": payload.get("run_id"),
+                               "step": payload.get("step"), "status": payload.get("status", "running"), "score": payload.get("score"),
+                               "stderr": payload.get("stderr"), "n_tasks": payload.get("n_tasks"), "k": payload.get("k", 1),
+                               "n_infra": payload.get("n_infra"), "started_at": time.time(), "ended_at": None,
+                               "cost_usd": None, "config": payload.get("config"), "command": payload.get("command", ""),
+                               "source": payload.get("target", ""), "provenance": "published"})
+        return {"eval_id": eid, "benchmark_id": bid}
+    return workspace.write(fn)
+
+
+@router.post("/evals/{eval_id}/results")
+def eval_results(eval_id: str, request: Request, payload: dict = Body(...)):
+    u, scoped = eval_caller(request)
+
+    def fn(conn):
+        e = db.one(conn, "SELECT * FROM evals WHERE id=?", (eval_id,))
+        if not e:
+            raise HTTPException(404, f"No eval {eval_id}.")
+        if scoped and e["run_id"] != scoped:
+            raise HTTPException(403, "This token belongs to one run and can only record results for that run's evals.")
+        tasks = payload.get("tasks", [])
+        for t in tasks:
+            insert(conn, "eval_tasks", {"eval_id": eval_id, "task_id": t.get("task_id"), "task_name": t["task_name"],
+                                        "attempts": t.get("attempts", 1), "passes": t.get("passes"), "infra": t.get("infra", 0),
+                                        "score": t.get("score"), "mean_turns": t.get("mean_turns"), "mean_tokens": t.get("mean_tokens")})
+        score, se = payload.get("score"), payload.get("stderr")
+        if score is None and tasks:
+            vals = [t["score"] for t in tasks if t.get("score") is not None]
+            if vals:
+                score = sum(vals) / len(vals)
+                if len(vals) > 1:
+                    sd = (sum((v - score) ** 2 for v in vals) / (len(vals) - 1)) ** 0.5
+                    se = sd / len(vals) ** 0.5
+        conn.execute("UPDATE evals SET status=?, score=?, stderr=?, n_tasks=coalesce(?, n_tasks), n_infra=coalesce(?, n_infra), ended_at=? WHERE id=?",
+                     (payload.get("status", "completed"), score, se, len(tasks) or None, payload.get("n_infra"), time.time(), eval_id))
+        conn.execute("UPDATE benchmarks SET n_tasks=coalesce(n_tasks, ?) WHERE id=?", (len(tasks) or None, e["benchmark_id"]))
+        return {"eval_id": eval_id, "score": score, "stderr": se}
+    return workspace.write(fn)
+
+
+# ------------------------------------------------------------------ compute targets and runners
+
+@router.get("/orgs/{org}/compute")
+def list_compute(org: str):
+    conn = workspace.connect()
+    targets = db.rows(conn, "SELECT c.* FROM compute_targets c JOIN orgs o ON o.id=c.org_id WHERE o.slug=? ORDER BY c.name", (org,))
+    runners = db.rows(conn, "SELECT r.* FROM runners r JOIN orgs o ON o.id=r.org_id WHERE o.slug=? ORDER BY r.last_seen DESC", (org,))
+    now = time.time()
+    for t in targets:
+        t["config"] = json.loads(t["config"]) if isinstance(t["config"], str) else t["config"]
+        t["runners"] = [r["name"] for r in runners if t["name"] in (r.get("targets") or []) and now - (r["last_seen"] or 0) < 90]
+    for r in runners:
+        r["online"] = now - (r["last_seen"] or 0) < 90
+    queued = db.rows(conn, "SELECT j.id, j.target, j.name, j.created_at, j.run_id FROM jobs j JOIN projects p ON p.id=j.project_id "
+                           "JOIN orgs o ON o.id=p.org_id WHERE o.slug=? AND j.status='queued' ORDER BY j.created_at", (org,))
+    return {"targets": targets, "runners": runners, "queued": queued}
+
+
+@router.post("/orgs/{org}/compute")
+def add_compute(org: str, request: Request, payload: dict = Body(...)):
+    """Register a compute target. Only non-secret settings are stored; credentials stay with the
+    machine that runs jobs (the CLI or a runner)."""
+    u = auth(request)
+    kind = payload.get("kind")
+    if kind not in {"local", "ssh", "slurm", "prime", "hf-jobs", "fireworks"}:
+        raise HTTPException(422, "kind must be local, ssh, slurm, prime, hf-jobs or fireworks")
+    cfg = {k: v for k, v in (payload.get("config") or {}).items() if not any(s in k.lower() for s in ("token", "secret", "password", "key"))}
+
+    def fn(conn):
+        o = db.one(conn, "SELECT id FROM orgs WHERE slug=?", (org,))
+        if not o:
+            raise HTTPException(404, f"No org {org}. Create a project first.")
+        existing = db.one(conn, "SELECT id FROM compute_targets WHERE org_id=? AND name=?", (o["id"], payload["name"]))
+        cid = existing["id"] if existing else new_id("target")
+        insert(conn, "compute_targets", {"id": cid, "org_id": o["id"], "name": payload["name"], "kind": kind, "config": cfg,
+                                         "created_at": time.time(), "created_by": u["name"]})
+        return {"target_id": cid, "updated": bool(existing)}
+    return workspace.write(fn)
+
+
+@router.post("/runners/register")
+def register_runner(request: Request, payload: dict = Body(...)):
+    auth(request, allow_runner=True)
+
+    def fn(conn):
+        o = db.one(conn, "SELECT id FROM orgs WHERE slug=?", (payload["org"],))
+        if not o:
+            raise HTTPException(404, f"No org {payload['org']}.")
+        rid = payload.get("id") or new_id("runner")
+        insert(conn, "runners", {"id": rid, "org_id": o["id"], "name": payload.get("name") or rid, "hostname": payload.get("hostname", ""),
+                                 "targets": payload.get("targets", []), "version": payload.get("version", ""),
+                                 "started_at": time.time(), "last_seen": time.time()})
+        return {"runner_id": rid}
+    return workspace.write(fn)
+
+
+@router.post("/runners/{runner_id}/heartbeat")
+def heartbeat(runner_id: str, request: Request, payload: dict = Body(default={})):
+    auth(request, allow_runner=True)
+
+    def fn(conn):
+        conn.execute("UPDATE runners SET last_seen=? WHERE id=?", (time.time(), runner_id))
+        running = payload.get("running", [])
+        if running:
+            q0 = ",".join("?" for _ in running)
+            conn.execute(f"UPDATE jobs SET claimed_at=? WHERE id IN ({q0}) AND runner_id=?", (time.time(), *running, runner_id))  # renew leases
+        cancel = []
+        if running:
+            q = ",".join("?" for _ in running)
+            cancel = [r[0] for r in conn.execute(f"SELECT id FROM jobs WHERE id IN ({q}) AND coalesce(cancel,0)=1", running)]
+        return {"cancel": cancel}
+    return workspace.write(fn)
+
+
+@router.post("/runners/{runner_id}/claim")
+def claim(runner_id: str, request: Request):
+    """The oldest queued job for one of this runner's targets, now assigned to it (a lease renewed by heartbeat)."""
+    auth(request, allow_runner=True)
+
+    def fn(conn):
+        r = db.one(conn, "SELECT * FROM runners WHERE id=?", (runner_id,))
+        if not r:
+            raise HTTPException(404, "Unknown runner; register again.")
+        targets = r.get("targets") or []
+        if not targets:
+            return {"job": None}
+        q = ",".join("?" for _ in targets)
+        j = db.one(conn, f"SELECT j.*, p.slug AS project_slug, o.slug AS org_slug FROM jobs j JOIN projects p ON p.id=j.project_id "
+                         f"JOIN orgs o ON o.id=p.org_id WHERE j.status='queued' AND coalesce(j.cancel,0)=0 AND j.target IN ({q}) AND o.id=? ORDER BY j.created_at LIMIT 1",
+                   (*targets, r["org_id"]))
+        if not j:
+            conn.execute("UPDATE runners SET last_seen=? WHERE id=?", (time.time(), runner_id))
+            return {"job": None}
+        now = time.time()
+        conn.execute("UPDATE jobs SET status='starting', runner_id=?, claimed_at=? WHERE id=? AND status='queued'", (runner_id, now, j["id"]))
+        j.update(status="starting", runner_id=runner_id, claimed_at=now)
+        conn.execute("UPDATE runs SET status='starting', updated_at=? WHERE id=? AND status='queued'", (now, j["run_id"]))
+        event(conn, j["run_id"], "notice", "Picked up by a runner", f"{r['name']} on {r['hostname']} will run it on {j['target']}.")
+        run = db.one(conn, "SELECT * FROM runs WHERE id=?", (j["run_id"],))
+        return {"job": j, "run": run, "run_token": None}
+    res = workspace.write(fn)
+    if res.get("job"):
+        res["run_token"] = workspace.issue_token(f"run {res['job']['run_id']}", "runner", scope=f"run:{res['job']['run_id']}",
+                                                 expires=time.time() + 7 * 86400 * 4)
+    return res
+
+
+@router.post("/jobs/{job_id}/status")
+def job_status(job_id: str, request: Request, payload: dict = Body(...)):
+    auth(request, allow_runner=True)
+
+    def fn(conn):
+        j = db.one(conn, "SELECT * FROM jobs WHERE id=?", (job_id,))
+        if not j:
+            raise HTTPException(404, f"No job {job_id}.")
+        sets = {k: payload[k] for k in ("status", "external_id", "message", "exit", "cost_usd", "log_tail") if k in payload}
+        if payload.get("status") == "running" and not j["started_at"]:
+            sets["started_at"] = time.time()
+        if payload.get("status") in TERMINAL:
+            sets["ended_at"] = time.time()
+        if sets:
+            conn.execute(f"UPDATE jobs SET {','.join(k + '=?' for k in sets)} WHERE id=?", (*sets.values(), job_id))
+        return {"job_id": job_id, **sets}
+    return workspace.write(fn)
diff --git a/viewer/build/LAB_MODULES.md b/viewer/build/LAB_MODULES.md
new file mode 100644
index 0000000000000000000000000000000000000000..34920eae9ddd7bc7242b2abf83ab8969c3ff703c
--- /dev/null
+++ b/viewer/build/LAB_MODULES.md
@@ -0,0 +1,33 @@
+# Writing a lab module for the demo source
+
+The demo database shows what a post-training team's whole program looks like in the viewer: models and their lineage, datasets, RL environments and tasks, training runs (SFT, preference, RL, distillation), held-out evals, jobs, spend and written findings. Each lab gets one module, `viewer/build/labs/<lab>.py`, exposing `build(w, now)`.
+
+## Rules
+
+1. **Published numbers are the skeleton.** Take every number you can from the lab's dossier (`~/benchflow/pta-work/ref/viewer-v3/<lab>/DOSSIER.md` and `recipe.json`) and from real public run data (`~/benchflow/pta-work/public-runs/<run>/metrics.jsonl`, `attempts.jsonl`, `traces/`). Record the source URL on every record (`source=`).
+2. **Simulate only what isn't published, and consistently.** Rollouts, per-task results and missing curves are simulated with the engine so they agree with the published numbers (for example `rl_run(..., pass_start=, pass_end=)` or `env_targets` matching a published curve; `eval_run(score=published)`). Mark provenance: `published` (everything real), `mixed` (real metrics or scores, simulated rollouts/tasks), `simulated`.
+3. **Never invent concepts the lab doesn't have.** No runs, datasets or environments that the sources don't describe, except clearly-marked continuations that follow the lab's own stated next step (say which sentence in the source motivates it, in the run description). Anonymized names stay anonymized.
+4. **Denominators.** Benchmarks need a task count and attempts per task (`n_tasks`, `k`). If the count isn't published, pick a plausible one, say so in the benchmark `description`, and keep it ≤ 1,000 stored tasks.
+5. **Size budget.** Keep a lab under ~40 MB of SQLite: store ≤ 2,000 tasks per environment, `store_groups` 2–6 per step, ≤ 300 steps per run (log every step for RL; SFT logs are downsampled automatically).
+6. **Nothing harmful.** For security/cyber data, keep counts, grader kinds and domain names only: no exploit steps, payloads, proof-of-concept instructions or crash-reproduction prompts in task names, instructions, dataset samples or descriptions. The transcript renderer already withholds the `cyber` domain.
+7. **Self-contained build.** The demo is built from the repo alone (it deploys to a Space). Any file a module reads must live in `viewer/build/inputs/<lab>/` (gzip files over ~200 KB, keep a lab's inputs under ~15 MB, add a `SOURCE.md` with each file's origin and license) and be read via `Path(__file__).resolve().parent.parent / "inputs" / "<lab>"`. Never copy secrets or API keys. Hard-coding published numbers in the module is fine.
+8. **Only touch your own files**: `viewer/build/labs/<lab>.py` (and an optional `viewer/build/inputs/<lab>/` with a `SOURCE.md` saying where each file came from). Read the engine, don't edit it; if you need a helper, write it inside your module. Don't start or stop servers on port 7880 and don't commit.
+
+## The engine
+
+- `viewer/build/kit.py`: `org`, `project`, `model`, `dataset`, `grader`, `environment` (+ `write_tasks`), `import_metrics`, `metric_defs`, `cluster`, `jobs_for_run`, `usage_for_run`, `report`, `deployment`, `ts`.
+- `viewer/build/training.py`: `rl_run` (simulated RL with per-step aggregates computed from simulated attempts), `sft_run`, `dpo_run`, `benchmark`, `eval_run` (per-task results that average to the published score; `raw=True` for Elo/index scores).
+- `viewer/build/signals.py`: canonical signals and each framework's tag names (`verl`, `nemo_rl`, `prime_rl`, `open_instruct`, `skyrl`, `trl_sft`, `trl_dpo`, `megatron_sft`). Real imported tags should get `metric_defs` rows with a `signal` so the run page's health view finds them (`kit.metric_defs(w, pid, framework, extra=[...])`).
+- `viewer/build/labs/banks.py`: task-name/instruction generators per domain (`bank_for(domain)`); write your own bank in your module when the lab publishes real task examples.
+- `viewer/build/labs/mimo.py`: the reference module (real published metrics imported, rollouts simulated to match).
+- `viewer/PROTOCOL.md`: what each table means. `viewer/server.py`: how pages read it.
+
+## Check your work
+
+```bash
+cd ~/benchflow/pta-work/pta-space-viewer
+python3 -m viewer.build --only <lab> --out /tmp/<lab>.sqlite      # builds just your lab
+VIEWER_DATA=/tmp python3 -c "..."                                  # or query the file with sqlite3
+```
+
+Then look at the numbers the pages will show: runs (status, steps, primary metric first → last), evals (score ± SE per benchmark and model), environments (task counts, pass rates), datasets (rows, tokens, sources). Every published number you used should appear unchanged.
diff --git a/viewer/build/__init__.py b/viewer/build/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/viewer/build/__main__.py b/viewer/build/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7108e3cc2b67cc07d1f93f761b1ae6908e68ccdd
--- /dev/null
+++ b/viewer/build/__main__.py
@@ -0,0 +1,57 @@
+"""Build the demo database: python -m viewer.build [--out path] [--only mimo,...]"""
+import argparse
+import importlib
+import time
+from pathlib import Path
+
+from .. import db
+from .sim import World
+
+LABS = ["mimo", "nemotron", "marin", "olmo", "prime", "openthoughts", "agentica"]
+NOW = 1790395200.0  # 2026-09-26 04:00 UTC, the demo's clock
+
+
+def check_spend(conn):
+    """One number per fact: a project's run costs and its usage ledger must agree (within 1%), because the
+    home page shows one and the overview and Usage page the other."""
+    bad = []
+    for pid, name in conn.execute("SELECT id, name FROM projects"):
+        runs = conn.execute("SELECT coalesce(sum(cost_usd), 0) FROM runs WHERE project_id=?", (pid,)).fetchone()[0]
+        usage = conn.execute("SELECT coalesce(sum(cost_usd), 0) FROM usage WHERE project_id=?", (pid,)).fetchone()[0]
+        if (runs or usage) and abs(runs - usage) > 0.01 * max(runs, usage):
+            bad.append(f"{name}: runs ${runs:,.0f} vs usage ${usage:,.0f}")
+    if bad:
+        raise SystemExit("Run costs and usage disagree:\n  " + "\n  ".join(bad))
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default=str(db.DATA / "demo.sqlite"))
+    ap.add_argument("--only", default="")
+    args = ap.parse_args()
+    out = Path(args.out)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    tmp = out.with_suffix(".building")
+    w = World(tmp, NOW)
+    w.meta(source="demo", now=NOW, built_at=time.time(), version="3")
+    labs = [x for x in args.only.split(",") if x] or LABS
+    for name in labs:
+        t0 = time.time()
+        try:
+            mod = importlib.import_module(f".labs.{name}", __package__)
+        except ModuleNotFoundError as e:
+            if e.name and e.name.endswith(f"labs.{name}"):
+                print(f"{name}: no module yet, skipped")
+                continue
+            raise
+        mod.build(w, NOW)
+        w.conn.commit()
+        print(f"{name}: {time.time() - t0:.1f}s")
+    check_spend(w.conn)
+    w.close()
+    tmp.replace(out)
+    print(out, f"{out.stat().st_size / 1e6:.1f} MB", w.counts)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/viewer/build/inputs/agentica/SOURCE.md b/viewer/build/inputs/agentica/SOURCE.md
new file mode 100644
index 0000000000000000000000000000000000000000..9a9d2d0d7db3f076f8ea46ab04e60688cae9941b
--- /dev/null
+++ b/viewer/build/inputs/agentica/SOURCE.md
@@ -0,0 +1,13 @@
+# Inputs for `labs/agentica.py`
+
+Everything here was copied from public sources on 2026-09-26. The viewer build reads only these files. Published numbers that are not in these files (card and blog scores, hyperparameters) are written in `labs/agentica.py` next to their source URL. Strings that look like credentials would have been replaced with `[redacted]` while copying; none were found.
+
+| File | What it is | Where it came from | License |
+|---|---|---|---|
+| `wandb_runs.json.gz` | Full logged history (every key, every step) and run metadata of the four runs in the public W&B project: `deepswe-preview-part1` (bx0o5d9l, steps 1-170), `deepswe-preview-part2` (fmwxpge7, 83 steps resumed from part 1's `global_step_170`), `swe-14b-no-overlong-filter-fail` (tzaqgde3, steps 41-273), `swe-sft-rl-fail` (dax4at2n, steps 0-100). The history `_timestamp`s are the 2025-07-01 upload time, not the training time. | https://wandb.ai/mluo/deepswe (anonymous GraphQL `history` per run) | none stated (public W&B project) |
+| `eval_runs_7of16.json.gz` | Per-instance results of 7 of the 16 official DeepSWE-Preview SWE-bench Verified evaluation runs (runs 0, 1, 2, 5, 10, 11, 13; 500 instances each): reward, exit reason, agent steps, tokens, LLM / environment / scoring time, patch size. Summarised from the run files inside `deepswe.zip`. | https://drive.google.com/file/d/10LIwpJeaFuiX6Y-qEG2a4a335PEuQJeS (linked from the DeepSWE blog) | released with the MIT-licensed DeepSWE project; no separate license stated |
+| `eval_trajectories.json.gz` | 112 of those trajectories (16 instances, chosen two per "solved in k of 7 runs" level, × 7 runs): the agent's steps converted to the viewer's message format (system prompt cut at 1,500 characters, issue at 1,800; thoughts, tool arguments and observations cut at 500; at most 30 steps kept, the rest summarised in a note) with reward, exit reason, token and time totals. | same `deepswe.zip` | as above |
+| `swebv_instances.json.gz` | The 500 SWE-bench Verified instance ids with repo, issue title and problem-statement length. | https://huggingface.co/datasets/R2E-Gym/SWE-Bench-Verified | not stated |
+| `r2e_gym_subset.json.gz` | For all 4,578 R2E-Gym-Subset rows: repo, commit, non-test files and lines changed, relevant files; real problem statements for 11 rows downloaded whole. | https://huggingface.co/datasets/R2E-Gym/R2E-Gym-Subset | apache-2.0 |
+
+The DeepSWE-Preview training curves are the same W&B series that `~/benchflow/pta-work/public-runs/agentica-deepswe-preview-qwen3-32b/` imported; here they are copied with every logged key. No training rollouts were released, so the run's rollouts in the demo are simulated to match each step's logged pass rate.
diff --git a/viewer/build/inputs/agentica/eval_runs_7of16.json.gz b/viewer/build/inputs/agentica/eval_runs_7of16.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..4595693b6695ab99668fa51820a9866b25706026
--- /dev/null
+++ b/viewer/build/inputs/agentica/eval_runs_7of16.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9902393838a784d8602c56643b29b48bb96107100d7c6cd2ff21a1a621c7ade
+size 227893
diff --git a/viewer/build/inputs/agentica/eval_trajectories.json.gz b/viewer/build/inputs/agentica/eval_trajectories.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..4e0ad48fa8dfd8bbeb23610b8067cb669ea863e1
--- /dev/null
+++ b/viewer/build/inputs/agentica/eval_trajectories.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97106c146f75e00a28d5a3f8095b84274ed187ac6d58d9e71ca2b8238a866a7b
+size 643016
diff --git a/viewer/build/inputs/agentica/r2e_gym_subset.json.gz b/viewer/build/inputs/agentica/r2e_gym_subset.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..91e44ec52ddcefc22d65ce90a2d942cc5bc17785
--- /dev/null
+++ b/viewer/build/inputs/agentica/r2e_gym_subset.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ff5dbf29d1f08533a6c249539c4f7c973c4db8c3813e5dd9dfbd5a0b7e2b6a0
+size 65635
diff --git a/viewer/build/inputs/agentica/swebv_instances.json.gz b/viewer/build/inputs/agentica/swebv_instances.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..7b7e9b54209b5826ab75e10c19f893051d77f297
--- /dev/null
+++ b/viewer/build/inputs/agentica/swebv_instances.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14f8c1be623803c392b481f35a4ac46e3e567bad0c8a38ec8d60915e0a9d7bd4
+size 19828
diff --git a/viewer/build/inputs/agentica/wandb_runs.json.gz b/viewer/build/inputs/agentica/wandb_runs.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..16c0811d2fc35d79b2a5c0c5f7f874f0952b7f99
--- /dev/null
+++ b/viewer/build/inputs/agentica/wandb_runs.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a22b794efafc896ff2fdb660fde298ce438b00a8b5daba0b45518c7060928542
+size 184638
diff --git a/viewer/build/inputs/marin/SOURCE.md b/viewer/build/inputs/marin/SOURCE.md
new file mode 100644
index 0000000000000000000000000000000000000000..19bd5b0145d3f5d0645a5cb701a3d54df531d0b6
--- /dev/null
+++ b/viewer/build/inputs/marin/SOURCE.md
@@ -0,0 +1,49 @@
+# Inputs for `labs/marin.py`
+
+Every file here was copied from our research workspace (`~/benchflow/pta-work`) on 2026-09-26. Nothing here contains credentials. All published numbers not read from these files are hard-coded in `labs/marin.py` with their source URL.
+
+## `recipe.json.gz`
+
+The Marin dossier's machine-readable recipe (`ref/viewer-v3/marin/recipe.json`, schema `ref/viewer-v3/SCHEMA.md`), compiled on 2026-09-26 from public sources: `marin-community/marin` issues and docs (repo at commit `f97c9c5d08be`, Apache-2.0), Hugging Face model and dataset cards (`marin-community`, `open-athena`, `laion`, `penfever`), and Marin's public reports on `storage.googleapis.com/marin-public`. Every entry carries its own source URL.
+
+One change from the original: the example-task instruction of three environments (the TaskTrove safety source and two Nemotron RL Ultra jailbreak domains) is replaced by `[withheld: safety/jailbreak prompt text is not copied]`, so no harmful prompt text enters the repository. Gzipped.
+
+The module reads its environments (TaskTrove Clean kept sources with grader modes, validation verdicts and example tasks; Nemotron RL Ultra domain agents), the Datakit SFT source registry, the RLVR1 example prompts and the 26-benchmark eval-policy panel (15 models each) from it.
+
+## `runs/<id>/run.json` and `runs/<id>/metrics.jsonl`
+
+Exact copies of `public-runs/<id>/`, written by our importers `importers/train_marin.py` (training curves) and `importers/rollouts_snowball_v104.py` (v104). `metrics.jsonl` has one row per logged step with the framework's own tags, no smoothing; `run.json` has the metadata and provenance. Known label problems in `run.json` are corrected in the module and noted in the run descriptions (v104 is RLOO-N at lr 8e-6, not GRPO at 4e-6; the #7785 arms' method label; pymethods2test-large's reported 0.74 vs its curve).
+
+| Folder | Upstream file(s) | License |
+|---|---|---|
+| `runs/marin-a3-inferredbugs/` | https://huggingface.co/laion/a3-rl-DCAgent_inferredbugs-sandboxes-verifier-55-8B/blob/main/training_logs/20260525_030311_metrics_table.csv | not stated |
+| `runs/marin-a3-llm-verifier-freelancer/` | https://huggingface.co/laion/a3-rl-DCAgent_llm-verifier-freelancer-70-8B/blob/main/training_logs/20260525_084909_metrics_table.csv | not stated |
+| `runs/marin-a3-nemotron-agent-calendar/` | https://huggingface.co/laion/a3-rl-laion_nemotron-gym-agent-calendar-80-8B/blob/main/training_logs/20260602_174231_metrics_table.csv | Apache-2.0 |
+| `runs/marin-a3-nl2bash/` | https://huggingface.co/laion/a3-rl-DCAgent2_nl2bash-tasks-cleaned-oracle-40-8B/blob/main/training_logs/20260526_134647_metrics_table.csv | not stated |
+| `runs/marin-a3-pymethods2test-large/` | https://huggingface.co/laion/a3-rl-DCAgent_exp_rpt_pymethods2test-large-80-8B/blob/main/training_logs/20260605_113517_metrics_table.csv (cut after step 80) | Apache-2.0 |
+| `runs/marin-q3c-tt-x3-kl0p001/` | https://huggingface.co/laion/tt-x3_kl-kl0p001-76-30B/blob/main/training_logs/metrics.csv | Apache-2.0 |
+| `runs/marin-q3c-tt-x5-gradnorm0p45/` | https://huggingface.co/laion/tt-x5_gradnorm-gn0p45-30-30B/blob/main/training_logs/metrics.csv | Apache-2.0 |
+| `runs/marin-q3c-tt-x10-fsdp2/` | https://huggingface.co/laion/tt-x10-fsdp2-fa2-117-30B/blob/main/training_logs/metrics.csv | Apache-2.0 |
+| `runs/marin-q3c-tt-x15-megatron/` | https://huggingface.co/laion/tt-x15-megatron-51-30B/blob/main/training_logs/metrics.csv | Apache-2.0 |
+| `runs/marin-q3c-cal-if-rloo-lr2/` | https://huggingface.co/penfever/qwen3coder-calendar-if-v49-lr2-step18/blob/main/training_logs/finelog.log and https://huggingface.co/datasets/penfever/qwen3coder-iris-rl-data-sweep-artifacts/blob/main/top-ten-checkpoint-fixed-validation.csv | not stated |
+| `runs/marin-q3c-cal-agent-rloo-lr2/` | https://huggingface.co/penfever/qwen3coder-calendar-agent-v49-lr2-step12/blob/main/training_logs/finelog.log and the same validation CSV | not stated |
+| `runs/marin-q3c-cal-agent-rloo-lr4/` | https://huggingface.co/penfever/qwen3coder-calendar-agent-v49-lr4-step9/blob/main/training_logs/finelog.log and the same validation CSV | not stated |
+| `runs/marin-snowball-e6-rlvr-math/` | https://storage.googleapis.com/marin-public/benjaminfeuer/passk-pass1-comparison/2026.08.31/run-metrics/e6-original.csv, https://huggingface.co/datasets/penfever/snowball-67b-a2b-math-rl-artifacts/blob/main/html-report/reward_curves.csv, https://huggingface.co/datasets/penfever/snowball-67b-a2b-math-rl-artifacts/blob/main/MATH_EVALS.md | not stated |
+| `runs/marin-snowball-e11-deepscaler-dapo/` | .../run-metrics/e11-deepscaler-dapo.csv plus the same reward_curves.csv and MATH_EVALS.md | not stated |
+| `runs/marin-snowball-e12-deepscaler-grpo/` | .../run-metrics/e12-deepscaler-grpo.csv plus the same reward_curves.csv and MATH_EVALS.md | not stated |
+| `runs/marin-snowball-v104-rlvr1-traces/` | `open-athena/Snowball-67B-A2B-Mixed-RLVR-Experiment-Artifacts@0ed714e5afbe11c13dfb227d6b13ac911a27d253:01-provenance-and-history/history/v104-termination-20260917` (https://huggingface.co/datasets/open-athena/Snowball-67B-A2B-Mixed-RLVR-Experiment-Artifacts) | not stated on the card; prompts come from nvidia/Nemotron-RL-Ultra-Training-Blends (components CC BY-SA 4.0, CC BY 4.0, ODC-BY 1.0, MIT, Apache-2.0) |
+
+## `runs/marin-snowball-v104-rlvr1-traces/attempts.jsonl.gz`
+
+`public-runs/marin-snowball-v104-rlvr1-traces/attempts.jsonl`, gzipped, unchanged: 1,952 attempts (1,152 training rollouts = 36 random complete 16-rollout groups from each of steps 1 and 15; 800 holdout samples = 100 prompts at steps 0, 2, …, 14) with the published rewards, stop reasons, token counts and domains. Same origin and license as the row above.
+
+## `runs/marin-snowball-v104-rlvr1-traces/transcripts.json.gz`
+
+Derived from `public-runs/marin-snowball-v104-rlvr1-traces/traces/*.json` (46 MB, not copied) by a one-off script with these rules:
+
+- Rollouts of the four `jailbreak_*` domains are skipped entirely (no prompt or response text).
+- Messages are converted to the viewer's format (system, user, assistant with `reasoning` and `tool_calls`, tool results, a final note with the last 300 characters of verifier output) and cut: system 200 characters, first user message 900 (later ones 400), assistant text 700, reasoning 350, tool arguments 200, tool results 250; cut text ends with "… [cut]".
+- A transcript longer than 12 messages keeps the first 6 and last 5 with a note in between.
+- `prompts` holds each task's first user message (up to 2,000 characters), keyed `train:<task>` or `eval:<task>`, because the importer's task ids (`rlvr1-<row index>`) restart per file and collide between training and holdout.
+
+Result: 1,864 transcripts and 164 prompts, about 4.0 MB uncompressed. The module stores full transcripts for the 800 holdout samples and for 12 of the 36 stored groups per training step, and a short pointer note for the other real training rollouts.
diff --git a/viewer/build/inputs/marin/recipe.json.gz b/viewer/build/inputs/marin/recipe.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..fa57a0d1043c8ebadec0d65568cbdedf4108987f
--- /dev/null
+++ b/viewer/build/inputs/marin/recipe.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7df33e6fd7306457d96eb0acbc6668965070d71b9a63d4bf72db6a9c51958d18
+size 53623
diff --git a/viewer/build/inputs/marin/runs/marin-a3-inferredbugs/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-a3-inferredbugs/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..0a3353f0c4c978368a07d2bfa18000c797dfcd17
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-a3-inferredbugs/metrics.jsonl
@@ -0,0 +1,78 @@
+{"step":1,"async/staleness_mean":0.0,"generate/avg_num_tokens":3554.5293,"generate/avg_tokens_non_zero_rewards":5487.5524,"generate/avg_tokens_zero_rewards":2210.3742,"generate/max_num_tokens":27297,"generate/std_num_tokens":4153.5765,"loss/avg_final_rewards":0.4102,"loss/avg_raw_advantages":0.0484,"loss/avg_raw_advantages_abs":0.2364,"policy/policy_entropy":0.0552,"policy/policy_loss":-0.0059,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0288,"reward/avg_pass_at_8":0.6562,"reward/avg_raw_reward":0.4102,"timing/step":8293.4295,"trainer/epoch":0}
+{"step":2,"async/staleness_mean":1.0,"generate/avg_num_tokens":3575.0723,"generate/avg_tokens_non_zero_rewards":6572.3139,"generate/avg_tokens_zero_rewards":2480.08,"generate/max_num_tokens":30777,"generate/std_num_tokens":5688.8025,"loss/avg_final_rewards":0.2676,"loss/avg_raw_advantages":0.0765,"loss/avg_raw_advantages_abs":0.1962,"policy/policy_entropy":0.0396,"policy/policy_loss":-0.0083,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0419,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.2676,"timing/step":664.4752,"trainer/epoch":0}
+{"step":3,"async/staleness_mean":1.4531,"generate/avg_num_tokens":2257.6348,"generate/avg_tokens_non_zero_rewards":5324.374,"generate/avg_tokens_zero_rewards":1203.1916,"generate/max_num_tokens":30351,"generate/std_num_tokens":3596.3146,"loss/avg_final_rewards":0.2559,"loss/avg_raw_advantages":0.1299,"loss/avg_raw_advantages_abs":0.2503,"policy/policy_entropy":0.0375,"policy/policy_loss":-0.0294,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0446,"reward/avg_pass_at_8":0.5156,"reward/avg_raw_reward":0.2559,"timing/step":6178.9035,"trainer/epoch":0}
+{"step":4,"async/staleness_mean":1.5625,"generate/avg_num_tokens":2162.7051,"generate/avg_tokens_non_zero_rewards":6591.2113,"generate/avg_tokens_zero_rewards":1449.7256,"generate/max_num_tokens":30986,"generate/std_num_tokens":4168.7167,"loss/avg_final_rewards":0.1387,"loss/avg_raw_advantages":0.0369,"loss/avg_raw_advantages_abs":0.2575,"policy/policy_entropy":0.0219,"policy/policy_loss":-0.0087,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.016,"reward/avg_pass_at_8":0.375,"reward/avg_raw_reward":0.1387,"timing/step":1267.1686,"trainer/epoch":0}
+{"step":5,"async/staleness_mean":1.3906,"generate/avg_num_tokens":1752.9648,"generate/avg_tokens_non_zero_rewards":7083.6949,"generate/avg_tokens_zero_rewards":1058.6755,"generate/max_num_tokens":22939,"generate/std_num_tokens":3735.264,"loss/avg_final_rewards":0.1152,"loss/avg_raw_advantages":0.1295,"loss/avg_raw_advantages_abs":0.2618,"policy/policy_entropy":0.0152,"policy/policy_loss":-0.0298,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0113,"reward/avg_pass_at_8":0.4062,"reward/avg_raw_reward":0.1152,"timing/step":5785.6711,"trainer/epoch":0}
+{"step":6,"async/staleness_mean":1.1719,"generate/avg_num_tokens":1250.6895,"generate/avg_tokens_non_zero_rewards":6531.6818,"generate/avg_tokens_zero_rewards":754.1859,"generate/max_num_tokens":27177,"generate/std_num_tokens":3653.1449,"loss/avg_final_rewards":0.0859,"loss/avg_raw_advantages":0.0677,"loss/avg_raw_advantages_abs":0.2001,"policy/policy_entropy":0.0082,"policy/policy_loss":-0.0176,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0091,"reward/avg_pass_at_8":0.25,"reward/avg_raw_reward":0.0859,"timing/step":1901.8618,"trainer/epoch":0}
+{"step":7,"async/staleness_mean":0.1562,"generate/avg_num_tokens":2757.6699,"generate/avg_tokens_non_zero_rewards":5131.4013,"generate/avg_tokens_zero_rewards":1755.4278,"generate/max_num_tokens":30895,"generate/std_num_tokens":4025.9714,"loss/avg_final_rewards":0.2969,"loss/avg_raw_advantages":0.0821,"loss/avg_raw_advantages_abs":0.2883,"policy/policy_entropy":0.0327,"policy/policy_loss":-0.0375,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0242,"reward/avg_pass_at_8":0.6333,"reward/avg_raw_reward":0.2969,"timing/step":8205.9669,"trainer/epoch":0}
+{"step":8,"async/staleness_mean":1.0,"generate/avg_num_tokens":2169.2109,"generate/avg_tokens_non_zero_rewards":7972.4857,"generate/avg_tokens_zero_rewards":1250.1403,"generate/max_num_tokens":30300,"generate/std_num_tokens":4891.1346,"loss/avg_final_rewards":0.1367,"loss/avg_raw_advantages":0.0692,"loss/avg_raw_advantages_abs":0.1725,"policy/policy_entropy":0.0148,"policy/policy_loss":-0.0241,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0109,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.1367,"timing/step":1319.1071,"trainer/epoch":0}
+{"step":9,"async/staleness_mean":1.4844,"generate/avg_num_tokens":3028.4199,"generate/avg_tokens_non_zero_rewards":5770.2286,"generate/avg_tokens_zero_rewards":1996.5565,"generate/max_num_tokens":29148,"generate/std_num_tokens":4542.8655,"loss/avg_final_rewards":0.2734,"loss/avg_raw_advantages":0.0444,"loss/avg_raw_advantages_abs":0.1845,"policy/policy_entropy":0.0292,"policy/policy_loss":-0.0213,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0121,"reward/avg_pass_at_8":0.5156,"reward/avg_raw_reward":0.2734,"timing/step":5804.1709,"trainer/epoch":0}
+{"step":10,"async/staleness_mean":1.5,"generate/avg_num_tokens":2115.5254,"generate/avg_tokens_non_zero_rewards":7133.6164,"generate/avg_tokens_zero_rewards":1281.082,"generate/max_num_tokens":28527,"generate/std_num_tokens":4442.122,"loss/avg_final_rewards":0.1426,"loss/avg_raw_advantages":0.0836,"loss/avg_raw_advantages_abs":0.1262,"policy/policy_entropy":0.0158,"policy/policy_loss":-0.0213,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0079,"reward/avg_pass_at_8":0.4531,"reward/avg_raw_reward":0.1426,"timing/step":1543.1181,"trainer/epoch":0}
+{"step":11,"async/staleness_mean":1.3594,"generate/avg_num_tokens":2746.5098,"generate/avg_tokens_non_zero_rewards":5941.9194,"generate/avg_tokens_zero_rewards":1725.2964,"generate/max_num_tokens":24484,"generate/std_num_tokens":4396.7582,"loss/avg_final_rewards":0.2422,"loss/avg_raw_advantages":0.0111,"loss/avg_raw_advantages_abs":0.1144,"policy/policy_entropy":0.0227,"policy/policy_loss":-0.0056,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0111,"reward/avg_pass_at_8":0.5,"reward/avg_raw_reward":0.2422,"timing/step":5597.2787,"trainer/epoch":0}
+{"step":12,"async/staleness_mean":1.6094,"generate/avg_num_tokens":1974.1328,"generate/avg_tokens_non_zero_rewards":6117.1944,"generate/avg_tokens_zero_rewards":866.5817,"generate/max_num_tokens":21058,"generate/std_num_tokens":3670.2518,"loss/avg_final_rewards":0.2109,"loss/avg_raw_advantages":0.1302,"loss/avg_raw_advantages_abs":0.2538,"policy/policy_entropy":0.0208,"policy/policy_loss":-0.0273,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.014,"reward/avg_pass_at_8":0.4531,"reward/avg_raw_reward":0.2109,"timing/step":2062.4401,"trainer/epoch":0}
+{"step":13,"async/staleness_mean":1.625,"generate/avg_num_tokens":2930.0977,"generate/avg_tokens_non_zero_rewards":6136.312,"generate/avg_tokens_zero_rewards":1894.4987,"generate/max_num_tokens":29462,"generate/std_num_tokens":4844.6221,"loss/avg_final_rewards":0.2441,"loss/avg_raw_advantages":0.0868,"loss/avg_raw_advantages_abs":0.1834,"policy/policy_entropy":0.0232,"policy/policy_loss":-0.0514,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.014,"reward/avg_pass_at_8":0.5,"reward/avg_raw_reward":0.2441,"timing/step":4021.5429,"trainer/epoch":0}
+{"step":14,"async/staleness_mean":1.875,"generate/avg_num_tokens":2880.4043,"generate/avg_tokens_non_zero_rewards":6461.1908,"generate/avg_tokens_zero_rewards":1649.2152,"generate/max_num_tokens":27936,"generate/std_num_tokens":4381.1046,"loss/avg_final_rewards":0.2559,"loss/avg_raw_advantages":0.0729,"loss/avg_raw_advantages_abs":0.2213,"policy/policy_entropy":0.0232,"policy/policy_loss":-0.0343,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.016,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.2559,"timing/step":3677.0767,"trainer/epoch":0}
+{"step":15,"async/staleness_mean":0.0,"generate/avg_num_tokens":3899.7969,"generate/avg_tokens_non_zero_rewards":7074.6913,"generate/avg_tokens_zero_rewards":2596.6033,"generate/max_num_tokens":26927,"generate/std_num_tokens":5093.0614,"loss/avg_final_rewards":0.291,"loss/avg_raw_advantages":0.0352,"loss/avg_raw_advantages_abs":0.151,"policy/policy_entropy":0.0258,"policy/policy_loss":-0.0172,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0088,"reward/avg_pass_at_8":0.4688,"reward/avg_raw_reward":0.291,"timing/step":8365.709,"trainer/epoch":0}
+{"step":16,"async/staleness_mean":1.0,"generate/avg_num_tokens":3354.5391,"generate/avg_tokens_non_zero_rewards":8819.5865,"generate/avg_tokens_zero_rewards":1961.4877,"generate/max_num_tokens":30311,"generate/std_num_tokens":5355.9926,"loss/avg_final_rewards":0.2031,"loss/avg_raw_advantages":0.0644,"loss/avg_raw_advantages_abs":0.1826,"policy/policy_entropy":0.0184,"policy/policy_loss":-0.02,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.015,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.2031,"timing/step":1673.4662,"trainer/epoch":0}
+{"step":17,"async/staleness_mean":1.6719,"generate/avg_num_tokens":3884.9746,"generate/avg_tokens_non_zero_rewards":5600.6923,"generate/avg_tokens_zero_rewards":2938.7303,"generate/max_num_tokens":27180,"generate/std_num_tokens":4337.686,"loss/avg_final_rewards":0.3555,"loss/avg_raw_advantages":0.0129,"loss/avg_raw_advantages_abs":0.1233,"policy/policy_entropy":0.0369,"policy/policy_loss":-0.0086,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0208,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.3555,"timing/step":5026.4629,"trainer/epoch":0}
+{"step":18,"async/staleness_mean":1.9531,"generate/avg_num_tokens":3891.8926,"generate/avg_tokens_non_zero_rewards":7625.4897,"generate/avg_tokens_zero_rewards":2416.7657,"generate/max_num_tokens":30131,"generate/std_num_tokens":5490.3941,"loss/avg_final_rewards":0.2832,"loss/avg_raw_advantages":0.023,"loss/avg_raw_advantages_abs":0.2999,"policy/policy_entropy":0.0211,"policy/policy_loss":-0.0187,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0128,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.2832,"timing/step":1340.1342,"trainer/epoch":0}
+{"step":19,"async/staleness_mean":1.7969,"generate/avg_num_tokens":3556.9355,"generate/avg_tokens_non_zero_rewards":6212.4203,"generate/avg_tokens_zero_rewards":2577.1043,"generate/max_num_tokens":31194,"generate/std_num_tokens":5555.2022,"loss/avg_final_rewards":0.2695,"loss/avg_raw_advantages":0.0373,"loss/avg_raw_advantages_abs":0.1216,"policy/policy_entropy":0.0214,"policy/policy_loss":-0.0168,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0171,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.2695,"timing/step":3726.9289,"trainer/epoch":0}
+{"step":20,"async/staleness_mean":1.9531,"generate/avg_num_tokens":4239.8027,"generate/avg_tokens_non_zero_rewards":5839.0,"generate/avg_tokens_zero_rewards":3136.7261,"generate/max_num_tokens":27132,"generate/std_num_tokens":5137.5811,"loss/avg_final_rewards":0.4082,"loss/avg_raw_advantages":0.0127,"loss/avg_raw_advantages_abs":0.1571,"policy/policy_entropy":0.0319,"policy/policy_loss":-0.0089,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0168,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.4082,"timing/step":3066.7613,"trainer/epoch":0}
+{"step":21,"async/staleness_mean":1.5312,"generate/avg_num_tokens":3199.2871,"generate/avg_tokens_non_zero_rewards":5553.7681,"generate/avg_tokens_zero_rewards":2330.5214,"generate/max_num_tokens":30770,"generate/std_num_tokens":4916.8226,"loss/avg_final_rewards":0.2695,"loss/avg_raw_advantages":0.021,"loss/avg_raw_advantages_abs":0.1296,"policy/policy_entropy":0.0252,"policy/policy_loss":-0.0058,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0133,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.2695,"timing/step":2831.6951,"trainer/epoch":0}
+{"step":22,"async/staleness_mean":1.9219,"generate/avg_num_tokens":3256.2715,"generate/avg_tokens_non_zero_rewards":5572.2785,"generate/avg_tokens_zero_rewards":2222.5734,"generate/max_num_tokens":20250,"generate/std_num_tokens":4011.3658,"loss/avg_final_rewards":0.3086,"loss/avg_raw_advantages":0.0222,"loss/avg_raw_advantages_abs":0.1556,"policy/policy_entropy":0.0298,"policy/policy_loss":-0.008,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0123,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.3086,"timing/step":3108.7729,"trainer/epoch":0}
+{"step":23,"async/staleness_mean":1.8438,"generate/avg_num_tokens":3942.6367,"generate/avg_tokens_non_zero_rewards":6538.8837,"generate/avg_tokens_zero_rewards":2629.2412,"generate/max_num_tokens":31316,"generate/std_num_tokens":5134.6975,"loss/avg_final_rewards":0.3359,"loss/avg_raw_advantages":0.0132,"loss/avg_raw_advantages_abs":0.1686,"policy/policy_entropy":0.0287,"policy/policy_loss":-0.0107,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0668,"reward/avg_pass_at_8":0.5469,"reward/avg_raw_reward":0.3359,"timing/step":2508.6885,"trainer/epoch":0}
+{"step":24,"async/staleness_mean":2.0781,"generate/avg_num_tokens":3206.0605,"generate/avg_tokens_non_zero_rewards":5638.4586,"generate/avg_tokens_zero_rewards":2130.3239,"generate/max_num_tokens":31119,"generate/std_num_tokens":4114.0874,"loss/avg_final_rewards":0.3066,"loss/avg_raw_advantages":0.0066,"loss/avg_raw_advantages_abs":0.1306,"policy/policy_entropy":0.0305,"policy/policy_loss":-0.0006,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0121,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.3066,"timing/step":2153.3934,"trainer/epoch":0}
+{"step":25,"async/staleness_mean":2.0312,"generate/avg_num_tokens":4323.1875,"generate/avg_tokens_non_zero_rewards":6594.0226,"generate/avg_tokens_zero_rewards":3123.3731,"generate/max_num_tokens":28049,"generate/std_num_tokens":4973.1141,"loss/avg_final_rewards":0.3457,"loss/avg_raw_advantages":0.0054,"loss/avg_raw_advantages_abs":0.1836,"policy/policy_entropy":0.0244,"policy/policy_loss":-0.0106,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0156,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.3457,"timing/step":3221.5509,"trainer/epoch":0}
+{"step":26,"async/staleness_mean":2.0,"generate/avg_num_tokens":3369.8633,"generate/avg_tokens_non_zero_rewards":6680.9032,"generate/avg_tokens_zero_rewards":1480.7423,"generate/max_num_tokens":23175,"generate/std_num_tokens":4426.3121,"loss/avg_final_rewards":0.3633,"loss/avg_raw_advantages":0.0363,"loss/avg_raw_advantages_abs":0.191,"policy/policy_entropy":0.0255,"policy/policy_loss":-0.0125,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.014,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.3633,"timing/step":3009.1833,"trainer/epoch":0}
+{"step":27,"async/staleness_mean":0.3906,"generate/avg_num_tokens":4734.0098,"generate/avg_tokens_non_zero_rewards":5301.7187,"generate/avg_tokens_zero_rewards":3730.5459,"generate/max_num_tokens":20084,"generate/std_num_tokens":3683.1818,"loss/avg_final_rewards":0.6387,"loss/avg_raw_advantages":0.0168,"loss/avg_raw_advantages_abs":0.1982,"policy/policy_entropy":0.0468,"policy/policy_loss":-0.0076,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0172,"reward/avg_pass_at_8":0.8,"reward/avg_raw_reward":0.6387,"timing/step":8253.2289,"trainer/epoch":0}
+{"step":28,"async/staleness_mean":1.0,"generate/avg_num_tokens":3503.1445,"generate/avg_tokens_non_zero_rewards":7824.5556,"generate/avg_tokens_zero_rewards":2467.2615,"generate/max_num_tokens":30411,"generate/std_num_tokens":5444.356,"loss/avg_final_rewards":0.1934,"loss/avg_raw_advantages":0.0426,"loss/avg_raw_advantages_abs":0.1969,"policy/policy_entropy":0.0153,"policy/policy_loss":-0.0174,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0089,"reward/avg_pass_at_8":0.4219,"reward/avg_raw_reward":0.1934,"timing/step":877.8049,"trainer/epoch":0}
+{"step":29,"async/staleness_mean":1.7812,"generate/avg_num_tokens":3965.5879,"generate/avg_tokens_non_zero_rewards":4949.3244,"generate/avg_tokens_zero_rewards":3194.3659,"generate/max_num_tokens":29557,"generate/std_num_tokens":4568.2977,"loss/avg_final_rewards":0.4395,"loss/avg_raw_advantages":0.0079,"loss/avg_raw_advantages_abs":0.1816,"policy/policy_entropy":0.0326,"policy/policy_loss":-0.0088,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0167,"reward/avg_pass_at_8":0.6719,"reward/avg_raw_reward":0.4395,"timing/step":2373.1954,"trainer/epoch":0}
+{"step":30,"async/staleness_mean":2.1562,"generate/avg_num_tokens":4404.9922,"generate/avg_tokens_non_zero_rewards":6360.2297,"generate/avg_tokens_zero_rewards":2908.2241,"generate/max_num_tokens":29058,"generate/std_num_tokens":4579.7426,"loss/avg_final_rewards":0.4336,"loss/avg_raw_advantages":0.0075,"loss/avg_raw_advantages_abs":0.1682,"policy/policy_entropy":0.033,"policy/policy_loss":-0.0065,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0156,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.4336,"timing/step":3572.8006,"trainer/epoch":0}
+{"step":31,"async/staleness_mean":2.5781,"generate/avg_num_tokens":3999.6875,"generate/avg_tokens_non_zero_rewards":6186.3742,"generate/avg_tokens_zero_rewards":3050.2857,"generate/max_num_tokens":29749,"generate/std_num_tokens":4909.8164,"loss/avg_final_rewards":0.3027,"loss/avg_raw_advantages":0.0018,"loss/avg_raw_advantages_abs":0.1616,"policy/policy_entropy":0.0305,"policy/policy_loss":-0.0124,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0204,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.3027,"timing/step":1794.4302,"trainer/epoch":0}
+{"step":32,"async/staleness_mean":2.3594,"generate/avg_num_tokens":3965.4336,"generate/avg_tokens_non_zero_rewards":6360.0714,"generate/avg_tokens_zero_rewards":2644.7545,"generate/max_num_tokens":24908,"generate/std_num_tokens":4427.5009,"loss/avg_final_rewards":0.3555,"loss/avg_raw_advantages":0.0451,"loss/avg_raw_advantages_abs":0.1816,"policy/policy_entropy":0.0315,"policy/policy_loss":-0.0219,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0165,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.3555,"timing/step":2352.6975,"trainer/epoch":0}
+{"step":33,"async/staleness_mean":1.9688,"generate/avg_num_tokens":3756.4199,"generate/avg_tokens_non_zero_rewards":5020.2679,"generate/avg_tokens_zero_rewards":2884.6568,"generate/max_num_tokens":29683,"generate/std_num_tokens":4355.1836,"loss/avg_final_rewards":0.4082,"loss/avg_raw_advantages":0.013,"loss/avg_raw_advantages_abs":0.1548,"policy/policy_entropy":0.0302,"policy/policy_loss":-0.0111,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.023,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.4082,"timing/step":3022.2582,"trainer/epoch":0}
+{"step":34,"async/staleness_mean":2.1094,"generate/avg_num_tokens":3504.6309,"generate/avg_tokens_non_zero_rewards":7160.2857,"generate/avg_tokens_zero_rewards":2221.7757,"generate/max_num_tokens":26231,"generate/std_num_tokens":4896.6027,"loss/avg_final_rewards":0.2598,"loss/avg_raw_advantages":0.0351,"loss/avg_raw_advantages_abs":0.136,"policy/policy_entropy":0.0225,"policy/policy_loss":-0.0161,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0101,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.2598,"timing/step":2524.0268,"trainer/epoch":0}
+{"step":35,"async/staleness_mean":2.0469,"generate/avg_num_tokens":4162.2695,"generate/avg_tokens_non_zero_rewards":6298.2949,"generate/avg_tokens_zero_rewards":2591.0237,"generate/max_num_tokens":31360,"generate/std_num_tokens":4591.9243,"loss/avg_final_rewards":0.4238,"loss/avg_raw_advantages":0.0075,"loss/avg_raw_advantages_abs":0.1742,"policy/policy_entropy":0.0235,"policy/policy_loss":-0.006,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0409,"reward/avg_pass_at_8":0.6719,"reward/avg_raw_reward":0.4238,"timing/step":2347.1455,"trainer/epoch":0}
+{"step":36,"async/staleness_mean":1.9219,"generate/avg_num_tokens":3721.7012,"generate/avg_tokens_non_zero_rewards":4800.5648,"generate/avg_tokens_zero_rewards":3068.9718,"generate/max_num_tokens":29714,"generate/std_num_tokens":4245.8268,"loss/avg_final_rewards":0.377,"loss/avg_raw_advantages":0.0102,"loss/avg_raw_advantages_abs":0.2038,"policy/policy_entropy":0.033,"policy/policy_loss":-0.0055,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0469,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.377,"timing/step":2721.9797,"trainer/epoch":0}
+{"step":37,"async/staleness_mean":2.1094,"generate/avg_num_tokens":3798.9453,"generate/avg_tokens_non_zero_rewards":5469.6588,"generate/avg_tokens_zero_rewards":2968.4737,"generate/max_num_tokens":29671,"generate/std_num_tokens":4825.2589,"loss/avg_final_rewards":0.332,"loss/avg_raw_advantages":0.0144,"loss/avg_raw_advantages_abs":0.1735,"policy/policy_entropy":0.0274,"policy/policy_loss":-0.0106,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0177,"reward/avg_pass_at_8":0.5156,"reward/avg_raw_reward":0.332,"timing/step":2876.2119,"trainer/epoch":0}
+{"step":38,"async/staleness_mean":1.9062,"generate/avg_num_tokens":3871.7402,"generate/avg_tokens_non_zero_rewards":6783.8218,"generate/avg_tokens_zero_rewards":2372.6213,"generate/max_num_tokens":26739,"generate/std_num_tokens":4882.4938,"loss/avg_final_rewards":0.3398,"loss/avg_raw_advantages":-0.0027,"loss/avg_raw_advantages_abs":0.1698,"policy/policy_entropy":0.024,"policy/policy_loss":-0.0043,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0127,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.3398,"timing/step":2213.9343,"trainer/epoch":0}
+{"step":39,"async/staleness_mean":1.8281,"generate/avg_num_tokens":4060.5625,"generate/avg_tokens_non_zero_rewards":5228.2353,"generate/avg_tokens_zero_rewards":3562.9192,"generate/max_num_tokens":28012,"generate/std_num_tokens":5343.7181,"loss/avg_final_rewards":0.2988,"loss/avg_raw_advantages":0.0237,"loss/avg_raw_advantages_abs":0.1214,"policy/policy_entropy":0.0233,"policy/policy_loss":-0.008,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0157,"reward/avg_pass_at_8":0.4375,"reward/avg_raw_reward":0.2988,"timing/step":2673.1147,"trainer/epoch":0}
+{"step":40,"async/staleness_mean":1.9688,"generate/avg_num_tokens":4187.6387,"generate/avg_tokens_non_zero_rewards":5793.3686,"generate/avg_tokens_zero_rewards":2814.6232,"generate/max_num_tokens":18121,"generate/std_num_tokens":4439.6933,"loss/avg_final_rewards":0.4609,"loss/avg_raw_advantages":0.0037,"loss/avg_raw_advantages_abs":0.118,"policy/policy_entropy":0.0303,"policy/policy_loss":-0.0032,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.012,"reward/avg_pass_at_8":0.625,"reward/avg_raw_reward":0.4609,"timing/step":2590.4576,"trainer/epoch":0}
+{"step":41,"async/staleness_mean":0.7344,"generate/avg_num_tokens":5014.9102,"generate/avg_tokens_non_zero_rewards":5363.7867,"generate/avg_tokens_zero_rewards":4573.4115,"generate/max_num_tokens":21764,"generate/std_num_tokens":3448.4712,"loss/avg_final_rewards":0.5586,"loss/avg_raw_advantages":0.0045,"loss/avg_raw_advantages_abs":0.16,"policy/policy_entropy":0.0359,"policy/policy_loss":-0.0062,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0191,"reward/avg_pass_at_8":0.75,"reward/avg_raw_reward":0.5586,"timing/step":7641.2515,"trainer/epoch":0}
+{"step":42,"async/staleness_mean":1.0,"generate/avg_num_tokens":4234.4883,"generate/avg_tokens_non_zero_rewards":7709.5957,"generate/avg_tokens_zero_rewards":2913.7601,"generate/max_num_tokens":25390,"generate/std_num_tokens":5166.8672,"loss/avg_final_rewards":0.2754,"loss/avg_raw_advantages":0.0715,"loss/avg_raw_advantages_abs":0.2396,"policy/policy_entropy":0.0205,"policy/policy_loss":-0.0386,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.1278,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.2754,"timing/step":809.0107,"trainer/epoch":0}
+{"step":43,"async/staleness_mean":1.9062,"generate/avg_num_tokens":4277.3184,"generate/avg_tokens_non_zero_rewards":6012.0857,"generate/avg_tokens_zero_rewards":3376.4748,"generate/max_num_tokens":35754,"generate/std_num_tokens":5085.0484,"loss/avg_final_rewards":0.3418,"loss/avg_raw_advantages":-0.0014,"loss/avg_raw_advantages_abs":0.1355,"policy/policy_entropy":0.0249,"policy/policy_loss":-0.0062,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0144,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.3418,"timing/step":2843.7962,"trainer/epoch":0}
+{"step":44,"async/staleness_mean":2.4219,"generate/avg_num_tokens":4201.5156,"generate/avg_tokens_non_zero_rewards":6196.9589,"generate/avg_tokens_zero_rewards":2710.041,"generate/max_num_tokens":25645,"generate/std_num_tokens":4505.7438,"loss/avg_final_rewards":0.4277,"loss/avg_raw_advantages":0.02,"loss/avg_raw_advantages_abs":0.196,"policy/policy_entropy":0.0289,"policy/policy_loss":-0.0125,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0205,"reward/avg_pass_at_8":0.6719,"reward/avg_raw_reward":0.4277,"timing/step":2403.379,"trainer/epoch":0}
+{"step":45,"async/staleness_mean":2.3594,"generate/avg_num_tokens":3554.498,"generate/avg_tokens_non_zero_rewards":5824.5833,"generate/avg_tokens_zero_rewards":2323.7289,"generate/max_num_tokens":28004,"generate/std_num_tokens":4192.7437,"loss/avg_final_rewards":0.3516,"loss/avg_raw_advantages":0.0091,"loss/avg_raw_advantages_abs":0.1841,"policy/policy_entropy":0.0278,"policy/policy_loss":-0.0127,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0174,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.3516,"timing/step":2111.06,"trainer/epoch":0}
+{"step":46,"async/staleness_mean":2.0625,"generate/avg_num_tokens":4247.9727,"generate/avg_tokens_non_zero_rewards":5589.4333,"generate/avg_tokens_zero_rewards":3315.1689,"generate/max_num_tokens":30401,"generate/std_num_tokens":4779.4237,"loss/avg_final_rewards":0.4102,"loss/avg_raw_advantages":0.0081,"loss/avg_raw_advantages_abs":0.1125,"policy/policy_entropy":0.0265,"policy/policy_loss":-0.0027,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0149,"reward/avg_pass_at_8":0.625,"reward/avg_raw_reward":0.4102,"timing/step":2808.4339,"trainer/epoch":0}
+{"step":47,"async/staleness_mean":2.2188,"generate/avg_num_tokens":4706.6543,"generate/avg_tokens_non_zero_rewards":6220.3009,"generate/avg_tokens_zero_rewards":3602.1014,"generate/max_num_tokens":29987,"generate/std_num_tokens":5076.1121,"loss/avg_final_rewards":0.4219,"loss/avg_raw_advantages":-0.0061,"loss/avg_raw_advantages_abs":0.2368,"policy/policy_entropy":0.0294,"policy/policy_loss":-0.0063,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0195,"reward/avg_pass_at_8":0.6719,"reward/avg_raw_reward":0.4219,"timing/step":2333.4236,"trainer/epoch":0}
+{"step":48,"async/staleness_mean":2.1719,"generate/avg_num_tokens":4437.375,"generate/avg_tokens_non_zero_rewards":6230.3756,"generate/avg_tokens_zero_rewards":3160.087,"generate/max_num_tokens":24808,"generate/std_num_tokens":4496.5138,"loss/avg_final_rewards":0.416,"loss/avg_raw_advantages":0.0075,"loss/avg_raw_advantages_abs":0.1863,"policy/policy_entropy":0.0275,"policy/policy_loss":-0.0004,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0128,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.416,"timing/step":2473.6369,"trainer/epoch":0}
+{"step":49,"async/staleness_mean":2.2969,"generate/avg_num_tokens":5040.9453,"generate/avg_tokens_non_zero_rewards":5835.8168,"generate/avg_tokens_zero_rewards":4522.9968,"generate/max_num_tokens":25559,"generate/std_num_tokens":4828.1681,"loss/avg_final_rewards":0.3945,"loss/avg_raw_advantages":0.0117,"loss/avg_raw_advantages_abs":0.1464,"policy/policy_entropy":0.033,"policy/policy_loss":-0.0052,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0169,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.3945,"timing/step":2328.2427,"trainer/epoch":0}
+{"step":50,"async/staleness_mean":2.4844,"generate/avg_num_tokens":4544.0625,"generate/avg_tokens_non_zero_rewards":6245.1566,"generate/avg_tokens_zero_rewards":3471.3981,"generate/max_num_tokens":25117,"generate/std_num_tokens":3843.4054,"loss/avg_final_rewards":0.3867,"loss/avg_raw_advantages":-0.0041,"loss/avg_raw_advantages_abs":0.2038,"policy/policy_entropy":0.0299,"policy/policy_loss":-0.002,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0175,"reward/avg_pass_at_8":0.6562,"reward/avg_raw_reward":0.3867,"timing/step":2052.8109,"trainer/epoch":0}
+{"step":51,"async/staleness_mean":2.4219,"generate/avg_num_tokens":4180.918,"generate/avg_tokens_non_zero_rewards":5545.2165,"generate/avg_tokens_zero_rewards":3348.6101,"generate/max_num_tokens":23252,"generate/std_num_tokens":4819.6171,"loss/avg_final_rewards":0.3789,"loss/avg_raw_advantages":0.0055,"loss/avg_raw_advantages_abs":0.1441,"policy/policy_entropy":0.0275,"policy/policy_loss":-0.0066,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0158,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.3789,"timing/step":2260.6657,"trainer/epoch":0}
+{"step":52,"async/staleness_mean":2.5938,"generate/avg_num_tokens":4455.75,"generate/avg_tokens_non_zero_rewards":6957.9505,"generate/avg_tokens_zero_rewards":2825.2839,"generate/max_num_tokens":30540,"generate/std_num_tokens":4759.6593,"loss/avg_final_rewards":0.3945,"loss/avg_raw_advantages":0.0314,"loss/avg_raw_advantages_abs":0.1364,"policy/policy_entropy":0.0211,"policy/policy_loss":-0.0143,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0096,"reward/avg_pass_at_8":0.625,"reward/avg_raw_reward":0.3945,"timing/step":5334.2377,"trainer/epoch":0}
+{"step":53,"async/staleness_mean":2.2344,"generate/avg_num_tokens":2974.4414,"generate/avg_tokens_non_zero_rewards":5231.4716,"generate/avg_tokens_zero_rewards":1792.1875,"generate/max_num_tokens":23029,"generate/std_num_tokens":3988.3975,"loss/avg_final_rewards":0.3438,"loss/avg_raw_advantages":0.1127,"loss/avg_raw_advantages_abs":0.1811,"policy/policy_entropy":0.0228,"policy/policy_loss":-0.0441,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0375,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.3438,"timing/step":3496.4626,"trainer/epoch":0}
+{"step":54,"async/staleness_mean":2.1719,"generate/avg_num_tokens":3025.7383,"generate/avg_tokens_non_zero_rewards":4947.9773,"generate/avg_tokens_zero_rewards":2018.8512,"generate/max_num_tokens":17298,"generate/std_num_tokens":3230.3986,"loss/avg_final_rewards":0.3438,"loss/avg_raw_advantages":0.109,"loss/avg_raw_advantages_abs":0.2328,"policy/policy_entropy":0.0263,"policy/policy_loss":-0.0476,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.018,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.3438,"timing/step":1967.8768,"trainer/epoch":0}
+{"step":55,"async/staleness_mean":0.2188,"generate/avg_num_tokens":4983.5684,"generate/avg_tokens_non_zero_rewards":5594.0812,"generate/avg_tokens_zero_rewards":4061.8137,"generate/max_num_tokens":21234,"generate/std_num_tokens":3444.2816,"loss/avg_final_rewards":0.6016,"loss/avg_raw_advantages":0.0189,"loss/avg_raw_advantages_abs":0.1898,"policy/policy_entropy":0.0339,"policy/policy_loss":-0.0177,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0176,"reward/avg_pass_at_8":0.7541,"reward/avg_raw_reward":0.6016,"timing/step":7700.0928,"trainer/epoch":0}
+{"step":56,"async/staleness_mean":1.0,"generate/avg_num_tokens":4016.0664,"generate/avg_tokens_non_zero_rewards":7264.2264,"generate/avg_tokens_zero_rewards":2553.0142,"generate/max_num_tokens":25297,"generate/std_num_tokens":4964.2252,"loss/avg_final_rewards":0.3105,"loss/avg_raw_advantages":0.0383,"loss/avg_raw_advantages_abs":0.2742,"policy/policy_entropy":0.0224,"policy/policy_loss":-0.0164,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0151,"reward/avg_pass_at_8":0.5469,"reward/avg_raw_reward":0.3105,"timing/step":698.2019,"trainer/epoch":0}
+{"step":57,"async/staleness_mean":1.9688,"generate/avg_num_tokens":3494.8184,"generate/avg_tokens_non_zero_rewards":5344.1636,"generate/avg_tokens_zero_rewards":2615.4467,"generate/max_num_tokens":25477,"generate/std_num_tokens":4190.2245,"loss/avg_final_rewards":0.3223,"loss/avg_raw_advantages":0.0173,"loss/avg_raw_advantages_abs":0.2263,"policy/policy_entropy":0.025,"policy/policy_loss":-0.015,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0175,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.3223,"timing/step":1666.5993,"trainer/epoch":0}
+{"step":58,"async/staleness_mean":2.2344,"generate/avg_num_tokens":4374.5781,"generate/avg_tokens_non_zero_rewards":5539.7117,"generate/avg_tokens_zero_rewards":3033.2059,"generate/max_num_tokens":17396,"generate/std_num_tokens":3565.8817,"loss/avg_final_rewards":0.5352,"loss/avg_raw_advantages":0.0235,"loss/avg_raw_advantages_abs":0.1949,"policy/policy_entropy":0.027,"policy/policy_loss":-0.013,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0221,"reward/avg_pass_at_8":0.7812,"reward/avg_raw_reward":0.5352,"timing/step":2546.9027,"trainer/epoch":0}
+{"step":59,"async/staleness_mean":2.2812,"generate/avg_num_tokens":4491.2891,"generate/avg_tokens_non_zero_rewards":5043.9627,"generate/avg_tokens_zero_rewards":3999.797,"generate/max_num_tokens":25211,"generate/std_num_tokens":4037.2616,"loss/avg_final_rewards":0.4707,"loss/avg_raw_advantages":0.0002,"loss/avg_raw_advantages_abs":0.1642,"policy/policy_entropy":0.0279,"policy/policy_loss":-0.0039,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0164,"reward/avg_pass_at_8":0.6562,"reward/avg_raw_reward":0.4707,"timing/step":2529.1779,"trainer/epoch":0}
+{"step":60,"async/staleness_mean":2.6406,"generate/avg_num_tokens":4325.4512,"generate/avg_tokens_non_zero_rewards":6503.0047,"generate/avg_tokens_zero_rewards":2749.1077,"generate/max_num_tokens":25313,"generate/std_num_tokens":4579.467,"loss/avg_final_rewards":0.4199,"loss/avg_raw_advantages":0.0244,"loss/avg_raw_advantages_abs":0.2086,"policy/policy_entropy":0.0233,"policy/policy_loss":-0.0161,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0104,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.4199,"timing/step":1310.3803,"trainer/epoch":0}
+{"step":61,"async/staleness_mean":2.4375,"generate/avg_num_tokens":4239.7832,"generate/avg_tokens_non_zero_rewards":5941.0693,"generate/avg_tokens_zero_rewards":2841.2171,"generate/max_num_tokens":26838,"generate/std_num_tokens":4123.1173,"loss/avg_final_rewards":0.4512,"loss/avg_raw_advantages":0.0195,"loss/avg_raw_advantages_abs":0.2248,"policy/policy_entropy":0.0245,"policy/policy_loss":-0.0112,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0205,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.4512,"timing/step":2339.0794,"trainer/epoch":0}
+{"step":62,"async/staleness_mean":2.5781,"generate/avg_num_tokens":4891.2207,"generate/avg_tokens_non_zero_rewards":6417.1683,"generate/avg_tokens_zero_rewards":3896.8935,"generate/max_num_tokens":27581,"generate/std_num_tokens":4785.9904,"loss/avg_final_rewards":0.3945,"loss/avg_raw_advantages":0.0074,"loss/avg_raw_advantages_abs":0.1881,"policy/policy_entropy":0.0247,"policy/policy_loss":-0.0039,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0143,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.3945,"timing/step":2045.6361,"trainer/epoch":0}
+{"step":63,"async/staleness_mean":2.2031,"generate/avg_num_tokens":4822.709,"generate/avg_tokens_non_zero_rewards":5594.5819,"generate/avg_tokens_zero_rewards":3739.1878,"generate/max_num_tokens":22463,"generate/std_num_tokens":3575.863,"loss/avg_final_rewards":0.584,"loss/avg_raw_advantages":0.0156,"loss/avg_raw_advantages_abs":0.1904,"policy/policy_entropy":0.0285,"policy/policy_loss":-0.0065,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0374,"reward/avg_pass_at_8":0.8281,"reward/avg_raw_reward":0.584,"timing/step":1623.7142,"trainer/epoch":0}
+{"step":64,"async/staleness_mean":2.7188,"generate/avg_num_tokens":4897.4883,"generate/avg_tokens_non_zero_rewards":5614.4464,"generate/avg_tokens_zero_rewards":4298.7384,"generate/max_num_tokens":29490,"generate/std_num_tokens":4482.8336,"loss/avg_final_rewards":0.4551,"loss/avg_raw_advantages":-0.0007,"loss/avg_raw_advantages_abs":0.1731,"policy/policy_entropy":0.0293,"policy/policy_loss":-0.0029,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0201,"reward/avg_pass_at_8":0.6875,"reward/avg_raw_reward":0.4551,"timing/step":1801.7146,"trainer/epoch":0}
+{"step":65,"async/staleness_mean":2.6406,"generate/avg_num_tokens":5770.957,"generate/avg_tokens_non_zero_rewards":6332.9202,"generate/avg_tokens_zero_rewards":5282.8285,"generate/max_num_tokens":22508,"generate/std_num_tokens":4287.7432,"loss/avg_final_rewards":0.4648,"loss/avg_raw_advantages":0.0155,"loss/avg_raw_advantages_abs":0.2291,"policy/policy_entropy":0.0293,"policy/policy_loss":-0.0071,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0197,"reward/avg_pass_at_8":0.7031,"reward/avg_raw_reward":0.4648,"timing/step":1732.397,"trainer/epoch":0}
+{"step":66,"async/staleness_mean":2.6562,"generate/avg_num_tokens":5634.877,"generate/avg_tokens_non_zero_rewards":6787.384,"generate/avg_tokens_zero_rewards":4641.6255,"generate/max_num_tokens":31352,"generate/std_num_tokens":5143.29,"loss/avg_final_rewards":0.4629,"loss/avg_raw_advantages":0.019,"loss/avg_raw_advantages_abs":0.2278,"policy/policy_entropy":0.0269,"policy/policy_loss":-0.0128,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0192,"reward/avg_pass_at_8":0.6562,"reward/avg_raw_reward":0.4629,"timing/step":1991.3162,"trainer/epoch":0}
+{"step":67,"async/staleness_mean":2.7031,"generate/avg_num_tokens":5362.1816,"generate/avg_tokens_non_zero_rewards":6330.2122,"generate/avg_tokens_zero_rewards":4212.1282,"generate/max_num_tokens":22071,"generate/std_num_tokens":3636.0517,"loss/avg_final_rewards":0.543,"loss/avg_raw_advantages":-0.0005,"loss/avg_raw_advantages_abs":0.1837,"policy/policy_entropy":0.0279,"policy/policy_loss":-0.0014,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0179,"reward/avg_pass_at_8":0.75,"reward/avg_raw_reward":0.543,"timing/step":1343.1399,"trainer/epoch":0}
+{"step":68,"async/staleness_mean":2.7812,"generate/avg_num_tokens":4970.2012,"generate/avg_tokens_non_zero_rewards":5580.6046,"generate/avg_tokens_zero_rewards":4325.4779,"generate/max_num_tokens":25827,"generate/std_num_tokens":4095.0748,"loss/avg_final_rewards":0.5137,"loss/avg_raw_advantages":0.0012,"loss/avg_raw_advantages_abs":0.1885,"policy/policy_entropy":0.0268,"policy/policy_loss":-0.0039,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0191,"reward/avg_pass_at_8":0.7344,"reward/avg_raw_reward":0.5137,"timing/step":1569.2032,"trainer/epoch":0}
+{"step":69,"async/staleness_mean":2.7656,"generate/avg_num_tokens":4856.9043,"generate/avg_tokens_non_zero_rewards":6299.4016,"generate/avg_tokens_zero_rewards":3543.5858,"generate/max_num_tokens":28538,"generate/std_num_tokens":3972.354,"loss/avg_final_rewards":0.4766,"loss/avg_raw_advantages":0.0233,"loss/avg_raw_advantages_abs":0.2329,"policy/policy_entropy":0.0252,"policy/policy_loss":-0.0181,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0355,"reward/avg_pass_at_8":0.7344,"reward/avg_raw_reward":0.4766,"timing/step":2174.8383,"trainer/epoch":0}
+{"step":70,"async/staleness_mean":2.5781,"generate/avg_num_tokens":4174.5391,"generate/avg_tokens_non_zero_rewards":5174.5363,"generate/avg_tokens_zero_rewards":3235.1477,"generate/max_num_tokens":23443,"generate/std_num_tokens":4084.7715,"loss/avg_final_rewards":0.4844,"loss/avg_raw_advantages":0.0041,"loss/avg_raw_advantages_abs":0.1119,"policy/policy_entropy":0.0253,"policy/policy_loss":-0.0044,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0136,"reward/avg_pass_at_8":0.6562,"reward/avg_raw_reward":0.4844,"timing/step":1889.4222,"trainer/epoch":0}
+{"step":71,"async/staleness_mean":2.2812,"generate/avg_num_tokens":4969.4277,"generate/avg_tokens_non_zero_rewards":6109.6913,"generate/avg_tokens_zero_rewards":4039.4255,"generate/max_num_tokens":29103,"generate/std_num_tokens":4638.401,"loss/avg_final_rewards":0.4492,"loss/avg_raw_advantages":0.008,"loss/avg_raw_advantages_abs":0.1585,"policy/policy_entropy":0.0263,"policy/policy_loss":-0.0073,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0281,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.4492,"timing/step":1848.6629,"trainer/epoch":0}
+{"step":72,"async/staleness_mean":2.625,"generate/avg_num_tokens":4861.5605,"generate/avg_tokens_non_zero_rewards":6199.4355,"generate/avg_tokens_zero_rewards":3604.7689,"generate/max_num_tokens":19869,"generate/std_num_tokens":4409.6282,"loss/avg_final_rewards":0.4844,"loss/avg_raw_advantages":0.0137,"loss/avg_raw_advantages_abs":0.1836,"policy/policy_entropy":0.0231,"policy/policy_loss":-0.0125,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0517,"reward/avg_pass_at_8":0.7188,"reward/avg_raw_reward":0.4844,"timing/step":1362.1325,"trainer/epoch":0}
+{"step":73,"async/staleness_mean":2.7031,"generate/avg_num_tokens":4400.0762,"generate/avg_tokens_non_zero_rewards":5518.6064,"generate/avg_tokens_zero_rewards":3341.0875,"generate/max_num_tokens":23078,"generate/std_num_tokens":4122.3915,"loss/avg_final_rewards":0.4863,"loss/avg_raw_advantages":0.0024,"loss/avg_raw_advantages_abs":0.2172,"policy/policy_entropy":0.025,"policy/policy_loss":-0.0054,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0687,"reward/avg_pass_at_8":0.6875,"reward/avg_raw_reward":0.4863,"timing/step":2094.5654,"trainer/epoch":0}
+{"step":74,"async/staleness_mean":2.5625,"generate/avg_num_tokens":4532.9746,"generate/avg_tokens_non_zero_rewards":5339.6484,"generate/avg_tokens_zero_rewards":3295.0099,"generate/max_num_tokens":26198,"generate/std_num_tokens":3759.0977,"loss/avg_final_rewards":0.6055,"loss/avg_raw_advantages":0.0214,"loss/avg_raw_advantages_abs":0.1527,"policy/policy_entropy":0.0276,"policy/policy_loss":-0.0083,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0191,"reward/avg_pass_at_8":0.8438,"reward/avg_raw_reward":0.6055,"timing/step":1415.8977,"trainer/epoch":0}
+{"step":75,"async/staleness_mean":0.5312,"generate/avg_num_tokens":4576.875,"generate/avg_tokens_non_zero_rewards":4728.5101,"generate/avg_tokens_zero_rewards":4369.0787,"generate/max_num_tokens":17535,"generate/std_num_tokens":3160.5729,"loss/avg_final_rewards":0.5781,"loss/avg_raw_advantages":0.0119,"loss/avg_raw_advantages_abs":0.1715,"policy/policy_entropy":0.0328,"policy/policy_loss":-0.0082,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0306,"reward/avg_pass_at_8":0.7931,"reward/avg_raw_reward":0.5781,"timing/step":6652.8217,"trainer/epoch":0}
+{"step":76,"async/staleness_mean":0.9844,"generate/avg_num_tokens":4948.4961,"generate/avg_tokens_non_zero_rewards":6104.6826,"generate/avg_tokens_zero_rewards":4005.5071,"generate/max_num_tokens":29321,"generate/std_num_tokens":4568.6688,"loss/avg_final_rewards":0.4492,"loss/avg_raw_advantages":0.027,"loss/avg_raw_advantages_abs":0.1829,"policy/policy_entropy":0.0254,"policy/policy_loss":-0.0218,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0182,"reward/avg_pass_at_8":0.6719,"reward/avg_raw_reward":0.4492,"timing/step":1520.4627,"trainer/epoch":0}
+{"step":77,"async/staleness_mean":1.875,"generate/avg_num_tokens":3918.4082,"generate/avg_tokens_non_zero_rewards":6218.3667,"generate/avg_tokens_zero_rewards":2671.4428,"generate/max_num_tokens":25717,"generate/std_num_tokens":4431.6038,"loss/avg_final_rewards":0.3516,"loss/avg_raw_advantages":0.0006,"loss/avg_raw_advantages_abs":0.1057,"policy/policy_entropy":0.0157,"policy/policy_loss":-0.0085,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0128,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.3516,"timing/step":582.7078,"trainer/epoch":0}
+{"step":78,"async/staleness_mean":2.4219,"generate/avg_num_tokens":4184.1621,"generate/avg_tokens_non_zero_rewards":5520.4978,"generate/avg_tokens_zero_rewards":3102.8163,"generate/max_num_tokens":16019,"generate/std_num_tokens":3591.7024,"loss/avg_final_rewards":0.4473,"loss/avg_raw_advantages":0.0128,"loss/avg_raw_advantages_abs":0.2054,"policy/policy_entropy":0.0255,"policy/policy_loss":-0.0059,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0179,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.4473,"timing/step":2340.5418,"trainer/epoch":0}
diff --git a/viewer/build/inputs/marin/runs/marin-a3-inferredbugs/run.json b/viewer/build/inputs/marin/runs/marin-a3-inferredbugs/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..e772b2c738655d5d232bb1b7dc00ff11f164dd52
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-a3-inferredbugs/run.json
@@ -0,0 +1,27 @@
+{
+ "id": "marin-a3-inferredbugs",
+ "title": "A3 RLOO on inferredbugs-sandboxes-verifier (Qwen3-8B agent)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/laion/a3-rl-DCAgent_inferredbugs-sandboxes-verifier-55-8B/tree/main/training_logs",
+ "license": "unknown",
+ "model": "laion/a3-rl-DCAgent_inferredbugs-sandboxes-verifier-55-8B",
+ "base_model": "laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink",
+ "method": "RLOO-N (SkyRL, binary verifier reward)",
+ "dataset": "DCAgent/inferredbugs-sandboxes-verifier",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-05-25T01:27:54Z",
+ "attempts": 0,
+ "note": "Marin A3 sweep (issue #6187): one RLOO-N run per training dataset from the same Qwen3-8B-derived SFT agent, here DCAgent/inferredbugs-sandboxes-verifier; EMA-best step 55 at reward 0.602, per the issue. Our copy has every logged step of the final lineage (7 resumed job segments, 2 superseded rows dropped). The issue concluded this binary-reward setup was uninformative about dataset utility.",
+ "metrics_map": {
+  "reward": "reward/avg_raw_reward",
+  "loss": "policy/policy_loss",
+  "entropy": "policy/policy_entropy",
+  "grad_norm": "policy/raw_grad_norm",
+  "response_length": "generate/avg_num_tokens"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-a3-llm-verifier-freelancer/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-a3-llm-verifier-freelancer/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..6929ee91cc0561fb0491116e62b3e643f83b3a4b
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-a3-llm-verifier-freelancer/metrics.jsonl
@@ -0,0 +1,76 @@
+{"step":1,"async/staleness_mean":0.0,"generate/avg_num_tokens":6833.9395,"generate/avg_tokens_non_zero_rewards":7155.1346,"generate/avg_tokens_zero_rewards":5442.0938,"generate/max_num_tokens":30654,"generate/std_num_tokens":5046.9818,"loss/avg_final_rewards":0.5664,"loss/avg_raw_advantages":0.0248,"loss/avg_raw_advantages_abs":0.2355,"policy/policy_entropy":0.2043,"policy/policy_loss":-0.0058,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0234,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.5664,"timing/step":3854.9161,"trainer/epoch":0}
+{"step":2,"async/staleness_mean":0.9062,"generate/avg_num_tokens":8661.0078,"generate/avg_tokens_non_zero_rewards":8783.2251,"generate/avg_tokens_zero_rewards":8266.0744,"generate/max_num_tokens":32047,"generate/std_num_tokens":5953.0178,"loss/avg_final_rewards":0.4891,"loss/avg_raw_advantages":0.0114,"loss/avg_raw_advantages_abs":0.2438,"policy/policy_entropy":0.1978,"policy/policy_loss":-0.0068,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0227,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.4891,"timing/step":3100.7366,"trainer/epoch":0}
+{"step":3,"async/staleness_mean":1.8594,"generate/avg_num_tokens":9751.8027,"generate/avg_tokens_non_zero_rewards":11110.7092,"generate/avg_tokens_zero_rewards":6279.0417,"generate/max_num_tokens":31830,"generate/std_num_tokens":7140.833,"loss/avg_final_rewards":0.4268,"loss/avg_raw_advantages":0.0158,"loss/avg_raw_advantages_abs":0.2256,"policy/policy_entropy":0.1712,"policy/policy_loss":-0.01,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0204,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.4268,"timing/step":2035.4234,"trainer/epoch":0}
+{"step":4,"async/staleness_mean":2.6875,"generate/avg_num_tokens":11438.873,"generate/avg_tokens_non_zero_rewards":13812.7345,"generate/avg_tokens_zero_rewards":6787.2023,"generate/max_num_tokens":32985,"generate/std_num_tokens":8297.216,"loss/avg_final_rewards":0.3528,"loss/avg_raw_advantages":0.0135,"loss/avg_raw_advantages_abs":0.1855,"policy/policy_entropy":0.1521,"policy/policy_loss":-0.0034,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.02,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.3528,"timing/step":824.0228,"trainer/epoch":0}
+{"step":5,"async/staleness_mean":3.0312,"generate/avg_num_tokens":8473.5078,"generate/avg_tokens_non_zero_rewards":11101.1261,"generate/avg_tokens_zero_rewards":3585.257,"generate/max_num_tokens":32045,"generate/std_num_tokens":7384.1156,"loss/avg_final_rewards":0.3561,"loss/avg_raw_advantages":0.0113,"loss/avg_raw_advantages_abs":0.1719,"policy/policy_entropy":0.1423,"policy/policy_loss":-0.0105,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0154,"reward/avg_pass_at_8":0.9375,"reward/avg_raw_reward":0.3561,"timing/step":2368.7394,"trainer/epoch":0}
+{"step":6,"async/staleness_mean":2.9219,"generate/avg_num_tokens":9709.6738,"generate/avg_tokens_non_zero_rewards":11000.4118,"generate/avg_tokens_zero_rewards":4646.0096,"generate/max_num_tokens":31767,"generate/std_num_tokens":7106.1134,"loss/avg_final_rewards":0.4579,"loss/avg_raw_advantages":0.0209,"loss/avg_raw_advantages_abs":0.1416,"policy/policy_entropy":0.1599,"policy/policy_loss":-0.0159,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0136,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.4579,"timing/step":2055.0597,"trainer/epoch":0}
+{"step":7,"async/staleness_mean":2.9844,"generate/avg_num_tokens":8835.0137,"generate/avg_tokens_non_zero_rewards":10083.2451,"generate/avg_tokens_zero_rewards":3938.1058,"generate/max_num_tokens":32048,"generate/std_num_tokens":6535.2771,"loss/avg_final_rewards":0.4908,"loss/avg_raw_advantages":0.0172,"loss/avg_raw_advantages_abs":0.1832,"policy/policy_entropy":0.1648,"policy/policy_loss":-0.0101,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0164,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.4908,"timing/step":2973.8084,"trainer/epoch":0}
+{"step":8,"async/staleness_mean":2.5156,"generate/avg_num_tokens":8257.9219,"generate/avg_tokens_non_zero_rewards":11010.7934,"generate/avg_tokens_zero_rewards":1551.2617,"generate/max_num_tokens":32120,"generate/std_num_tokens":7447.5951,"loss/avg_final_rewards":0.4457,"loss/avg_raw_advantages":0.0088,"loss/avg_raw_advantages_abs":0.1721,"policy/policy_entropy":0.1292,"policy/policy_loss":-0.0226,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0138,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.4457,"timing/step":2149.1646,"trainer/epoch":0}
+{"step":9,"async/staleness_mean":2.7188,"generate/avg_num_tokens":9825.5918,"generate/avg_tokens_non_zero_rewards":11938.4278,"generate/avg_tokens_zero_rewards":2692.5128,"generate/max_num_tokens":32118,"generate/std_num_tokens":7441.7294,"loss/avg_final_rewards":0.4697,"loss/avg_raw_advantages":0.0195,"loss/avg_raw_advantages_abs":0.1718,"policy/policy_entropy":0.1446,"policy/policy_loss":-0.0223,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0271,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.4697,"timing/step":1945.6135,"trainer/epoch":0}
+{"step":10,"async/staleness_mean":0.3281,"generate/avg_num_tokens":8510.8438,"generate/avg_tokens_non_zero_rewards":9187.2851,"generate/avg_tokens_zero_rewards":3002.6786,"generate/max_num_tokens":31705,"generate/std_num_tokens":5658.3599,"loss/avg_final_rewards":0.5799,"loss/avg_raw_advantages":0.0365,"loss/avg_raw_advantages_abs":0.1551,"policy/policy_entropy":0.1728,"policy/policy_loss":-0.022,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0187,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.5799,"timing/step":7833.5253,"trainer/epoch":0}
+{"step":11,"async/staleness_mean":1.0,"generate/avg_num_tokens":10939.0723,"generate/avg_tokens_non_zero_rewards":14077.518,"generate/avg_tokens_zero_rewards":3435.9007,"generate/max_num_tokens":32122,"generate/std_num_tokens":8655.8075,"loss/avg_final_rewards":0.4057,"loss/avg_raw_advantages":-0.0024,"loss/avg_raw_advantages_abs":0.1477,"policy/policy_entropy":0.1192,"policy/policy_loss":-0.0136,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0121,"reward/avg_pass_at_8":0.9375,"reward/avg_raw_reward":0.4057,"timing/step":1125.0477,"trainer/epoch":0}
+{"step":12,"async/staleness_mean":1.875,"generate/avg_num_tokens":10134.1504,"generate/avg_tokens_non_zero_rewards":12561.2746,"generate/avg_tokens_zero_rewards":2698.6746,"generate/max_num_tokens":32120,"generate/std_num_tokens":8078.7739,"loss/avg_final_rewards":0.4517,"loss/avg_raw_advantages":0.0026,"loss/avg_raw_advantages_abs":0.171,"policy/policy_entropy":0.1254,"policy/policy_loss":-0.0125,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0203,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.4517,"timing/step":1694.0212,"trainer/epoch":0}
+{"step":13,"async/staleness_mean":2.3906,"generate/avg_num_tokens":9665.498,"generate/avg_tokens_non_zero_rewards":10825.1273,"generate/avg_tokens_zero_rewards":3403.5,"generate/max_num_tokens":31846,"generate/std_num_tokens":6770.7501,"loss/avg_final_rewards":0.529,"loss/avg_raw_advantages":0.0169,"loss/avg_raw_advantages_abs":0.1458,"policy/policy_entropy":0.1541,"policy/policy_loss":-0.0092,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0123,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.529,"timing/step":2774.1276,"trainer/epoch":0}
+{"step":14,"async/staleness_mean":2.5469,"generate/avg_num_tokens":9017.6797,"generate/avg_tokens_non_zero_rewards":10972.3399,"generate/avg_tokens_zero_rewards":1255.9709,"generate/max_num_tokens":32118,"generate/std_num_tokens":6784.8966,"loss/avg_final_rewards":0.5264,"loss/avg_raw_advantages":0.0298,"loss/avg_raw_advantages_abs":0.1343,"policy/policy_entropy":0.1406,"policy/policy_loss":-0.0188,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0116,"reward/avg_pass_at_8":0.9375,"reward/avg_raw_reward":0.5264,"timing/step":2628.9733,"trainer/epoch":0}
+{"step":15,"async/staleness_mean":2.8906,"generate/avg_num_tokens":10018.084,"generate/avg_tokens_non_zero_rewards":11944.8235,"generate/avg_tokens_zero_rewards":3792.0083,"generate/max_num_tokens":32108,"generate/std_num_tokens":7642.9612,"loss/avg_final_rewards":0.4393,"loss/avg_raw_advantages":0.0123,"loss/avg_raw_advantages_abs":0.159,"policy/policy_entropy":0.1332,"policy/policy_loss":-0.0102,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0122,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.4393,"timing/step":1612.1218,"trainer/epoch":0}
+{"step":16,"async/staleness_mean":0.7188,"generate/avg_num_tokens":7710.1855,"generate/avg_tokens_non_zero_rewards":8252.7751,"generate/avg_tokens_zero_rewards":3108.2222,"generate/max_num_tokens":31754,"generate/std_num_tokens":5364.2242,"loss/avg_final_rewards":0.5849,"loss/avg_raw_advantages":0.0239,"loss/avg_raw_advantages_abs":0.1484,"policy/policy_entropy":0.1659,"policy/policy_loss":-0.0155,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0151,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.5849,"timing/step":6444.7011,"trainer/epoch":0}
+{"step":17,"async/staleness_mean":0.9844,"generate/avg_num_tokens":10174.5684,"generate/avg_tokens_non_zero_rewards":12229.3085,"generate/avg_tokens_zero_rewards":2665.4273,"generate/max_num_tokens":32050,"generate/std_num_tokens":7609.0707,"loss/avg_final_rewards":0.4872,"loss/avg_raw_advantages":0.0266,"loss/avg_raw_advantages_abs":0.1505,"policy/policy_entropy":0.1356,"policy/policy_loss":-0.021,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0127,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.4872,"timing/step":2344.092,"trainer/epoch":0}
+{"step":18,"async/staleness_mean":1.7656,"generate/avg_num_tokens":10939.5273,"generate/avg_tokens_non_zero_rewards":13794.5484,"generate/avg_tokens_zero_rewards":3353.3286,"generate/max_num_tokens":32046,"generate/std_num_tokens":8679.4954,"loss/avg_final_rewards":0.4208,"loss/avg_raw_advantages":0.007,"loss/avg_raw_advantages_abs":0.1411,"policy/policy_entropy":0.1162,"policy/policy_loss":-0.0068,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0107,"reward/avg_pass_at_8":0.9531,"reward/avg_raw_reward":0.4208,"timing/step":1400.3478,"trainer/epoch":0}
+{"step":19,"async/staleness_mean":2.3438,"generate/avg_num_tokens":8532.4668,"generate/avg_tokens_non_zero_rewards":9477.3466,"generate/avg_tokens_zero_rewards":3785.8353,"generate/max_num_tokens":32044,"generate/std_num_tokens":6449.129,"loss/avg_final_rewards":0.5238,"loss/avg_raw_advantages":0.0355,"loss/avg_raw_advantages_abs":0.1371,"policy/policy_entropy":0.1502,"policy/policy_loss":-0.017,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0128,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.5238,"timing/step":1864.9276,"trainer/epoch":0}
+{"step":20,"async/staleness_mean":2.8281,"generate/avg_num_tokens":8662.2715,"generate/avg_tokens_non_zero_rewards":9761.8886,"generate/avg_tokens_zero_rewards":3506.2889,"generate/max_num_tokens":32045,"generate/std_num_tokens":6046.8415,"loss/avg_final_rewards":0.5943,"loss/avg_raw_advantages":0.0077,"loss/avg_raw_advantages_abs":0.1446,"policy/policy_entropy":0.1525,"policy/policy_loss":-0.0092,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0141,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.5943,"timing/step":2429.2105,"trainer/epoch":0}
+{"step":21,"async/staleness_mean":2.6562,"generate/avg_num_tokens":9512.9219,"generate/avg_tokens_non_zero_rewards":11186.8321,"generate/avg_tokens_zero_rewards":2165.3368,"generate/max_num_tokens":32046,"generate/std_num_tokens":7091.9621,"loss/avg_final_rewards":0.505,"loss/avg_raw_advantages":0.0152,"loss/avg_raw_advantages_abs":0.1465,"policy/policy_entropy":0.1382,"policy/policy_loss":-0.0121,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0122,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.505,"timing/step":2222.8783,"trainer/epoch":0}
+{"step":22,"async/staleness_mean":0.7812,"generate/avg_num_tokens":8607.3203,"generate/avg_tokens_non_zero_rewards":9263.9739,"generate/avg_tokens_zero_rewards":2920.4528,"generate/max_num_tokens":31752,"generate/std_num_tokens":5678.662,"loss/avg_final_rewards":0.6205,"loss/avg_raw_advantages":0.0245,"loss/avg_raw_advantages_abs":0.1402,"policy/policy_entropy":0.1559,"policy/policy_loss":-0.0138,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0156,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.6205,"timing/step":7128.5454,"trainer/epoch":0}
+{"step":23,"async/staleness_mean":1.0,"generate/avg_num_tokens":10841.8223,"generate/avg_tokens_non_zero_rewards":13884.7411,"generate/avg_tokens_zero_rewards":3140.0897,"generate/max_num_tokens":32120,"generate/std_num_tokens":8445.9015,"loss/avg_final_rewards":0.4345,"loss/avg_raw_advantages":0.0334,"loss/avg_raw_advantages_abs":0.1464,"policy/policy_entropy":0.1132,"policy/policy_loss":-0.0233,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0133,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.4345,"timing/step":2101.9452,"trainer/epoch":0}
+{"step":24,"async/staleness_mean":1.9062,"generate/avg_num_tokens":10107.7227,"generate/avg_tokens_non_zero_rewards":12953.8747,"generate/avg_tokens_zero_rewards":3429.4967,"generate/max_num_tokens":31852,"generate/std_num_tokens":8266.8672,"loss/avg_final_rewards":0.4389,"loss/avg_raw_advantages":0.0125,"loss/avg_raw_advantages_abs":0.168,"policy/policy_entropy":0.1111,"policy/policy_loss":-0.0134,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0127,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.4389,"timing/step":1092.8984,"trainer/epoch":0}
+{"step":25,"async/staleness_mean":2.2812,"generate/avg_num_tokens":9390.4082,"generate/avg_tokens_non_zero_rewards":10635.257,"generate/avg_tokens_zero_rewards":3047.6071,"generate/max_num_tokens":31893,"generate/std_num_tokens":7153.5074,"loss/avg_final_rewards":0.5253,"loss/avg_raw_advantages":0.012,"loss/avg_raw_advantages_abs":0.1503,"policy/policy_entropy":0.1425,"policy/policy_loss":-0.0075,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0187,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.5253,"timing/step":2718.5878,"trainer/epoch":0}
+{"step":26,"async/staleness_mean":2.5625,"generate/avg_num_tokens":9182.2207,"generate/avg_tokens_non_zero_rewards":9713.4084,"generate/avg_tokens_zero_rewards":2362.9189,"generate/max_num_tokens":31707,"generate/std_num_tokens":6016.6304,"loss/avg_final_rewards":0.6262,"loss/avg_raw_advantages":0.0158,"loss/avg_raw_advantages_abs":0.124,"policy/policy_entropy":0.1515,"policy/policy_loss":-0.0056,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0119,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.6262,"timing/step":2192.0123,"trainer/epoch":0}
+{"step":27,"async/staleness_mean":2.8438,"generate/avg_num_tokens":10177.2734,"generate/avg_tokens_non_zero_rewards":11794.7915,"generate/avg_tokens_zero_rewards":2592.9111,"generate/max_num_tokens":32115,"generate/std_num_tokens":7898.6955,"loss/avg_final_rewards":0.5667,"loss/avg_raw_advantages":0.0169,"loss/avg_raw_advantages_abs":0.1284,"policy/policy_entropy":0.1255,"policy/policy_loss":-0.0154,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0121,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.5667,"timing/step":2114.1214,"trainer/epoch":0}
+{"step":28,"async/staleness_mean":0.75,"generate/avg_num_tokens":8692.0527,"generate/avg_tokens_non_zero_rewards":9277.3557,"generate/avg_tokens_zero_rewards":4666.9692,"generate/max_num_tokens":31733,"generate/std_num_tokens":6704.6075,"loss/avg_final_rewards":0.5886,"loss/avg_raw_advantages":0.0166,"loss/avg_raw_advantages_abs":0.1246,"policy/policy_entropy":0.149,"policy/policy_loss":-0.0179,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0137,"reward/avg_pass_at_8":0.9815,"reward/avg_raw_reward":0.5886,"timing/step":8105.2142,"trainer/epoch":0}
+{"step":29,"async/staleness_mean":1.0,"generate/avg_num_tokens":10905.0195,"generate/avg_tokens_non_zero_rewards":14689.5271,"generate/avg_tokens_zero_rewards":2654.323,"generate/max_num_tokens":31884,"generate/std_num_tokens":9216.2628,"loss/avg_final_rewards":0.4064,"loss/avg_raw_advantages":0.0296,"loss/avg_raw_advantages_abs":0.1358,"policy/policy_entropy":0.0998,"policy/policy_loss":-0.0205,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.011,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.4064,"timing/step":1155.1303,"trainer/epoch":0}
+{"step":30,"async/staleness_mean":1.9531,"generate/avg_num_tokens":11282.5879,"generate/avg_tokens_non_zero_rewards":14253.5969,"generate/avg_tokens_zero_rewards":2552.3923,"generate/max_num_tokens":32120,"generate/std_num_tokens":8607.3032,"loss/avg_final_rewards":0.448,"loss/avg_raw_advantages":0.0173,"loss/avg_raw_advantages_abs":0.1516,"policy/policy_entropy":0.1042,"policy/policy_loss":-0.0177,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0104,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.448,"timing/step":1069.2842,"trainer/epoch":0}
+{"step":31,"async/staleness_mean":2.4062,"generate/avg_num_tokens":9116.4531,"generate/avg_tokens_non_zero_rewards":10364.7674,"generate/avg_tokens_zero_rewards":3637.0105,"generate/max_num_tokens":32047,"generate/std_num_tokens":6662.5562,"loss/avg_final_rewards":0.5596,"loss/avg_raw_advantages":0.0125,"loss/avg_raw_advantages_abs":0.1174,"policy/policy_entropy":0.1297,"policy/policy_loss":-0.0064,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0106,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.5596,"timing/step":3380.0364,"trainer/epoch":0}
+{"step":32,"async/staleness_mean":2.5312,"generate/avg_num_tokens":9350.9492,"generate/avg_tokens_non_zero_rewards":11628.3231,"generate/avg_tokens_zero_rewards":2070.8197,"generate/max_num_tokens":32051,"generate/std_num_tokens":7606.569,"loss/avg_final_rewards":0.516,"loss/avg_raw_advantages":0.0084,"loss/avg_raw_advantages_abs":0.146,"policy/policy_entropy":0.1175,"policy/policy_loss":-0.0091,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0139,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.516,"timing/step":2638.9178,"trainer/epoch":0}
+{"step":33,"async/staleness_mean":2.5,"generate/avg_num_tokens":11750.9355,"generate/avg_tokens_non_zero_rewards":13641.2512,"generate/avg_tokens_zero_rewards":3765.3163,"generate/max_num_tokens":32123,"generate/std_num_tokens":8456.3621,"loss/avg_final_rewards":0.4489,"loss/avg_raw_advantages":0.0123,"loss/avg_raw_advantages_abs":0.1183,"policy/policy_entropy":0.1132,"policy/policy_loss":-0.0066,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0119,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.4489,"timing/step":1628.9191,"trainer/epoch":0}
+{"step":34,"async/staleness_mean":2.5,"generate/avg_num_tokens":9573.7402,"generate/avg_tokens_non_zero_rewards":10717.4671,"generate/avg_tokens_zero_rewards":2469.7465,"generate/max_num_tokens":32045,"generate/std_num_tokens":6242.7726,"loss/avg_final_rewards":0.5954,"loss/avg_raw_advantages":0.019,"loss/avg_raw_advantages_abs":0.1491,"policy/policy_entropy":0.133,"policy/policy_loss":-0.0101,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0128,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.5954,"timing/step":2030.3738,"trainer/epoch":0}
+{"step":35,"async/staleness_mean":2.4844,"generate/avg_num_tokens":10894.6309,"generate/avg_tokens_non_zero_rewards":12434.633,"generate/avg_tokens_zero_rewards":2059.8816,"generate/max_num_tokens":32051,"generate/std_num_tokens":7367.9947,"loss/avg_final_rewards":0.5028,"loss/avg_raw_advantages":0.0081,"loss/avg_raw_advantages_abs":0.114,"policy/policy_entropy":0.1195,"policy/policy_loss":-0.0086,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0127,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.5028,"timing/step":3126.3372,"trainer/epoch":0}
+{"step":36,"async/staleness_mean":2.5781,"generate/avg_num_tokens":10317.5273,"generate/avg_tokens_non_zero_rewards":12661.5225,"generate/avg_tokens_zero_rewards":1946.1161,"generate/max_num_tokens":32119,"generate/std_num_tokens":7794.2575,"loss/avg_final_rewards":0.5109,"loss/avg_raw_advantages":0.0014,"loss/avg_raw_advantages_abs":0.1617,"policy/policy_entropy":0.1122,"policy/policy_loss":-0.0106,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0126,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.5109,"timing/step":2236.2336,"trainer/epoch":0}
+{"step":37,"async/staleness_mean":2.3125,"generate/avg_num_tokens":10482.5938,"generate/avg_tokens_non_zero_rewards":11641.9167,"generate/avg_tokens_zero_rewards":5934.4808,"generate/max_num_tokens":32051,"generate/std_num_tokens":7190.2295,"loss/avg_final_rewards":0.4886,"loss/avg_raw_advantages":0.004,"loss/avg_raw_advantages_abs":0.135,"policy/policy_entropy":0.1224,"policy/policy_loss":-0.0074,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0126,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.4886,"timing/step":1792.8176,"trainer/epoch":0}
+{"step":38,"async/staleness_mean":2.3438,"generate/avg_num_tokens":9999.0859,"generate/avg_tokens_non_zero_rewards":11378.8105,"generate/avg_tokens_zero_rewards":1832.6081,"generate/max_num_tokens":31882,"generate/std_num_tokens":7055.9958,"loss/avg_final_rewards":0.5558,"loss/avg_raw_advantages":0.0107,"loss/avg_raw_advantages_abs":0.1305,"policy/policy_entropy":0.1208,"policy/policy_loss":-0.0049,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0121,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.5558,"timing/step":2562.2797,"trainer/epoch":0}
+{"step":39,"async/staleness_mean":2.3438,"generate/avg_num_tokens":9061.4551,"generate/avg_tokens_non_zero_rewards":10640.0995,"generate/avg_tokens_zero_rewards":3292.2273,"generate/max_num_tokens":32045,"generate/std_num_tokens":7388.3659,"loss/avg_final_rewards":0.4996,"loss/avg_raw_advantages":0.0168,"loss/avg_raw_advantages_abs":0.1453,"policy/policy_entropy":0.1188,"policy/policy_loss":-0.0131,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0149,"reward/avg_pass_at_8":0.9531,"reward/avg_raw_reward":0.4996,"timing/step":2320.4125,"trainer/epoch":0}
+{"step":40,"async/staleness_mean":2.5625,"generate/avg_num_tokens":10218.9258,"generate/avg_tokens_non_zero_rewards":11969.8435,"generate/avg_tokens_zero_rewards":3266.2524,"generate/max_num_tokens":32049,"generate/std_num_tokens":6845.5778,"loss/avg_final_rewards":0.5163,"loss/avg_raw_advantages":0.0291,"loss/avg_raw_advantages_abs":0.1419,"policy/policy_entropy":0.1153,"policy/policy_loss":-0.016,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0126,"reward/avg_pass_at_8":0.9531,"reward/avg_raw_reward":0.5163,"timing/step":1652.7905,"trainer/epoch":0}
+{"step":41,"async/staleness_mean":2.7344,"generate/avg_num_tokens":9904.8164,"generate/avg_tokens_non_zero_rewards":11499.066,"generate/avg_tokens_zero_rewards":2223.4318,"generate/max_num_tokens":32042,"generate/std_num_tokens":6720.7832,"loss/avg_final_rewards":0.5634,"loss/avg_raw_advantages":0.0143,"loss/avg_raw_advantages_abs":0.1337,"policy/policy_entropy":0.1218,"policy/policy_loss":-0.0089,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0132,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.5634,"timing/step":2326.2753,"trainer/epoch":0}
+{"step":42,"async/staleness_mean":2.5625,"generate/avg_num_tokens":9639.502,"generate/avg_tokens_non_zero_rewards":11166.766,"generate/avg_tokens_zero_rewards":2380.7079,"generate/max_num_tokens":32049,"generate/std_num_tokens":6990.9528,"loss/avg_final_rewards":0.576,"loss/avg_raw_advantages":0.0291,"loss/avg_raw_advantages_abs":0.1305,"policy/policy_entropy":0.1126,"policy/policy_loss":-0.0184,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0121,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.576,"timing/step":1945.1063,"trainer/epoch":0}
+{"step":43,"async/staleness_mean":0.4375,"generate/avg_num_tokens":8526.0098,"generate/avg_tokens_non_zero_rewards":9153.4397,"generate/avg_tokens_zero_rewards":2460.8542,"generate/max_num_tokens":31657,"generate/std_num_tokens":5366.2312,"loss/avg_final_rewards":0.6858,"loss/avg_raw_advantages":0.0365,"loss/avg_raw_advantages_abs":0.1366,"policy/policy_entropy":0.1384,"policy/policy_loss":-0.0328,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0155,"reward/avg_pass_at_8":0.9821,"reward/avg_raw_reward":0.6858,"timing/step":7503.4743,"trainer/epoch":0}
+{"step":44,"async/staleness_mean":1.0,"generate/avg_num_tokens":10857.1738,"generate/avg_tokens_non_zero_rewards":13542.7188,"generate/avg_tokens_zero_rewards":2800.5391,"generate/max_num_tokens":31842,"generate/std_num_tokens":8448.3655,"loss/avg_final_rewards":0.4057,"loss/avg_raw_advantages":0.0253,"loss/avg_raw_advantages_abs":0.1327,"policy/policy_entropy":0.0992,"policy/policy_loss":-0.0222,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0117,"reward/avg_pass_at_8":0.9531,"reward/avg_raw_reward":0.4057,"timing/step":2178.0809,"trainer/epoch":0}
+{"step":45,"async/staleness_mean":1.9219,"generate/avg_num_tokens":8753.6836,"generate/avg_tokens_non_zero_rewards":11951.7628,"generate/avg_tokens_zero_rewards":2804.1844,"generate/max_num_tokens":31838,"generate/std_num_tokens":8045.577,"loss/avg_final_rewards":0.4379,"loss/avg_raw_advantages":0.0202,"loss/avg_raw_advantages_abs":0.1272,"policy/policy_entropy":0.089,"policy/policy_loss":-0.016,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0108,"reward/avg_pass_at_8":0.9531,"reward/avg_raw_reward":0.4379,"timing/step":1175.6698,"trainer/epoch":0}
+{"step":46,"async/staleness_mean":2.1875,"generate/avg_num_tokens":9020.1895,"generate/avg_tokens_non_zero_rewards":11089.6061,"generate/avg_tokens_zero_rewards":1955.6293,"generate/max_num_tokens":33138,"generate/std_num_tokens":7640.7865,"loss/avg_final_rewards":0.5028,"loss/avg_raw_advantages":0.0222,"loss/avg_raw_advantages_abs":0.1315,"policy/policy_entropy":0.106,"policy/policy_loss":-0.018,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0289,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.5028,"timing/step":3217.8506,"trainer/epoch":0}
+{"step":47,"async/staleness_mean":2.3125,"generate/avg_num_tokens":9114.3848,"generate/avg_tokens_non_zero_rewards":11057.5164,"generate/avg_tokens_zero_rewards":2406.3565,"generate/max_num_tokens":32280,"generate/std_num_tokens":6726.3824,"loss/avg_final_rewards":0.5133,"loss/avg_raw_advantages":0.0356,"loss/avg_raw_advantages_abs":0.1508,"policy/policy_entropy":0.1057,"policy/policy_loss":-0.0267,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0148,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.5133,"timing/step":2750.6137,"trainer/epoch":0}
+{"step":48,"async/staleness_mean":2.4062,"generate/avg_num_tokens":8759.4766,"generate/avg_tokens_non_zero_rewards":12008.6229,"generate/avg_tokens_zero_rewards":1206.2662,"generate/max_num_tokens":31994,"generate/std_num_tokens":7475.912,"loss/avg_final_rewards":0.4376,"loss/avg_raw_advantages":0.02,"loss/avg_raw_advantages_abs":0.13,"policy/policy_entropy":0.0896,"policy/policy_loss":-0.0175,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0294,"reward/avg_pass_at_8":0.9531,"reward/avg_raw_reward":0.4376,"timing/step":2385.7088,"trainer/epoch":0}
+{"step":49,"async/staleness_mean":2.3594,"generate/avg_num_tokens":8316.1094,"generate/avg_tokens_non_zero_rewards":10984.5378,"generate/avg_tokens_zero_rewards":1363.162,"generate/max_num_tokens":31760,"generate/std_num_tokens":6980.733,"loss/avg_final_rewards":0.4956,"loss/avg_raw_advantages":0.0331,"loss/avg_raw_advantages_abs":0.1298,"policy/policy_entropy":0.0933,"policy/policy_loss":-0.0203,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0125,"reward/avg_pass_at_8":0.9375,"reward/avg_raw_reward":0.4956,"timing/step":2394.7512,"trainer/epoch":0}
+{"step":50,"async/staleness_mean":2.1562,"generate/avg_num_tokens":9415.2988,"generate/avg_tokens_non_zero_rewards":10773.6524,"generate/avg_tokens_zero_rewards":694.2754,"generate/max_num_tokens":32046,"generate/std_num_tokens":6691.1476,"loss/avg_final_rewards":0.5997,"loss/avg_raw_advantages":0.0347,"loss/avg_raw_advantages_abs":0.1401,"policy/policy_entropy":0.1122,"policy/policy_loss":-0.034,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0142,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.5997,"timing/step":2754.4871,"trainer/epoch":0}
+{"step":51,"async/staleness_mean":2.625,"generate/avg_num_tokens":7991.6914,"generate/avg_tokens_non_zero_rewards":10300.8103,"generate/avg_tokens_zero_rewards":2033.1958,"generate/max_num_tokens":32118,"generate/std_num_tokens":6981.3409,"loss/avg_final_rewards":0.486,"loss/avg_raw_advantages":0.0258,"loss/avg_raw_advantages_abs":0.1455,"policy/policy_entropy":0.0989,"policy/policy_loss":-0.0285,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0146,"reward/avg_pass_at_8":0.9531,"reward/avg_raw_reward":0.486,"timing/step":1850.0278,"trainer/epoch":0}
+{"step":52,"async/staleness_mean":0.4531,"generate/avg_num_tokens":8983.584,"generate/avg_tokens_non_zero_rewards":9595.1301,"generate/avg_tokens_zero_rewards":2313.4651,"generate/max_num_tokens":31648,"generate/std_num_tokens":5431.2092,"loss/avg_final_rewards":0.6782,"loss/avg_raw_advantages":0.0182,"loss/avg_raw_advantages_abs":0.1253,"policy/policy_entropy":0.1224,"policy/policy_loss":-0.0118,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0141,"reward/avg_pass_at_8":0.9836,"reward/avg_raw_reward":0.6782,"timing/step":7710.4512,"trainer/epoch":0}
+{"step":53,"async/staleness_mean":1.0,"generate/avg_num_tokens":11968.8965,"generate/avg_tokens_non_zero_rewards":14394.2147,"generate/avg_tokens_zero_rewards":4842.1923,"generate/max_num_tokens":32049,"generate/std_num_tokens":8483.5468,"loss/avg_final_rewards":0.4545,"loss/avg_raw_advantages":0.0165,"loss/avg_raw_advantages_abs":0.1415,"policy/policy_entropy":0.0901,"policy/policy_loss":-0.0122,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0123,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.4545,"timing/step":1194.0669,"trainer/epoch":0}
+{"step":54,"async/staleness_mean":1.8906,"generate/avg_num_tokens":11108.5215,"generate/avg_tokens_non_zero_rewards":12862.0496,"generate/avg_tokens_zero_rewards":2774.3371,"generate/max_num_tokens":32232,"generate/std_num_tokens":8304.5944,"loss/avg_final_rewards":0.5139,"loss/avg_raw_advantages":0.0056,"loss/avg_raw_advantages_abs":0.1438,"policy/policy_entropy":0.0946,"policy/policy_loss":-0.0085,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0126,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.5139,"timing/step":1531.9723,"trainer/epoch":0}
+{"step":55,"async/staleness_mean":2.3594,"generate/avg_num_tokens":10867.6074,"generate/avg_tokens_non_zero_rewards":11586.3348,"generate/avg_tokens_zero_rewards":3586.587,"generate/max_num_tokens":31860,"generate/std_num_tokens":6673.593,"loss/avg_final_rewards":0.576,"loss/avg_raw_advantages":0.0091,"loss/avg_raw_advantages_abs":0.1225,"policy/policy_entropy":0.1094,"policy/policy_loss":-0.0041,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0136,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.576,"timing/step":2104.6037,"trainer/epoch":0}
+{"step":56,"async/staleness_mean":2.6562,"generate/avg_num_tokens":10019.8652,"generate/avg_tokens_non_zero_rewards":10413.0448,"generate/avg_tokens_zero_rewards":5731.4651,"generate/max_num_tokens":32047,"generate/std_num_tokens":6491.9299,"loss/avg_final_rewards":0.6383,"loss/avg_raw_advantages":0.0059,"loss/avg_raw_advantages_abs":0.1323,"policy/policy_entropy":0.1111,"policy/policy_loss":-0.0103,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0152,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.6383,"timing/step":2776.3766,"trainer/epoch":0}
+{"step":57,"async/staleness_mean":2.8281,"generate/avg_num_tokens":10692.1504,"generate/avg_tokens_non_zero_rewards":12498.0024,"generate/avg_tokens_zero_rewards":2765.4105,"generate/max_num_tokens":32109,"generate/std_num_tokens":8081.0706,"loss/avg_final_rewards":0.5351,"loss/avg_raw_advantages":0.0017,"loss/avg_raw_advantages_abs":0.1368,"policy/policy_entropy":0.0919,"policy/policy_loss":-0.0086,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0132,"reward/avg_pass_at_8":0.9531,"reward/avg_raw_reward":0.5351,"timing/step":1932.6384,"trainer/epoch":0}
+{"step":58,"async/staleness_mean":2.4844,"generate/avg_num_tokens":10424.6172,"generate/avg_tokens_non_zero_rewards":11960.4939,"generate/avg_tokens_zero_rewards":4325.8447,"generate/max_num_tokens":31812,"generate/std_num_tokens":7610.1572,"loss/avg_final_rewards":0.518,"loss/avg_raw_advantages":0.0066,"loss/avg_raw_advantages_abs":0.1312,"policy/policy_entropy":0.0981,"policy/policy_loss":-0.0111,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0177,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.518,"timing/step":1760.3623,"trainer/epoch":0}
+{"step":59,"async/staleness_mean":2.4688,"generate/avg_num_tokens":10010.4961,"generate/avg_tokens_non_zero_rewards":10718.9843,"generate/avg_tokens_zero_rewards":5222.8333,"generate/max_num_tokens":31864,"generate/std_num_tokens":7115.95,"loss/avg_final_rewards":0.6093,"loss/avg_raw_advantages":0.0099,"loss/avg_raw_advantages_abs":0.1241,"policy/policy_entropy":0.1053,"policy/policy_loss":-0.0027,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0133,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.6093,"timing/step":1933.2122,"trainer/epoch":0}
+{"step":60,"async/staleness_mean":2.6094,"generate/avg_num_tokens":10168.5332,"generate/avg_tokens_non_zero_rewards":11320.7862,"generate/avg_tokens_zero_rewards":1956.4444,"generate/max_num_tokens":32334,"generate/std_num_tokens":6849.4232,"loss/avg_final_rewards":0.6181,"loss/avg_raw_advantages":0.027,"loss/avg_raw_advantages_abs":0.1435,"policy/policy_entropy":0.1025,"policy/policy_loss":-0.0131,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0156,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.6181,"timing/step":2221.5922,"trainer/epoch":0}
+{"step":61,"async/staleness_mean":2.5156,"generate/avg_num_tokens":10184.793,"generate/avg_tokens_non_zero_rewards":11908.068,"generate/avg_tokens_zero_rewards":3084.9,"generate/max_num_tokens":32049,"generate/std_num_tokens":7351.8065,"loss/avg_final_rewards":0.5326,"loss/avg_raw_advantages":0.009,"loss/avg_raw_advantages_abs":0.1271,"policy/policy_entropy":0.0961,"policy/policy_loss":-0.0029,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.014,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.5326,"timing/step":2152.2381,"trainer/epoch":0}
+{"step":62,"async/staleness_mean":2.5,"generate/avg_num_tokens":9331.7812,"generate/avg_tokens_non_zero_rewards":10914.7356,"generate/avg_tokens_zero_rewards":2472.3125,"generate/max_num_tokens":32049,"generate/std_num_tokens":6865.2744,"loss/avg_final_rewards":0.5387,"loss/avg_raw_advantages":0.0108,"loss/avg_raw_advantages_abs":0.1101,"policy/policy_entropy":0.0966,"policy/policy_loss":-0.0087,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0132,"reward/avg_pass_at_8":0.9531,"reward/avg_raw_reward":0.5387,"timing/step":1654.4657,"trainer/epoch":0}
+{"step":63,"async/staleness_mean":2.625,"generate/avg_num_tokens":9486.832,"generate/avg_tokens_non_zero_rewards":10367.2965,"generate/avg_tokens_zero_rewards":2854.0,"generate/max_num_tokens":32121,"generate/std_num_tokens":6102.5569,"loss/avg_final_rewards":0.6796,"loss/avg_raw_advantages":0.02,"loss/avg_raw_advantages_abs":0.1069,"policy/policy_entropy":0.1018,"policy/policy_loss":-0.0147,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0134,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.6796,"timing/step":1965.9876,"trainer/epoch":0}
+{"step":64,"async/staleness_mean":2.5156,"generate/avg_num_tokens":10798.4805,"generate/avg_tokens_non_zero_rewards":12088.3382,"generate/avg_tokens_zero_rewards":5349.4898,"generate/max_num_tokens":31906,"generate/std_num_tokens":7584.6937,"loss/avg_final_rewards":0.5364,"loss/avg_raw_advantages":0.0113,"loss/avg_raw_advantages_abs":0.1162,"policy/policy_entropy":0.0945,"policy/policy_loss":-0.009,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0119,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.5364,"timing/step":1857.1893,"trainer/epoch":0}
+{"step":65,"async/staleness_mean":2.4688,"generate/avg_num_tokens":10813.1543,"generate/avg_tokens_non_zero_rewards":11583.4165,"generate/avg_tokens_zero_rewards":3850.5882,"generate/max_num_tokens":31906,"generate/std_num_tokens":6913.4062,"loss/avg_final_rewards":0.6414,"loss/avg_raw_advantages":0.0123,"loss/avg_raw_advantages_abs":0.1119,"policy/policy_entropy":0.1004,"policy/policy_loss":-0.0049,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.012,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.6414,"timing/step":2337.8249,"trainer/epoch":0}
+{"step":66,"async/staleness_mean":2.6719,"generate/avg_num_tokens":10605.4082,"generate/avg_tokens_non_zero_rewards":11567.5558,"generate/avg_tokens_zero_rewards":2610.8364,"generate/max_num_tokens":31877,"generate/std_num_tokens":6789.7385,"loss/avg_final_rewards":0.5981,"loss/avg_raw_advantages":0.0008,"loss/avg_raw_advantages_abs":0.1207,"policy/policy_entropy":0.1001,"policy/policy_loss":-0.0028,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0129,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.5981,"timing/step":1795.6286,"trainer/epoch":0}
+{"step":67,"async/staleness_mean":2.5312,"generate/avg_num_tokens":10565.9805,"generate/avg_tokens_non_zero_rewards":11555.4614,"generate/avg_tokens_zero_rewards":4519.1528,"generate/max_num_tokens":31830,"generate/std_num_tokens":7442.9398,"loss/avg_final_rewards":0.5891,"loss/avg_raw_advantages":0.003,"loss/avg_raw_advantages_abs":0.1114,"policy/policy_entropy":0.0957,"policy/policy_loss":-0.0034,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0131,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.5891,"timing/step":2330.4669,"trainer/epoch":0}
+{"step":68,"async/staleness_mean":2.625,"generate/avg_num_tokens":9743.6543,"generate/avg_tokens_non_zero_rewards":11561.9899,"generate/avg_tokens_zero_rewards":3395.4298,"generate/max_num_tokens":31921,"generate/std_num_tokens":7782.6672,"loss/avg_final_rewards":0.5301,"loss/avg_raw_advantages":0.0179,"loss/avg_raw_advantages_abs":0.1379,"policy/policy_entropy":0.089,"policy/policy_loss":-0.0099,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0148,"reward/avg_pass_at_8":0.9531,"reward/avg_raw_reward":0.5301,"timing/step":2086.6562,"trainer/epoch":0}
+{"step":69,"async/staleness_mean":2.2969,"generate/avg_num_tokens":11047.3789,"generate/avg_tokens_non_zero_rewards":11709.6925,"generate/avg_tokens_zero_rewards":4494.7021,"generate/max_num_tokens":31892,"generate/std_num_tokens":6973.144,"loss/avg_final_rewards":0.6016,"loss/avg_raw_advantages":0.0066,"loss/avg_raw_advantages_abs":0.1147,"policy/policy_entropy":0.0962,"policy/policy_loss":-0.0042,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0125,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.6016,"timing/step":1763.9431,"trainer/epoch":0}
+{"step":70,"async/staleness_mean":0.8281,"generate/avg_num_tokens":9673.7988,"generate/avg_tokens_non_zero_rewards":9948.0247,"generate/avg_tokens_zero_rewards":4547.8846,"generate/max_num_tokens":32047,"generate/std_num_tokens":5122.4505,"loss/avg_final_rewards":0.7178,"loss/avg_raw_advantages":0.0134,"loss/avg_raw_advantages_abs":0.0889,"policy/policy_entropy":0.1091,"policy/policy_loss":-0.0062,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.013,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.7178,"timing/step":6252.1126,"trainer/epoch":0}
+{"step":71,"async/staleness_mean":0.9844,"generate/avg_num_tokens":12553.4453,"generate/avg_tokens_non_zero_rewards":13870.9911,"generate/avg_tokens_zero_rewards":3330.625,"generate/max_num_tokens":32049,"generate/std_num_tokens":8285.0009,"loss/avg_final_rewards":0.5413,"loss/avg_raw_advantages":0.0144,"loss/avg_raw_advantages_abs":0.1347,"policy/policy_entropy":0.091,"policy/policy_loss":-0.0105,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0135,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.5413,"timing/step":2571.0828,"trainer/epoch":0}
+{"step":72,"async/staleness_mean":1.8125,"generate/avg_num_tokens":12188.6406,"generate/avg_tokens_non_zero_rewards":15205.9711,"generate/avg_tokens_zero_rewards":3502.3864,"generate/max_num_tokens":32041,"generate/std_num_tokens":9010.8414,"loss/avg_final_rewards":0.451,"loss/avg_raw_advantages":0.0119,"loss/avg_raw_advantages_abs":0.1232,"policy/policy_entropy":0.0745,"policy/policy_loss":-0.0091,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0104,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.451,"timing/step":904.4599,"trainer/epoch":0}
+{"step":73,"async/staleness_mean":2.1875,"generate/avg_num_tokens":10409.3262,"generate/avg_tokens_non_zero_rewards":11811.1733,"generate/avg_tokens_zero_rewards":3367.1059,"generate/max_num_tokens":32118,"generate/std_num_tokens":7098.8033,"loss/avg_final_rewards":0.5814,"loss/avg_raw_advantages":0.0013,"loss/avg_raw_advantages_abs":0.1175,"policy/policy_entropy":0.089,"policy/policy_loss":-0.0017,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0153,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.5814,"timing/step":2376.5707,"trainer/epoch":0}
+{"step":74,"async/staleness_mean":2.6406,"generate/avg_num_tokens":10459.8105,"generate/avg_tokens_non_zero_rewards":11643.9531,"generate/avg_tokens_zero_rewards":2170.8125,"generate/max_num_tokens":31867,"generate/std_num_tokens":5955.108,"loss/avg_final_rewards":0.6191,"loss/avg_raw_advantages":0.0084,"loss/avg_raw_advantages_abs":0.1129,"policy/policy_entropy":0.094,"policy/policy_loss":-0.0039,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0141,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.6191,"timing/step":2432.5072,"trainer/epoch":0}
+{"step":75,"async/staleness_mean":2.4531,"generate/avg_num_tokens":10980.2188,"generate/avg_tokens_non_zero_rewards":11777.0306,"generate/avg_tokens_zero_rewards":4359.4364,"generate/max_num_tokens":32716,"generate/std_num_tokens":6644.6176,"loss/avg_final_rewards":0.6147,"loss/avg_raw_advantages":0.0106,"loss/avg_raw_advantages_abs":0.1136,"policy/policy_entropy":0.0935,"policy/policy_loss":-0.0054,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0136,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.6147,"timing/step":2139.2163,"trainer/epoch":0}
+{"step":76,"async/staleness_mean":1.1406,"generate/avg_num_tokens":9838.6426,"generate/avg_tokens_non_zero_rewards":10797.2354,"generate/avg_tokens_zero_rewards":3360.8788,"generate/max_num_tokens":31829,"generate/std_num_tokens":5633.872,"loss/avg_final_rewards":0.6303,"loss/avg_raw_advantages":0.0354,"loss/avg_raw_advantages_abs":0.1315,"policy/policy_entropy":0.0946,"policy/policy_loss":-0.0305,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0225,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.6303,"timing/step":7783.8267,"trainer/epoch":0}
diff --git a/viewer/build/inputs/marin/runs/marin-a3-llm-verifier-freelancer/run.json b/viewer/build/inputs/marin/runs/marin-a3-llm-verifier-freelancer/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..77bcbbf447df4eb8fde00b04f708f15d218b4b99
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-a3-llm-verifier-freelancer/run.json
@@ -0,0 +1,27 @@
+{
+ "id": "marin-a3-llm-verifier-freelancer",
+ "title": "A3 RLOO on llm-verifier-freelancer (Qwen3-8B agent)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/laion/a3-rl-DCAgent_llm-verifier-freelancer-70-8B/tree/main/training_logs",
+ "license": "unknown",
+ "model": "laion/a3-rl-DCAgent_llm-verifier-freelancer-70-8B",
+ "base_model": "laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink",
+ "method": "RLOO-N (SkyRL, binary verifier reward)",
+ "dataset": "DCAgent/llm-verifier-freelancer",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-05-25T07:12:34Z",
+ "attempts": 0,
+ "note": "Marin A3 sweep (issue #6187): one RLOO-N run per training dataset from the same Qwen3-8B-derived SFT agent, here DCAgent/llm-verifier-freelancer; the highest A3 reward (0.718 at the EMA-best step 70, per the issue). Our copy has every logged step of the final lineage (11 resumed job segments, 12 superseded rows dropped). The issue concluded this binary-reward setup was uninformative about dataset utility.",
+ "metrics_map": {
+  "reward": "reward/avg_raw_reward",
+  "loss": "policy/policy_loss",
+  "entropy": "policy/policy_entropy",
+  "grad_norm": "policy/raw_grad_norm",
+  "response_length": "generate/avg_num_tokens"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-a3-nemotron-agent-calendar/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-a3-nemotron-agent-calendar/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..d72f5eead29ab7ec38ea7cc4b1fb0024660cf461
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-a3-nemotron-agent-calendar/metrics.jsonl
@@ -0,0 +1,80 @@
+{"step":1,"async/staleness_mean":0.0,"generate/avg_num_tokens":1431.8281,"generate/avg_tokens_non_zero_rewards":2889.6108,"generate/avg_tokens_zero_rewards":726.1768,"generate/max_num_tokens":11273,"generate/std_num_tokens":1901.8064,"loss/avg_final_rewards":0.3262,"loss/avg_raw_advantages":0.0775,"loss/avg_raw_advantages_abs":0.3587,"policy/policy_entropy":0.0623,"policy/policy_loss":-0.0593,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0237,"reward/avg_pass_at_8":0.8281,"reward/avg_raw_reward":0.3262,"timing/step":16272.8114,"trainer/epoch":0}
+{"step":2,"async/staleness_mean":0.9844,"generate/avg_num_tokens":614.2637,"generate/avg_tokens_non_zero_rewards":2778.7671,"generate/avg_tokens_zero_rewards":254.3349,"generate/max_num_tokens":14488,"generate/std_num_tokens":1513.2025,"loss/avg_final_rewards":0.1426,"loss/avg_raw_advantages":0.2496,"loss/avg_raw_advantages_abs":0.3492,"policy/policy_entropy":0.0271,"policy/policy_loss":-0.0559,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.028,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.1426,"timing/step":12716.0999,"trainer/epoch":0}
+{"step":3,"async/staleness_mean":0.2969,"generate/avg_num_tokens":2085.2129,"generate/avg_tokens_non_zero_rewards":2333.9798,"generate/avg_tokens_zero_rewards":1235.9741,"generate/max_num_tokens":11796,"generate/std_num_tokens":1504.9847,"loss/avg_final_rewards":0.7734,"loss/avg_raw_advantages":0.0113,"loss/avg_raw_advantages_abs":0.1682,"policy/policy_entropy":0.1068,"policy/policy_loss":-0.0151,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0261,"reward/avg_pass_at_8":0.9194,"reward/avg_raw_reward":0.7734,"timing/step":1385.6931,"trainer/epoch":0}
+{"step":4,"async/staleness_mean":0.9531,"generate/avg_num_tokens":2736.7129,"generate/avg_tokens_non_zero_rewards":2478.469,"generate/avg_tokens_zero_rewards":3915.6522,"generate/max_num_tokens":16638,"generate/std_num_tokens":1706.5579,"loss/avg_final_rewards":0.8203,"loss/avg_raw_advantages":-0.0196,"loss/avg_raw_advantages_abs":0.2291,"policy/policy_entropy":0.1264,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0289,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.8203,"timing/step":421.796,"trainer/epoch":0}
+{"step":5,"async/staleness_mean":1.6094,"generate/avg_num_tokens":2976.0801,"generate/avg_tokens_non_zero_rewards":2705.5583,"generate/avg_tokens_zero_rewards":3616.7895,"generate/max_num_tokens":14808,"generate/std_num_tokens":1868.1502,"loss/avg_final_rewards":0.7031,"loss/avg_raw_advantages":-0.0001,"loss/avg_raw_advantages_abs":0.2735,"policy/policy_entropy":0.1246,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.028,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.7031,"timing/step":454.4222,"trainer/epoch":0}
+{"step":6,"async/staleness_mean":2.1562,"generate/avg_num_tokens":2689.2773,"generate/avg_tokens_non_zero_rewards":2421.3426,"generate/avg_tokens_zero_rewards":3614.2348,"generate/max_num_tokens":12730,"generate/std_num_tokens":1537.6723,"loss/avg_final_rewards":0.7754,"loss/avg_raw_advantages":-0.0164,"loss/avg_raw_advantages_abs":0.2754,"policy/policy_entropy":0.1243,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0306,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.7754,"timing/step":356.6975,"trainer/epoch":0}
+{"step":7,"async/staleness_mean":2.7656,"generate/avg_num_tokens":3006.9551,"generate/avg_tokens_non_zero_rewards":2735.0862,"generate/avg_tokens_zero_rewards":3814.1318,"generate/max_num_tokens":15163,"generate/std_num_tokens":2099.7744,"loss/avg_final_rewards":0.748,"loss/avg_raw_advantages":-0.0351,"loss/avg_raw_advantages_abs":0.3179,"policy/policy_entropy":0.1262,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0334,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.748,"timing/step":453.3526,"trainer/epoch":0}
+{"step":8,"async/staleness_mean":3.0312,"generate/avg_num_tokens":3005.291,"generate/avg_tokens_non_zero_rewards":2802.7748,"generate/avg_tokens_zero_rewards":3762.8519,"generate/max_num_tokens":28052,"generate/std_num_tokens":2190.8773,"loss/avg_final_rewards":0.7891,"loss/avg_raw_advantages":-0.0292,"loss/avg_raw_advantages_abs":0.2875,"policy/policy_entropy":0.1201,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0299,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.7891,"timing/step":369.1187,"trainer/epoch":0}
+{"step":9,"async/staleness_mean":3.2656,"generate/avg_num_tokens":2968.4883,"generate/avg_tokens_non_zero_rewards":2685.375,"generate/avg_tokens_zero_rewards":3893.325,"generate/max_num_tokens":14971,"generate/std_num_tokens":1731.3402,"loss/avg_final_rewards":0.7656,"loss/avg_raw_advantages":-0.0382,"loss/avg_raw_advantages_abs":0.278,"policy/policy_entropy":0.1161,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0284,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.7656,"timing/step":289.7455,"trainer/epoch":0}
+{"step":10,"async/staleness_mean":3.7031,"generate/avg_num_tokens":3184.5234,"generate/avg_tokens_non_zero_rewards":2926.0157,"generate/avg_tokens_zero_rewards":3936.3664,"generate/max_num_tokens":23313,"generate/std_num_tokens":2232.7037,"loss/avg_final_rewards":0.7441,"loss/avg_raw_advantages":-0.0322,"loss/avg_raw_advantages_abs":0.27,"policy/policy_entropy":0.1188,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0296,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.7441,"timing/step":322.2241,"trainer/epoch":0}
+{"step":11,"async/staleness_mean":4.0625,"generate/avg_num_tokens":3158.5684,"generate/avg_tokens_non_zero_rewards":2915.6842,"generate/avg_tokens_zero_rewards":4016.1858,"generate/max_num_tokens":18903,"generate/std_num_tokens":2125.1072,"loss/avg_final_rewards":0.7793,"loss/avg_raw_advantages":-0.0314,"loss/avg_raw_advantages_abs":0.3072,"policy/policy_entropy":0.1181,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0303,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.7793,"timing/step":251.7501,"trainer/epoch":0}
+{"step":12,"async/staleness_mean":3.7344,"generate/avg_num_tokens":2897.3184,"generate/avg_tokens_non_zero_rewards":2694.0557,"generate/avg_tokens_zero_rewards":3583.547,"generate/max_num_tokens":16805,"generate/std_num_tokens":1754.4908,"loss/avg_final_rewards":0.7715,"loss/avg_raw_advantages":-0.0268,"loss/avg_raw_advantages_abs":0.2844,"policy/policy_entropy":0.1199,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0312,"reward/avg_pass_at_8":0.9688,"reward/avg_raw_reward":0.7715,"timing/step":293.1536,"trainer/epoch":0}
+{"step":13,"async/staleness_mean":4.0,"generate/avg_num_tokens":2865.752,"generate/avg_tokens_non_zero_rewards":2647.5686,"generate/avg_tokens_zero_rewards":3653.964,"generate/max_num_tokens":17502,"generate/std_num_tokens":1861.9091,"loss/avg_final_rewards":0.7832,"loss/avg_raw_advantages":-0.0135,"loss/avg_raw_advantages_abs":0.2793,"policy/policy_entropy":0.1162,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0317,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.7832,"timing/step":295.1542,"trainer/epoch":0}
+{"step":14,"async/staleness_mean":4.5312,"generate/avg_num_tokens":3130.1191,"generate/avg_tokens_non_zero_rewards":2818.9857,"generate/avg_tokens_zero_rewards":4531.8925,"generate/max_num_tokens":25853,"generate/std_num_tokens":2346.123,"loss/avg_final_rewards":0.8184,"loss/avg_raw_advantages":-0.04,"loss/avg_raw_advantages_abs":0.2752,"policy/policy_entropy":0.1144,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0286,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.8184,"timing/step":236.553,"trainer/epoch":0}
+{"step":15,"async/staleness_mean":4.5312,"generate/avg_num_tokens":3037.168,"generate/avg_tokens_non_zero_rewards":2717.8701,"generate/avg_tokens_zero_rewards":4289.7981,"generate/max_num_tokens":23975,"generate/std_num_tokens":2117.6372,"loss/avg_final_rewards":0.7969,"loss/avg_raw_advantages":-0.0415,"loss/avg_raw_advantages_abs":0.3254,"policy/policy_entropy":0.1174,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0311,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.7969,"timing/step":226.9706,"trainer/epoch":0}
+{"step":16,"async/staleness_mean":3.8906,"generate/avg_num_tokens":2836.6016,"generate/avg_tokens_non_zero_rewards":2672.5718,"generate/avg_tokens_zero_rewards":3823.0274,"generate/max_num_tokens":15261,"generate/std_num_tokens":1599.6131,"loss/avg_final_rewards":0.8574,"loss/avg_raw_advantages":-0.0401,"loss/avg_raw_advantages_abs":0.2081,"policy/policy_entropy":0.1147,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0239,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.8574,"timing/step":201.3474,"trainer/epoch":0}
+{"step":17,"async/staleness_mean":4.0625,"generate/avg_num_tokens":2856.3184,"generate/avg_tokens_non_zero_rewards":2694.0571,"generate/avg_tokens_zero_rewards":3816.7297,"generate/max_num_tokens":16407,"generate/std_num_tokens":1656.0729,"loss/avg_final_rewards":0.8555,"loss/avg_raw_advantages":-0.0268,"loss/avg_raw_advantages_abs":0.2471,"policy/policy_entropy":0.1143,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0291,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.8555,"timing/step":210.9901,"trainer/epoch":0}
+{"step":18,"async/staleness_mean":4.6562,"generate/avg_num_tokens":3046.6074,"generate/avg_tokens_non_zero_rewards":2938.9504,"generate/avg_tokens_zero_rewards":3444.6422,"generate/max_num_tokens":19486,"generate/std_num_tokens":1865.0103,"loss/avg_final_rewards":0.7871,"loss/avg_raw_advantages":-0.0125,"loss/avg_raw_advantages_abs":0.2417,"policy/policy_entropy":0.1117,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0314,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.7871,"timing/step":215.0986,"trainer/epoch":0}
+{"step":19,"async/staleness_mean":4.5156,"generate/avg_num_tokens":2960.2129,"generate/avg_tokens_non_zero_rewards":2813.3377,"generate/avg_tokens_zero_rewards":4232.2075,"generate/max_num_tokens":16390,"generate/std_num_tokens":1803.631,"loss/avg_final_rewards":0.8965,"loss/avg_raw_advantages":-0.0253,"loss/avg_raw_advantages_abs":0.2026,"policy/policy_entropy":0.1102,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0229,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.8965,"timing/step":211.8662,"trainer/epoch":0}
+{"step":20,"async/staleness_mean":4.25,"generate/avg_num_tokens":2770.2656,"generate/avg_tokens_non_zero_rewards":2650.6307,"generate/avg_tokens_zero_rewards":3900.6939,"generate/max_num_tokens":17942,"generate/std_num_tokens":1758.7398,"loss/avg_final_rewards":0.9043,"loss/avg_raw_advantages":-0.0214,"loss/avg_raw_advantages_abs":0.1757,"policy/policy_entropy":0.1095,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0243,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9043,"timing/step":202.3078,"trainer/epoch":0}
+{"step":21,"async/staleness_mean":4.5312,"generate/avg_num_tokens":2691.3633,"generate/avg_tokens_non_zero_rewards":2551.3468,"generate/avg_tokens_zero_rewards":3605.5882,"generate/max_num_tokens":10583,"generate/std_num_tokens":1312.5686,"loss/avg_final_rewards":0.8672,"loss/avg_raw_advantages":-0.0232,"loss/avg_raw_advantages_abs":0.1864,"policy/policy_entropy":0.1084,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0254,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.8672,"timing/step":188.4747,"trainer/epoch":0}
+{"step":22,"async/staleness_mean":4.5781,"generate/avg_num_tokens":2696.9902,"generate/avg_tokens_non_zero_rewards":2578.5987,"generate/avg_tokens_zero_rewards":3572.3115,"generate/max_num_tokens":12061,"generate/std_num_tokens":1342.3068,"loss/avg_final_rewards":0.8809,"loss/avg_raw_advantages":-0.0192,"loss/avg_raw_advantages_abs":0.1849,"policy/policy_entropy":0.1114,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0262,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.8809,"timing/step":190.1527,"trainer/epoch":0}
+{"step":23,"async/staleness_mean":4.2969,"generate/avg_num_tokens":2664.4746,"generate/avg_tokens_non_zero_rewards":2559.6116,"generate/avg_tokens_zero_rewards":3398.5156,"generate/max_num_tokens":9214,"generate/std_num_tokens":1283.4053,"loss/avg_final_rewards":0.875,"loss/avg_raw_advantages":-0.0141,"loss/avg_raw_advantages_abs":0.1952,"policy/policy_entropy":0.1107,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0278,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.875,"timing/step":182.7698,"trainer/epoch":0}
+{"step":24,"async/staleness_mean":4.9062,"generate/avg_num_tokens":2722.1816,"generate/avg_tokens_non_zero_rewards":2625.0022,"generate/avg_tokens_zero_rewards":3640.4286,"generate/max_num_tokens":13495,"generate/std_num_tokens":1452.6242,"loss/avg_final_rewards":0.9043,"loss/avg_raw_advantages":-0.019,"loss/avg_raw_advantages_abs":0.1909,"policy/policy_entropy":0.1116,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0271,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9043,"timing/step":181.0263,"trainer/epoch":0}
+{"step":25,"async/staleness_mean":4.129,"generate/avg_num_tokens":2633.0,"generate/avg_tokens_non_zero_rewards":2519.7539,"generate/avg_tokens_zero_rewards":3666.0816,"generate/max_num_tokens":13173,"generate/std_num_tokens":1296.4858,"loss/avg_final_rewards":0.9012,"loss/avg_raw_advantages":-0.0241,"loss/avg_raw_advantages_abs":0.1707,"policy/policy_entropy":0.1071,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9012,"timing/step":185.2818,"trainer/epoch":0}
+{"step":26,"async/staleness_mean":5.1406,"generate/avg_num_tokens":3091.373,"generate/avg_tokens_non_zero_rewards":2982.3311,"generate/avg_tokens_zero_rewards":3979.2857,"generate/max_num_tokens":14234,"generate/std_num_tokens":1712.4445,"loss/avg_final_rewards":0.8906,"loss/avg_raw_advantages":-0.0212,"loss/avg_raw_advantages_abs":0.2161,"policy/policy_entropy":0.1093,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.037,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.8906,"timing/step":209.3612,"trainer/epoch":0}
+{"step":27,"async/staleness_mean":4.3281,"generate/avg_num_tokens":2723.832,"generate/avg_tokens_non_zero_rewards":2614.4815,"generate/avg_tokens_zero_rewards":3670.8491,"generate/max_num_tokens":13130,"generate/std_num_tokens":1463.1991,"loss/avg_final_rewards":0.8965,"loss/avg_raw_advantages":-0.021,"loss/avg_raw_advantages_abs":0.1762,"policy/policy_entropy":0.1093,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0255,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.8965,"timing/step":190.8597,"trainer/epoch":0}
+{"step":28,"async/staleness_mean":4.9365,"generate/avg_num_tokens":2846.3234,"generate/avg_tokens_non_zero_rewards":2815.3597,"generate/avg_tokens_zero_rewards":3237.1351,"generate/max_num_tokens":12936,"generate/std_num_tokens":1420.929,"loss/avg_final_rewards":0.9266,"loss/avg_raw_advantages":-0.0085,"loss/avg_raw_advantages_abs":0.105,"policy/policy_entropy":0.1077,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9266,"timing/step":193.0694,"trainer/epoch":0}
+{"step":29,"async/staleness_mean":4.7619,"generate/avg_num_tokens":2635.8472,"generate/avg_tokens_non_zero_rewards":2533.13,"generate/avg_tokens_zero_rewards":3568.52,"generate/max_num_tokens":18514,"generate/std_num_tokens":1375.3518,"loss/avg_final_rewards":0.9008,"loss/avg_raw_advantages":-0.0207,"loss/avg_raw_advantages_abs":0.1426,"policy/policy_entropy":0.1085,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9008,"timing/step":176.5434,"trainer/epoch":0}
+{"step":30,"async/staleness_mean":5.254,"generate/avg_num_tokens":2849.5853,"generate/avg_tokens_non_zero_rewards":2753.7478,"generate/avg_tokens_zero_rewards":3760.0417,"generate/max_num_tokens":11625,"generate/std_num_tokens":1346.0454,"loss/avg_final_rewards":0.9048,"loss/avg_raw_advantages":-0.0177,"loss/avg_raw_advantages_abs":0.1905,"policy/policy_entropy":0.1064,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9048,"timing/step":192.0073,"trainer/epoch":0}
+{"step":31,"async/staleness_mean":4.8254,"generate/avg_num_tokens":2590.8393,"generate/avg_tokens_non_zero_rewards":2545.0174,"generate/avg_tokens_zero_rewards":3058.2222,"generate/max_num_tokens":10878,"generate/std_num_tokens":1164.3999,"loss/avg_final_rewards":0.9107,"loss/avg_raw_advantages":-0.0107,"loss/avg_raw_advantages_abs":0.141,"policy/policy_entropy":0.1101,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9107,"timing/step":173.492,"trainer/epoch":0}
+{"step":32,"async/staleness_mean":4.8254,"generate/avg_num_tokens":2799.3294,"generate/avg_tokens_non_zero_rewards":2676.5465,"generate/avg_tokens_zero_rewards":3866.5962,"generate/max_num_tokens":11311,"generate/std_num_tokens":1269.2805,"loss/avg_final_rewards":0.8968,"loss/avg_raw_advantages":-0.0271,"loss/avg_raw_advantages_abs":0.2102,"policy/policy_entropy":0.1086,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.8968,"timing/step":198.3175,"trainer/epoch":0}
+{"step":33,"async/staleness_mean":4.2344,"generate/avg_num_tokens":2602.0664,"generate/avg_tokens_non_zero_rewards":2530.3838,"generate/avg_tokens_zero_rewards":3753.7667,"generate/max_num_tokens":11238,"generate/std_num_tokens":1306.177,"loss/avg_final_rewards":0.9414,"loss/avg_raw_advantages":-0.0158,"loss/avg_raw_advantages_abs":0.1187,"policy/policy_entropy":0.1119,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0685,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9414,"timing/step":177.8609,"trainer/epoch":0}
+{"step":34,"async/staleness_mean":4.2698,"generate/avg_num_tokens":2713.0813,"generate/avg_tokens_non_zero_rewards":2644.9394,"generate/avg_tokens_zero_rewards":3462.6429,"generate/max_num_tokens":11070,"generate/std_num_tokens":1278.3998,"loss/avg_final_rewards":0.9167,"loss/avg_raw_advantages":-0.0117,"loss/avg_raw_advantages_abs":0.1655,"policy/policy_entropy":0.1095,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9167,"timing/step":187.63,"trainer/epoch":0}
+{"step":35,"async/staleness_mean":5.0161,"generate/avg_num_tokens":2792.2036,"generate/avg_tokens_non_zero_rewards":2721.2575,"generate/avg_tokens_zero_rewards":3894.2333,"generate/max_num_tokens":15150,"generate/std_num_tokens":1595.4949,"loss/avg_final_rewards":0.9395,"loss/avg_raw_advantages":-0.0037,"loss/avg_raw_advantages_abs":0.1416,"policy/policy_entropy":0.111,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9395,"timing/step":192.0157,"trainer/epoch":0}
+{"step":36,"async/staleness_mean":4.5469,"generate/avg_num_tokens":2547.2129,"generate/avg_tokens_non_zero_rewards":2503.2521,"generate/avg_tokens_zero_rewards":3206.625,"generate/max_num_tokens":17277,"generate/std_num_tokens":1415.5193,"loss/avg_final_rewards":0.9375,"loss/avg_raw_advantages":-0.01,"loss/avg_raw_advantages_abs":0.1143,"policy/policy_entropy":0.1088,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.043,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9375,"timing/step":190.8551,"trainer/epoch":0}
+{"step":37,"async/staleness_mean":5.6333,"generate/avg_num_tokens":2878.9,"generate/avg_tokens_non_zero_rewards":2834.3428,"generate/avg_tokens_zero_rewards":3806.5,"generate/max_num_tokens":14504,"generate/std_num_tokens":1430.6157,"loss/avg_final_rewards":0.9542,"loss/avg_raw_advantages":-0.0079,"loss/avg_raw_advantages_abs":0.0894,"policy/policy_entropy":0.107,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9542,"timing/step":179.0071,"trainer/epoch":0}
+{"step":38,"async/staleness_mean":5.2131,"generate/avg_num_tokens":2764.8115,"generate/avg_tokens_non_zero_rewards":2712.4091,"generate/avg_tokens_zero_rewards":3245.1667,"generate/max_num_tokens":9187,"generate/std_num_tokens":1240.2673,"loss/avg_final_rewards":0.9016,"loss/avg_raw_advantages":-0.0064,"loss/avg_raw_advantages_abs":0.1739,"policy/policy_entropy":0.11,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9016,"timing/step":174.8333,"trainer/epoch":0}
+{"step":39,"async/staleness_mean":5.1875,"generate/avg_num_tokens":2784.2344,"generate/avg_tokens_non_zero_rewards":2724.0524,"generate/avg_tokens_zero_rewards":3604.4286,"generate/max_num_tokens":11538,"generate/std_num_tokens":1391.8281,"loss/avg_final_rewards":0.9316,"loss/avg_raw_advantages":-0.0165,"loss/avg_raw_advantages_abs":0.1368,"policy/policy_entropy":0.1105,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0402,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9316,"timing/step":193.34,"trainer/epoch":0}
+{"step":40,"async/staleness_mean":5.4603,"generate/avg_num_tokens":2781.9107,"generate/avg_tokens_non_zero_rewards":2664.9104,"generate/avg_tokens_zero_rewards":4349.7143,"generate/max_num_tokens":23281,"generate/std_num_tokens":1790.8724,"loss/avg_final_rewards":0.9306,"loss/avg_raw_advantages":-0.0269,"loss/avg_raw_advantages_abs":0.1582,"policy/policy_entropy":0.1096,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9306,"timing/step":190.5524,"trainer/epoch":0}
+{"step":41,"async/staleness_mean":4.8906,"generate/avg_num_tokens":2870.9629,"generate/avg_tokens_non_zero_rewards":2837.7256,"generate/avg_tokens_zero_rewards":3688.6,"generate/max_num_tokens":19338,"generate/std_num_tokens":1423.2774,"loss/avg_final_rewards":0.9609,"loss/avg_raw_advantages":-0.0051,"loss/avg_raw_advantages_abs":0.0823,"policy/policy_entropy":0.1056,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0329,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9609,"timing/step":189.0223,"trainer/epoch":0}
+{"step":42,"async/staleness_mean":5.3492,"generate/avg_num_tokens":2922.2956,"generate/avg_tokens_non_zero_rewards":2855.1073,"generate/avg_tokens_zero_rewards":3746.2368,"generate/max_num_tokens":12895,"generate/std_num_tokens":1337.5946,"loss/avg_final_rewards":0.9246,"loss/avg_raw_advantages":-0.0155,"loss/avg_raw_advantages_abs":0.1321,"policy/policy_entropy":0.1098,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9246,"timing/step":248.2852,"trainer/epoch":0}
+{"step":43,"async/staleness_mean":4.8548,"generate/avg_num_tokens":2856.1794,"generate/avg_tokens_non_zero_rewards":2756.965,"generate/avg_tokens_zero_rewards":4018.7692,"generate/max_num_tokens":10806,"generate/std_num_tokens":1469.6077,"loss/avg_final_rewards":0.9214,"loss/avg_raw_advantages":-0.0233,"loss/avg_raw_advantages_abs":0.1463,"policy/policy_entropy":0.1079,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9214,"timing/step":209.3624,"trainer/epoch":0}
+{"step":44,"async/staleness_mean":4.0476,"generate/avg_num_tokens":2714.9643,"generate/avg_tokens_non_zero_rewards":2676.3822,"generate/avg_tokens_zero_rewards":3648.65,"generate/max_num_tokens":13880,"generate/std_num_tokens":1304.622,"loss/avg_final_rewards":0.9603,"loss/avg_raw_advantages":-0.0094,"loss/avg_raw_advantages_abs":0.086,"policy/policy_entropy":0.1103,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9603,"timing/step":271.8882,"trainer/epoch":0}
+{"step":45,"async/staleness_mean":4.381,"generate/avg_num_tokens":2944.752,"generate/avg_tokens_non_zero_rewards":2866.9834,"generate/avg_tokens_zero_rewards":4648.5909,"generate/max_num_tokens":16462,"generate/std_num_tokens":1309.1103,"loss/avg_final_rewards":0.9563,"loss/avg_raw_advantages":-0.0171,"loss/avg_raw_advantages_abs":0.1029,"policy/policy_entropy":0.1059,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9563,"timing/step":280.8006,"trainer/epoch":0}
+{"step":46,"async/staleness_mean":4.5484,"generate/avg_num_tokens":2756.6694,"generate/avg_tokens_non_zero_rewards":2692.0579,"generate/avg_tokens_zero_rewards":3760.3,"generate/max_num_tokens":12071,"generate/std_num_tokens":1244.5635,"loss/avg_final_rewards":0.9395,"loss/avg_raw_advantages":-0.0117,"loss/avg_raw_advantages_abs":0.1218,"policy/policy_entropy":0.1081,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9395,"timing/step":222.0341,"trainer/epoch":0}
+{"step":47,"async/staleness_mean":4.3651,"generate/avg_num_tokens":2945.1944,"generate/avg_tokens_non_zero_rewards":2893.2955,"generate/avg_tokens_zero_rewards":3600.2432,"generate/max_num_tokens":12644,"generate/std_num_tokens":1448.864,"loss/avg_final_rewards":0.9266,"loss/avg_raw_advantages":-0.0111,"loss/avg_raw_advantages_abs":0.0915,"policy/policy_entropy":0.1063,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":0.9841,"reward/avg_raw_reward":0.9266,"timing/step":283.4806,"trainer/epoch":0}
+{"step":48,"async/staleness_mean":4.8594,"generate/avg_num_tokens":3077.9453,"generate/avg_tokens_non_zero_rewards":3027.75,"generate/avg_tokens_zero_rewards":3830.875,"generate/max_num_tokens":14566,"generate/std_num_tokens":1617.056,"loss/avg_final_rewards":0.9375,"loss/avg_raw_advantages":-0.0134,"loss/avg_raw_advantages_abs":0.1268,"policy/policy_entropy":0.1068,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0641,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9375,"timing/step":354.9404,"trainer/epoch":0}
+{"step":49,"async/staleness_mean":3.7188,"generate/avg_num_tokens":2821.5469,"generate/avg_tokens_non_zero_rewards":2779.9917,"generate/avg_tokens_zero_rewards":3489.2,"generate/max_num_tokens":24244,"generate/std_num_tokens":1617.4158,"loss/avg_final_rewards":0.9414,"loss/avg_raw_advantages":-0.0114,"loss/avg_raw_advantages_abs":0.1108,"policy/policy_entropy":0.1077,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0233,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9414,"timing/step":197.8306,"trainer/epoch":0}
+{"step":50,"async/staleness_mean":4.4286,"generate/avg_num_tokens":3010.8155,"generate/avg_tokens_non_zero_rewards":2991.4758,"generate/avg_tokens_zero_rewards":3327.5862,"generate/max_num_tokens":18278,"generate/std_num_tokens":1543.572,"loss/avg_final_rewards":0.9425,"loss/avg_raw_advantages":-0.0056,"loss/avg_raw_advantages_abs":0.1075,"policy/policy_entropy":0.1065,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9425,"timing/step":256.6199,"trainer/epoch":0}
+{"step":51,"async/staleness_mean":5.4754,"generate/avg_num_tokens":3193.7377,"generate/avg_tokens_non_zero_rewards":3157.676,"generate/avg_tokens_zero_rewards":3861.6,"generate/max_num_tokens":9998,"generate/std_num_tokens":1336.5231,"loss/avg_final_rewards":0.9488,"loss/avg_raw_advantages":-0.0148,"loss/avg_raw_advantages_abs":0.0983,"policy/policy_entropy":0.1143,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9488,"timing/step":469.5261,"trainer/epoch":0}
+{"step":52,"async/staleness_mean":7.3492,"generate/avg_num_tokens":3425.1369,"generate/avg_tokens_non_zero_rewards":3476.6468,"generate/avg_tokens_zero_rewards":2967.6078,"generate/max_num_tokens":23285,"generate/std_num_tokens":1951.9608,"loss/avg_final_rewards":0.8988,"loss/avg_raw_advantages":-0.0139,"loss/avg_raw_advantages_abs":0.1411,"policy/policy_entropy":0.1084,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.8988,"timing/step":1611.2371,"trainer/epoch":0}
+{"step":53,"async/staleness_mean":0.0,"generate/avg_num_tokens":2381.2148,"generate/avg_tokens_non_zero_rewards":2366.4783,"generate/avg_tokens_zero_rewards":3624.0,"generate/max_num_tokens":6838,"generate/std_num_tokens":947.8529,"loss/avg_final_rewards":0.9883,"loss/avg_raw_advantages":-0.0053,"loss/avg_raw_advantages_abs":0.0295,"policy/policy_entropy":0.1075,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0519,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9883,"timing/step":1581.4156,"trainer/epoch":1}
+{"step":54,"async/staleness_mean":0.875,"generate/avg_num_tokens":2330.7402,"generate/avg_tokens_non_zero_rewards":2324.7067,"generate/avg_tokens_zero_rewards":3097.0,"generate/max_num_tokens":9577,"generate/std_num_tokens":969.3405,"loss/avg_final_rewards":0.9922,"loss/avg_raw_advantages":-0.0016,"loss/avg_raw_advantages_abs":0.0191,"policy/policy_entropy":0.1062,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.009,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9922,"timing/step":729.4275,"trainer/epoch":1}
+{"step":55,"async/staleness_mean":1.6562,"generate/avg_num_tokens":2704.9648,"generate/avg_tokens_non_zero_rewards":2697.7662,"generate/avg_tokens_zero_rewards":3926.3333,"generate/max_num_tokens":12609,"generate/std_num_tokens":1248.1393,"loss/avg_final_rewards":0.9941,"loss/avg_raw_advantages":-0.0017,"loss/avg_raw_advantages_abs":0.0153,"policy/policy_entropy":0.1068,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.009,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9941,"timing/step":684.5591,"trainer/epoch":1}
+{"step":56,"async/staleness_mean":1.9844,"generate/avg_num_tokens":2774.0977,"generate/avg_tokens_non_zero_rewards":2748.4112,"generate/avg_tokens_zero_rewards":3944.0,"generate/max_num_tokens":11344,"generate/std_num_tokens":1423.8899,"loss/avg_final_rewards":0.9785,"loss/avg_raw_advantages":-0.0058,"loss/avg_raw_advantages_abs":0.0413,"policy/policy_entropy":0.1071,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0109,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9785,"timing/step":839.3294,"trainer/epoch":1}
+{"step":57,"async/staleness_mean":2.5938,"generate/avg_num_tokens":2707.8516,"generate/avg_tokens_non_zero_rewards":2783.6818,"generate/avg_tokens_zero_rewards":1397.0714,"generate/max_num_tokens":11134,"generate/std_num_tokens":1335.8597,"loss/avg_final_rewards":0.9453,"loss/avg_raw_advantages":-0.0053,"loss/avg_raw_advantages_abs":0.0501,"policy/policy_entropy":0.1042,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0173,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9453,"timing/step":861.4917,"trainer/epoch":1}
+{"step":58,"async/staleness_mean":3.25,"generate/avg_num_tokens":2563.6445,"generate/avg_tokens_non_zero_rewards":2843.4382,"generate/avg_tokens_zero_rewards":705.3134,"generate/max_num_tokens":9047,"generate/std_num_tokens":1457.9575,"loss/avg_final_rewards":0.8691,"loss/avg_raw_advantages":0.0028,"loss/avg_raw_advantages_abs":0.0628,"policy/policy_entropy":0.0988,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0205,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.8691,"timing/step":639.2276,"trainer/epoch":1}
+{"step":59,"async/staleness_mean":3.1719,"generate/avg_num_tokens":2639.1445,"generate/avg_tokens_non_zero_rewards":2656.652,"generate/avg_tokens_zero_rewards":2400.5429,"generate/max_num_tokens":30113,"generate/std_num_tokens":2147.6442,"loss/avg_final_rewards":0.9316,"loss/avg_raw_advantages":-0.0399,"loss/avg_raw_advantages_abs":0.0778,"policy/policy_entropy":0.1018,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0169,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9316,"timing/step":624.4459,"trainer/epoch":1}
+{"step":60,"async/staleness_mean":3.3281,"generate/avg_num_tokens":2546.6992,"generate/avg_tokens_non_zero_rewards":2721.448,"generate/avg_tokens_zero_rewards":539.2195,"generate/max_num_tokens":8830,"generate/std_num_tokens":1398.6611,"loss/avg_final_rewards":0.9199,"loss/avg_raw_advantages":0.0061,"loss/avg_raw_advantages_abs":0.0363,"policy/policy_entropy":0.1022,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0217,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9199,"timing/step":651.3771,"trainer/epoch":1}
+{"step":61,"async/staleness_mean":3.625,"generate/avg_num_tokens":2845.9648,"generate/avg_tokens_non_zero_rewards":2992.8376,"generate/avg_tokens_zero_rewards":1283.7727,"generate/max_num_tokens":22700,"generate/std_num_tokens":1768.4694,"loss/avg_final_rewards":0.9141,"loss/avg_raw_advantages":-0.0046,"loss/avg_raw_advantages_abs":0.0427,"policy/policy_entropy":0.1015,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0149,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9141,"timing/step":776.8216,"trainer/epoch":1}
+{"step":62,"async/staleness_mean":3.1875,"generate/avg_num_tokens":2664.6875,"generate/avg_tokens_non_zero_rewards":2777.6955,"generate/avg_tokens_zero_rewards":552.3077,"generate/max_num_tokens":12053,"generate/std_num_tokens":1443.9594,"loss/avg_final_rewards":0.9492,"loss/avg_raw_advantages":0.0033,"loss/avg_raw_advantages_abs":0.0243,"policy/policy_entropy":0.1054,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0148,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9492,"timing/step":839.203,"trainer/epoch":1}
+{"step":63,"async/staleness_mean":2.8438,"generate/avg_num_tokens":2621.5898,"generate/avg_tokens_non_zero_rewards":2721.7835,"generate/avg_tokens_zero_rewards":821.8148,"generate/max_num_tokens":9347,"generate/std_num_tokens":1257.4092,"loss/avg_final_rewards":0.9473,"loss/avg_raw_advantages":0.0016,"loss/avg_raw_advantages_abs":0.0318,"policy/policy_entropy":0.1049,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0243,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9473,"timing/step":463.7961,"trainer/epoch":1}
+{"step":64,"async/staleness_mean":3.3906,"generate/avg_num_tokens":2631.5742,"generate/avg_tokens_non_zero_rewards":2770.8408,"generate/avg_tokens_zero_rewards":1031.7073,"generate/max_num_tokens":10004,"generate/std_num_tokens":1444.8114,"loss/avg_final_rewards":0.9199,"loss/avg_raw_advantages":-0.0043,"loss/avg_raw_advantages_abs":0.0509,"policy/policy_entropy":0.1037,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0119,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9199,"timing/step":677.503,"trainer/epoch":1}
+{"step":65,"async/staleness_mean":3.9531,"generate/avg_num_tokens":2877.4531,"generate/avg_tokens_non_zero_rewards":3008.7457,"generate/avg_tokens_zero_rewards":1608.2917,"generate/max_num_tokens":14795,"generate/std_num_tokens":1673.452,"loss/avg_final_rewards":0.9062,"loss/avg_raw_advantages":-0.0005,"loss/avg_raw_advantages_abs":0.0823,"policy/policy_entropy":0.1057,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0218,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9062,"timing/step":590.4898,"trainer/epoch":1}
+{"step":66,"async/staleness_mean":3.8438,"generate/avg_num_tokens":2806.2852,"generate/avg_tokens_non_zero_rewards":2922.8112,"generate/avg_tokens_zero_rewards":934.1,"generate/max_num_tokens":12837,"generate/std_num_tokens":1487.4971,"loss/avg_final_rewards":0.9414,"loss/avg_raw_advantages":0.0006,"loss/avg_raw_advantages_abs":0.0396,"policy/policy_entropy":0.1053,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0126,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9414,"timing/step":559.1384,"trainer/epoch":1}
+{"step":67,"async/staleness_mean":3.875,"generate/avg_num_tokens":2812.5215,"generate/avg_tokens_non_zero_rewards":2960.1459,"generate/avg_tokens_zero_rewards":1022.1026,"generate/max_num_tokens":11669,"generate/std_num_tokens":1560.2387,"loss/avg_final_rewards":0.9238,"loss/avg_raw_advantages":0.0003,"loss/avg_raw_advantages_abs":0.0256,"policy/policy_entropy":0.1005,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0106,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.9238,"timing/step":765.5756,"trainer/epoch":1}
+{"step":68,"async/staleness_mean":3.375,"generate/avg_num_tokens":2612.9922,"generate/avg_tokens_non_zero_rewards":2763.431,"generate/avg_tokens_zero_rewards":498.0,"generate/max_num_tokens":9393,"generate/std_num_tokens":1315.2754,"loss/avg_final_rewards":0.9336,"loss/avg_raw_advantages":-0.002,"loss/avg_raw_advantages_abs":0.0208,"policy/policy_entropy":0.1015,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.009,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9336,"timing/step":751.558,"trainer/epoch":1}
+{"step":69,"async/staleness_mean":3.7031,"generate/avg_num_tokens":2728.7969,"generate/avg_tokens_non_zero_rewards":2841.2257,"generate/avg_tokens_zero_rewards":856.2759,"generate/max_num_tokens":10693,"generate/std_num_tokens":1381.2743,"loss/avg_final_rewards":0.9434,"loss/avg_raw_advantages":-0.0041,"loss/avg_raw_advantages_abs":0.0314,"policy/policy_entropy":0.1077,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.008,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9434,"timing/step":596.0836,"trainer/epoch":1}
+{"step":70,"async/staleness_mean":3.5156,"generate/avg_num_tokens":2916.2012,"generate/avg_tokens_non_zero_rewards":3104.4258,"generate/avg_tokens_zero_rewards":695.15,"generate/max_num_tokens":14016,"generate/std_num_tokens":1841.5559,"loss/avg_final_rewards":0.9219,"loss/avg_raw_advantages":-0.0024,"loss/avg_raw_advantages_abs":0.0277,"policy/policy_entropy":0.1043,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0112,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9219,"timing/step":571.6014,"trainer/epoch":1}
+{"step":71,"async/staleness_mean":3.3906,"generate/avg_num_tokens":2742.6836,"generate/avg_tokens_non_zero_rewards":2872.2635,"generate/avg_tokens_zero_rewards":660.7667,"generate/max_num_tokens":27804,"generate/std_num_tokens":1741.732,"loss/avg_final_rewards":0.9414,"loss/avg_raw_advantages":0.0053,"loss/avg_raw_advantages_abs":0.0322,"policy/policy_entropy":0.106,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0291,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9414,"timing/step":701.936,"trainer/epoch":1}
+{"step":72,"async/staleness_mean":4.25,"generate/avg_num_tokens":2518.4102,"generate/avg_tokens_non_zero_rewards":2719.7987,"generate/avg_tokens_zero_rewards":657.58,"generate/max_num_tokens":10577,"generate/std_num_tokens":1418.1654,"loss/avg_final_rewards":0.9023,"loss/avg_raw_advantages":0.0003,"loss/avg_raw_advantages_abs":0.0131,"policy/policy_entropy":0.0997,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0069,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.9023,"timing/step":518.1089,"trainer/epoch":1}
+{"step":73,"async/staleness_mean":4.2344,"generate/avg_num_tokens":2859.4844,"generate/avg_tokens_non_zero_rewards":3043.2833,"generate/avg_tokens_zero_rewards":630.3333,"generate/max_num_tokens":12331,"generate/std_num_tokens":1680.893,"loss/avg_final_rewards":0.9238,"loss/avg_raw_advantages":0.0026,"loss/avg_raw_advantages_abs":0.0294,"policy/policy_entropy":0.1025,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0148,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9238,"timing/step":589.3744,"trainer/epoch":1}
+{"step":74,"async/staleness_mean":3.8594,"generate/avg_num_tokens":2868.1055,"generate/avg_tokens_non_zero_rewards":2998.4584,"generate/avg_tokens_zero_rewards":1446.3488,"generate/max_num_tokens":12107,"generate/std_num_tokens":1580.0912,"loss/avg_final_rewards":0.916,"loss/avg_raw_advantages":0.0017,"loss/avg_raw_advantages_abs":0.038,"policy/policy_entropy":0.1019,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0126,"reward/avg_pass_at_8":0.9844,"reward/avg_raw_reward":0.916,"timing/step":698.1936,"trainer/epoch":1}
+{"step":75,"async/staleness_mean":1.375,"generate/avg_num_tokens":2515.0352,"generate/avg_tokens_non_zero_rewards":2533.1736,"generate/avg_tokens_zero_rewards":675.8,"generate/max_num_tokens":10097,"generate/std_num_tokens":1195.7212,"loss/avg_final_rewards":0.9902,"loss/avg_raw_advantages":-0.001,"loss/avg_raw_advantages_abs":0.0042,"policy/policy_entropy":0.1075,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0057,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9902,"timing/step":1309.7496,"trainer/epoch":1}
+{"step":76,"async/staleness_mean":0.8281,"generate/avg_num_tokens":2758.6719,"generate/avg_tokens_non_zero_rewards":2760.4344,"generate/avg_tokens_zero_rewards":1858.0,"generate/max_num_tokens":13970,"generate/std_num_tokens":1186.4283,"loss/avg_final_rewards":0.998,"loss/avg_raw_advantages":0.0004,"loss/avg_raw_advantages_abs":0.0031,"policy/policy_entropy":0.1076,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0047,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.998,"timing/step":731.729,"trainer/epoch":1}
+{"step":77,"async/staleness_mean":1.5312,"generate/avg_num_tokens":2914.1328,"generate/avg_tokens_non_zero_rewards":2911.6673,"generate/avg_tokens_zero_rewards":3092.0,"generate/max_num_tokens":13460,"generate/std_num_tokens":1433.5917,"loss/avg_final_rewards":0.9863,"loss/avg_raw_advantages":-0.0004,"loss/avg_raw_advantages_abs":0.0245,"policy/policy_entropy":0.1113,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0112,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9863,"timing/step":622.7508,"trainer/epoch":1}
+{"step":78,"async/staleness_mean":1.7969,"generate/avg_num_tokens":2782.416,"generate/avg_tokens_non_zero_rewards":2771.4862,"generate/avg_tokens_zero_rewards":4170.5,"generate/max_num_tokens":12210,"generate/std_num_tokens":1349.6586,"loss/avg_final_rewards":0.9922,"loss/avg_raw_advantages":-0.0051,"loss/avg_raw_advantages_abs":0.0183,"policy/policy_entropy":0.1109,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0085,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9922,"timing/step":560.5876,"trainer/epoch":1}
+{"step":79,"async/staleness_mean":2.25,"generate/avg_num_tokens":2749.4746,"generate/avg_tokens_non_zero_rewards":2746.5992,"generate/avg_tokens_zero_rewards":3237.3333,"generate/max_num_tokens":8954,"generate/std_num_tokens":1306.7353,"loss/avg_final_rewards":0.9941,"loss/avg_raw_advantages":0.0002,"loss/avg_raw_advantages_abs":0.014,"policy/policy_entropy":0.114,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0068,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9941,"timing/step":461.4439,"trainer/epoch":1}
+{"step":80,"async/staleness_mean":2.7969,"generate/avg_num_tokens":2860.7715,"generate/avg_tokens_non_zero_rewards":2862.1807,"generate/avg_tokens_zero_rewards":2810.6429,"generate/max_num_tokens":9394,"generate/std_num_tokens":1326.79,"loss/avg_final_rewards":0.9727,"loss/avg_raw_advantages":0.0006,"loss/avg_raw_advantages_abs":0.0289,"policy/policy_entropy":0.1129,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0119,"reward/avg_pass_at_8":1.0,"reward/avg_raw_reward":0.9727,"timing/step":397.2111,"trainer/epoch":1}
diff --git a/viewer/build/inputs/marin/runs/marin-a3-nemotron-agent-calendar/run.json b/viewer/build/inputs/marin/runs/marin-a3-nemotron-agent-calendar/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..a2afe1de04025e3e3a423e225f4e8febace9062d
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-a3-nemotron-agent-calendar/run.json
@@ -0,0 +1,27 @@
+{
+ "id": "marin-a3-nemotron-agent-calendar",
+ "title": "A3 RLOO on nemotron-gym-agent-calendar (Qwen3-8B agent)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/laion/a3-rl-laion_nemotron-gym-agent-calendar-80-8B/tree/main/training_logs",
+ "license": "apache-2.0",
+ "model": "laion/a3-rl-laion_nemotron-gym-agent-calendar-80-8B",
+ "base_model": "laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink",
+ "method": "RLOO-N (SkyRL, binary verifier reward)",
+ "dataset": "laion/nemotron-gym-agent-calendar",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-09-04T16:21:32Z",
+ "attempts": 0,
+ "note": "Marin A3 sweep (issue #6187): one RLOO-N run per training dataset from the same Qwen3-8B-derived SFT agent, here laion/nemotron-gym-agent-calendar; reward 0.973 and pass@8 1.0 at step 80, per the issue. Our copy has every logged step of the final lineage (3 resumed job segments, 2 superseded rows dropped). The issue concluded this binary-reward setup was uninformative about dataset utility.",
+ "metrics_map": {
+  "reward": "reward/avg_raw_reward",
+  "loss": "policy/policy_loss",
+  "entropy": "policy/policy_entropy",
+  "grad_norm": "policy/raw_grad_norm",
+  "response_length": "generate/avg_num_tokens"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-a3-nl2bash/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-a3-nl2bash/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..5a176f7a3564318601c708868b6470f6eafe6bad
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-a3-nl2bash/metrics.jsonl
@@ -0,0 +1,48 @@
+{"step":1,"async/staleness_mean":0.0,"generate/avg_num_tokens":3352.2402,"generate/avg_tokens_non_zero_rewards":2985.2197,"generate/avg_tokens_zero_rewards":3479.7316,"generate/max_num_tokens":18150,"generate/std_num_tokens":1982.5026,"loss/avg_final_rewards":0.2578,"loss/avg_raw_advantages":-0.0167,"loss/avg_raw_advantages_abs":0.1818,"policy/policy_entropy":0.1654,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0319,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.2578,"timing/step":1216.34,"trainer/epoch":0}
+{"step":2,"async/staleness_mean":0.8281,"generate/avg_num_tokens":3726.5098,"generate/avg_tokens_non_zero_rewards":3381.7315,"generate/avg_tokens_zero_rewards":3868.0303,"generate/max_num_tokens":21220,"generate/std_num_tokens":2508.9219,"loss/avg_final_rewards":0.291,"loss/avg_raw_advantages":-0.0166,"loss/avg_raw_advantages_abs":0.2525,"policy/policy_entropy":0.1678,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0338,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.291,"timing/step":661.7763,"trainer/epoch":0}
+{"step":3,"async/staleness_mean":1.1875,"generate/avg_num_tokens":3550.0,"generate/avg_tokens_non_zero_rewards":2737.7194,"generate/avg_tokens_zero_rewards":3852.6997,"generate/max_num_tokens":21754,"generate/std_num_tokens":2318.228,"loss/avg_final_rewards":0.2715,"loss/avg_raw_advantages":-0.0207,"loss/avg_raw_advantages_abs":0.211,"policy/policy_entropy":0.163,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0386,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.2715,"timing/step":707.2637,"trainer/epoch":0}
+{"step":4,"async/staleness_mean":1.5312,"generate/avg_num_tokens":3137.4629,"generate/avg_tokens_non_zero_rewards":2889.3333,"generate/avg_tokens_zero_rewards":3268.5642,"generate/max_num_tokens":12387,"generate/std_num_tokens":1813.1676,"loss/avg_final_rewards":0.3457,"loss/avg_raw_advantages":0.0105,"loss/avg_raw_advantages_abs":0.2118,"policy/policy_entropy":0.1633,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0289,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.3457,"timing/step":672.5336,"trainer/epoch":0}
+{"step":5,"async/staleness_mean":1.5625,"generate/avg_num_tokens":3214.2305,"generate/avg_tokens_non_zero_rewards":2715.2885,"generate/avg_tokens_zero_rewards":3432.868,"generate/max_num_tokens":23624,"generate/std_num_tokens":2069.6596,"loss/avg_final_rewards":0.3047,"loss/avg_raw_advantages":-0.0074,"loss/avg_raw_advantages_abs":0.1808,"policy/policy_entropy":0.1649,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0324,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.3047,"timing/step":912.8212,"trainer/epoch":0}
+{"step":6,"async/staleness_mean":2.0469,"generate/avg_num_tokens":3736.7402,"generate/avg_tokens_non_zero_rewards":3083.0563,"generate/avg_tokens_zero_rewards":4033.8693,"generate/max_num_tokens":29460,"generate/std_num_tokens":2935.8412,"loss/avg_final_rewards":0.3125,"loss/avg_raw_advantages":0.0021,"loss/avg_raw_advantages_abs":0.172,"policy/policy_entropy":0.1657,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0301,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.3125,"timing/step":731.2619,"trainer/epoch":0}
+{"step":7,"async/staleness_mean":2.1094,"generate/avg_num_tokens":3666.4707,"generate/avg_tokens_non_zero_rewards":3125.0391,"generate/avg_tokens_zero_rewards":3846.9479,"generate/max_num_tokens":31791,"generate/std_num_tokens":2969.1608,"loss/avg_final_rewards":0.25,"loss/avg_raw_advantages":-0.0123,"loss/avg_raw_advantages_abs":0.2135,"policy/policy_entropy":0.167,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0392,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.25,"timing/step":842.0906,"trainer/epoch":0}
+{"step":8,"async/staleness_mean":1.7969,"generate/avg_num_tokens":3067.0254,"generate/avg_tokens_non_zero_rewards":3047.8589,"generate/avg_tokens_zero_rewards":3075.9771,"generate/max_num_tokens":25018,"generate/std_num_tokens":2106.2528,"loss/avg_final_rewards":0.3184,"loss/avg_raw_advantages":-0.0036,"loss/avg_raw_advantages_abs":0.2085,"policy/policy_entropy":0.1645,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0326,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.3184,"timing/step":967.5325,"trainer/epoch":0}
+{"step":9,"async/staleness_mean":2.8125,"generate/avg_num_tokens":3860.4453,"generate/avg_tokens_non_zero_rewards":3139.155,"generate/avg_tokens_zero_rewards":4103.3864,"generate/max_num_tokens":29565,"generate/std_num_tokens":3376.5289,"loss/avg_final_rewards":0.252,"loss/avg_raw_advantages":-0.0101,"loss/avg_raw_advantages_abs":0.1668,"policy/policy_entropy":0.1688,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0262,"reward/avg_pass_at_8":0.4688,"reward/avg_raw_reward":0.252,"timing/step":696.2709,"trainer/epoch":0}
+{"step":10,"async/staleness_mean":2.9531,"generate/avg_num_tokens":3999.9629,"generate/avg_tokens_non_zero_rewards":3180.4966,"generate/avg_tokens_zero_rewards":4336.3278,"generate/max_num_tokens":18644,"generate/std_num_tokens":2863.4872,"loss/avg_final_rewards":0.291,"loss/avg_raw_advantages":-0.0047,"loss/avg_raw_advantages_abs":0.1412,"policy/policy_entropy":0.1711,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0273,"reward/avg_pass_at_8":0.5156,"reward/avg_raw_reward":0.291,"timing/step":621.677,"trainer/epoch":0}
+{"step":11,"async/staleness_mean":3.0312,"generate/avg_num_tokens":3999.1641,"generate/avg_tokens_non_zero_rewards":2960.3374,"generate/avg_tokens_zero_rewards":4484.3467,"generate/max_num_tokens":31797,"generate/std_num_tokens":3286.2161,"loss/avg_final_rewards":0.3184,"loss/avg_raw_advantages":-0.0152,"loss/avg_raw_advantages_abs":0.1742,"policy/policy_entropy":0.1695,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0279,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.3184,"timing/step":664.4641,"trainer/epoch":0}
+{"step":12,"async/staleness_mean":2.4375,"generate/avg_num_tokens":3714.834,"generate/avg_tokens_non_zero_rewards":2952.5714,"generate/avg_tokens_zero_rewards":4160.8638,"generate/max_num_tokens":21755,"generate/std_num_tokens":2515.9931,"loss/avg_final_rewards":0.3691,"loss/avg_raw_advantages":-0.0163,"loss/avg_raw_advantages_abs":0.1796,"policy/policy_entropy":0.1702,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0272,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.3691,"timing/step":821.7749,"trainer/epoch":0}
+{"step":13,"async/staleness_mean":1.9531,"generate/avg_num_tokens":3352.8047,"generate/avg_tokens_non_zero_rewards":2851.5652,"generate/avg_tokens_zero_rewards":3633.9878,"generate/max_num_tokens":31802,"generate/std_num_tokens":2432.2051,"loss/avg_final_rewards":0.3594,"loss/avg_raw_advantages":-0.0078,"loss/avg_raw_advantages_abs":0.177,"policy/policy_entropy":0.1637,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0295,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.3594,"timing/step":679.5294,"trainer/epoch":0}
+{"step":14,"async/staleness_mean":2.2188,"generate/avg_num_tokens":3381.3848,"generate/avg_tokens_non_zero_rewards":2674.2604,"generate/avg_tokens_zero_rewards":3729.793,"generate/max_num_tokens":31807,"generate/std_num_tokens":3159.6383,"loss/avg_final_rewards":0.3301,"loss/avg_raw_advantages":-0.0037,"loss/avg_raw_advantages_abs":0.1685,"policy/policy_entropy":0.1646,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0283,"reward/avg_pass_at_8":0.5469,"reward/avg_raw_reward":0.3301,"timing/step":1026.1547,"trainer/epoch":0}
+{"step":15,"async/staleness_mean":2.4531,"generate/avg_num_tokens":4004.1074,"generate/avg_tokens_non_zero_rewards":2946.5819,"generate/avg_tokens_zero_rewards":4562.8597,"generate/max_num_tokens":31811,"generate/std_num_tokens":3190.4199,"loss/avg_final_rewards":0.3457,"loss/avg_raw_advantages":-0.0139,"loss/avg_raw_advantages_abs":0.1807,"policy/policy_entropy":0.1752,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0313,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.3457,"timing/step":1006.1819,"trainer/epoch":0}
+{"step":16,"async/staleness_mean":2.5625,"generate/avg_num_tokens":3649.4199,"generate/avg_tokens_non_zero_rewards":2577.3217,"generate/avg_tokens_zero_rewards":4064.8943,"generate/max_num_tokens":31857,"generate/std_num_tokens":3637.0503,"loss/avg_final_rewards":0.2793,"loss/avg_raw_advantages":-0.0074,"loss/avg_raw_advantages_abs":0.0982,"policy/policy_entropy":0.1653,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0251,"reward/avg_pass_at_8":0.4062,"reward/avg_raw_reward":0.2793,"timing/step":1278.6512,"trainer/epoch":0}
+{"step":17,"async/staleness_mean":2.5781,"generate/avg_num_tokens":3307.5,"generate/avg_tokens_non_zero_rewards":3224.385,"generate/avg_tokens_zero_rewards":3355.3231,"generate/max_num_tokens":14549,"generate/std_num_tokens":1869.9983,"loss/avg_final_rewards":0.3652,"loss/avg_raw_advantages":-0.0102,"loss/avg_raw_advantages_abs":0.1643,"policy/policy_entropy":0.1709,"policy/policy_loss":-0.0008,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0233,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.3652,"timing/step":1166.6575,"trainer/epoch":0}
+{"step":18,"async/staleness_mean":3.0938,"generate/avg_num_tokens":3185.6543,"generate/avg_tokens_non_zero_rewards":3065.5391,"generate/avg_tokens_zero_rewards":3225.6927,"generate/max_num_tokens":27509,"generate/std_num_tokens":2931.8951,"loss/avg_final_rewards":0.25,"loss/avg_raw_advantages":0.027,"loss/avg_raw_advantages_abs":0.2172,"policy/policy_entropy":0.1516,"policy/policy_loss":-0.0368,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0291,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.25,"timing/step":598.3133,"trainer/epoch":0}
+{"step":19,"async/staleness_mean":3.125,"generate/avg_num_tokens":3407.1797,"generate/avg_tokens_non_zero_rewards":2795.6562,"generate/avg_tokens_zero_rewards":3685.1449,"generate/max_num_tokens":31796,"generate/std_num_tokens":2731.5702,"loss/avg_final_rewards":0.3125,"loss/avg_raw_advantages":0.0033,"loss/avg_raw_advantages_abs":0.1421,"policy/policy_entropy":0.1585,"policy/policy_loss":-0.0223,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0255,"reward/avg_pass_at_8":0.5156,"reward/avg_raw_reward":0.3125,"timing/step":874.4677,"trainer/epoch":0}
+{"step":20,"async/staleness_mean":3.0938,"generate/avg_num_tokens":3191.4785,"generate/avg_tokens_non_zero_rewards":3127.3125,"generate/avg_tokens_zero_rewards":3212.8672,"generate/max_num_tokens":16154,"generate/std_num_tokens":2152.0271,"loss/avg_final_rewards":0.25,"loss/avg_raw_advantages":0.0168,"loss/avg_raw_advantages_abs":0.1292,"policy/policy_entropy":0.1588,"policy/policy_loss":-0.0084,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0369,"reward/avg_pass_at_8":0.4688,"reward/avg_raw_reward":0.25,"timing/step":1144.1321,"trainer/epoch":0}
+{"step":21,"async/staleness_mean":3.2857,"generate/avg_num_tokens":3254.998,"generate/avg_tokens_non_zero_rewards":2910.2583,"generate/avg_tokens_zero_rewards":3402.4646,"generate/max_num_tokens":31800,"generate/std_num_tokens":2612.288,"loss/avg_final_rewards":0.2996,"loss/avg_raw_advantages":0.0123,"loss/avg_raw_advantages_abs":0.1575,"policy/policy_entropy":0.1591,"policy/policy_loss":-0.0164,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":0.5079,"reward/avg_raw_reward":0.2996,"timing/step":1202.3364,"trainer/epoch":0}
+{"step":22,"async/staleness_mean":3.3281,"generate/avg_num_tokens":2967.5527,"generate/avg_tokens_non_zero_rewards":3486.7418,"generate/avg_tokens_zero_rewards":2681.2121,"generate/max_num_tokens":18393,"generate/std_num_tokens":2216.7916,"loss/avg_final_rewards":0.3555,"loss/avg_raw_advantages":0.0428,"loss/avg_raw_advantages_abs":0.2496,"policy/policy_entropy":0.1389,"policy/policy_loss":-0.0343,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.041,"reward/avg_pass_at_8":0.6562,"reward/avg_raw_reward":0.3555,"timing/step":191.685,"trainer/epoch":0}
+{"step":23,"async/staleness_mean":5.1406,"generate/avg_num_tokens":4687.584,"generate/avg_tokens_non_zero_rewards":4047.3274,"generate/avg_tokens_zero_rewards":4868.9098,"generate/max_num_tokens":31856,"generate/std_num_tokens":4223.1637,"loss/avg_final_rewards":0.2207,"loss/avg_raw_advantages":0.0029,"loss/avg_raw_advantages_abs":0.1345,"policy/policy_entropy":0.1661,"policy/policy_loss":-0.0131,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0216,"reward/avg_pass_at_8":0.4375,"reward/avg_raw_reward":0.2207,"timing/step":731.0408,"trainer/epoch":0}
+{"step":24,"async/staleness_mean":5.3651,"generate/avg_num_tokens":8120.4286,"generate/avg_tokens_non_zero_rewards":6356.3905,"generate/avg_tokens_zero_rewards":8584.6491,"generate/max_num_tokens":31822,"generate/std_num_tokens":8224.9844,"loss/avg_final_rewards":0.2083,"loss/avg_raw_advantages":-0.0051,"loss/avg_raw_advantages_abs":0.1786,"policy/policy_entropy":0.1651,"policy/policy_loss":-0.0116,"policy/ppo_clip_ratio":0.0,"reward/avg_pass_at_8":0.4762,"reward/avg_raw_reward":0.2083,"timing/step":4309.9466,"trainer/epoch":0}
+{"step":25,"async/staleness_mean":0.0,"generate/avg_num_tokens":2936.2734,"generate/avg_tokens_non_zero_rewards":2846.2981,"generate/avg_tokens_zero_rewards":2997.8355,"generate/max_num_tokens":22699,"generate/std_num_tokens":2173.5412,"loss/avg_final_rewards":0.4062,"loss/avg_raw_advantages":-0.0247,"loss/avg_raw_advantages_abs":0.2101,"policy/policy_entropy":0.1565,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0363,"reward/avg_pass_at_8":0.625,"reward/avg_raw_reward":0.4062,"timing/step":1335.3915,"trainer/epoch":1}
+{"step":26,"async/staleness_mean":0.7812,"generate/avg_num_tokens":3038.418,"generate/avg_tokens_non_zero_rewards":2761.0186,"generate/avg_tokens_zero_rewards":3239.229,"generate/max_num_tokens":16213,"generate/std_num_tokens":2018.5572,"loss/avg_final_rewards":0.4199,"loss/avg_raw_advantages":-0.0028,"loss/avg_raw_advantages_abs":0.1708,"policy/policy_entropy":0.1622,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0334,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.4199,"timing/step":855.1144,"trainer/epoch":1}
+{"step":27,"async/staleness_mean":1.3125,"generate/avg_num_tokens":3356.1113,"generate/avg_tokens_non_zero_rewards":2782.2455,"generate/avg_tokens_zero_rewards":3788.476,"generate/max_num_tokens":23835,"generate/std_num_tokens":2371.8118,"loss/avg_final_rewards":0.4297,"loss/avg_raw_advantages":-0.0023,"loss/avg_raw_advantages_abs":0.155,"policy/policy_entropy":0.1603,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0258,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.4297,"timing/step":1080.1866,"trainer/epoch":1}
+{"step":28,"async/staleness_mean":1.7969,"generate/avg_num_tokens":3113.0625,"generate/avg_tokens_non_zero_rewards":2736.2213,"generate/avg_tokens_zero_rewards":3432.7653,"generate/max_num_tokens":12512,"generate/std_num_tokens":1519.7836,"loss/avg_final_rewards":0.459,"loss/avg_raw_advantages":0.0022,"loss/avg_raw_advantages_abs":0.1806,"policy/policy_entropy":0.1607,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.029,"reward/avg_pass_at_8":0.6719,"reward/avg_raw_reward":0.459,"timing/step":1060.8113,"trainer/epoch":1}
+{"step":29,"async/staleness_mean":1.7344,"generate/avg_num_tokens":2415.0977,"generate/avg_tokens_non_zero_rewards":2673.164,"generate/avg_tokens_zero_rewards":2264.0929,"generate/max_num_tokens":10450,"generate/std_num_tokens":1586.9879,"loss/avg_final_rewards":0.3691,"loss/avg_raw_advantages":0.0347,"loss/avg_raw_advantages_abs":0.2096,"policy/policy_entropy":0.1327,"policy/policy_loss":-0.0424,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0258,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.3691,"timing/step":1504.4548,"trainer/epoch":1}
+{"step":30,"async/staleness_mean":2.375,"generate/avg_num_tokens":2830.498,"generate/avg_tokens_non_zero_rewards":3100.0791,"generate/avg_tokens_zero_rewards":2730.0375,"generate/max_num_tokens":31793,"generate/std_num_tokens":2256.1524,"loss/avg_final_rewards":0.2715,"loss/avg_raw_advantages":0.0223,"loss/avg_raw_advantages_abs":0.1885,"policy/policy_entropy":0.1401,"policy/policy_loss":-0.022,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0276,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.2715,"timing/step":1405.3238,"trainer/epoch":1}
+{"step":31,"async/staleness_mean":2.75,"generate/avg_num_tokens":3558.3574,"generate/avg_tokens_non_zero_rewards":2757.8198,"generate/avg_tokens_zero_rewards":3963.3353,"generate/max_num_tokens":21395,"generate/std_num_tokens":2960.4903,"loss/avg_final_rewards":0.3359,"loss/avg_raw_advantages":0.0217,"loss/avg_raw_advantages_abs":0.1805,"policy/policy_entropy":0.1491,"policy/policy_loss":-0.0246,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0286,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.3359,"timing/step":1063.248,"trainer/epoch":1}
+{"step":32,"async/staleness_mean":2.75,"generate/avg_num_tokens":3455.5938,"generate/avg_tokens_non_zero_rewards":3406.0,"generate/avg_tokens_zero_rewards":3475.377,"generate/max_num_tokens":31860,"generate/std_num_tokens":3578.9994,"loss/avg_final_rewards":0.2852,"loss/avg_raw_advantages":0.04,"loss/avg_raw_advantages_abs":0.1608,"policy/policy_entropy":0.1445,"policy/policy_loss":-0.0321,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0241,"reward/avg_pass_at_8":0.5469,"reward/avg_raw_reward":0.2852,"timing/step":1066.546,"trainer/epoch":1}
+{"step":33,"async/staleness_mean":3.4844,"generate/avg_num_tokens":3966.6543,"generate/avg_tokens_non_zero_rewards":3122.9412,"generate/avg_tokens_zero_rewards":4386.0439,"generate/max_num_tokens":31837,"generate/std_num_tokens":4143.3029,"loss/avg_final_rewards":0.332,"loss/avg_raw_advantages":0.0029,"loss/avg_raw_advantages_abs":0.1575,"policy/policy_entropy":0.1508,"policy/policy_loss":-0.0059,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0269,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.332,"timing/step":1072.7697,"trainer/epoch":1}
+{"step":34,"async/staleness_mean":3.5312,"generate/avg_num_tokens":3689.877,"generate/avg_tokens_non_zero_rewards":3468.7487,"generate/avg_tokens_zero_rewards":3817.1108,"generate/max_num_tokens":31787,"generate/std_num_tokens":2794.5776,"loss/avg_final_rewards":0.3652,"loss/avg_raw_advantages":-0.0098,"loss/avg_raw_advantages_abs":0.2416,"policy/policy_entropy":0.1519,"policy/policy_loss":-0.01,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0267,"reward/avg_pass_at_8":0.625,"reward/avg_raw_reward":0.3652,"timing/step":807.2692,"trainer/epoch":1}
+{"step":35,"async/staleness_mean":3.6094,"generate/avg_num_tokens":3523.7188,"generate/avg_tokens_non_zero_rewards":3091.564,"generate/avg_tokens_zero_rewards":3742.3382,"generate/max_num_tokens":31893,"generate/std_num_tokens":3531.3037,"loss/avg_final_rewards":0.3359,"loss/avg_raw_advantages":0.0209,"loss/avg_raw_advantages_abs":0.1373,"policy/policy_entropy":0.146,"policy/policy_loss":-0.0167,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0241,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.3359,"timing/step":1104.5501,"trainer/epoch":1}
+{"step":36,"async/staleness_mean":3.3594,"generate/avg_num_tokens":2614.9492,"generate/avg_tokens_non_zero_rewards":3124.878,"generate/avg_tokens_zero_rewards":2453.7121,"generate/max_num_tokens":31790,"generate/std_num_tokens":2523.1787,"loss/avg_final_rewards":0.2402,"loss/avg_raw_advantages":0.0515,"loss/avg_raw_advantages_abs":0.1496,"policy/policy_entropy":0.1157,"policy/policy_loss":-0.0454,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0232,"reward/avg_pass_at_8":0.4688,"reward/avg_raw_reward":0.2402,"timing/step":579.0805,"trainer/epoch":1}
+{"step":37,"async/staleness_mean":3.875,"generate/avg_num_tokens":4085.3691,"generate/avg_tokens_non_zero_rewards":3542.0213,"generate/avg_tokens_zero_rewards":4291.8706,"generate/max_num_tokens":31869,"generate/std_num_tokens":3237.1246,"loss/avg_final_rewards":0.2754,"loss/avg_raw_advantages":0.0112,"loss/avg_raw_advantages_abs":0.1345,"policy/policy_entropy":0.1495,"policy/policy_loss":-0.0259,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0229,"reward/avg_pass_at_8":0.4688,"reward/avg_raw_reward":0.2754,"timing/step":919.7587,"trainer/epoch":1}
+{"step":38,"async/staleness_mean":2.9688,"generate/avg_num_tokens":3382.25,"generate/avg_tokens_non_zero_rewards":3006.8256,"generate/avg_tokens_zero_rewards":3613.1893,"generate/max_num_tokens":31806,"generate/std_num_tokens":3421.0889,"loss/avg_final_rewards":0.3809,"loss/avg_raw_advantages":0.0223,"loss/avg_raw_advantages_abs":0.1881,"policy/policy_entropy":0.1386,"policy/policy_loss":-0.0193,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0284,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.3809,"timing/step":1279.6712,"trainer/epoch":1}
+{"step":39,"async/staleness_mean":3.1406,"generate/avg_num_tokens":3678.4531,"generate/avg_tokens_non_zero_rewards":2720.9455,"generate/avg_tokens_zero_rewards":4133.7522,"generate/max_num_tokens":31879,"generate/std_num_tokens":2850.2191,"loss/avg_final_rewards":0.3223,"loss/avg_raw_advantages":-0.0032,"loss/avg_raw_advantages_abs":0.0884,"policy/policy_entropy":0.1538,"policy/policy_loss":-0.0053,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0229,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.3223,"timing/step":1041.2257,"trainer/epoch":1}
+{"step":40,"async/staleness_mean":3.0469,"generate/avg_num_tokens":3621.1445,"generate/avg_tokens_non_zero_rewards":3113.7897,"generate/avg_tokens_zero_rewards":3985.4866,"generate/max_num_tokens":31806,"generate/std_num_tokens":3049.3881,"loss/avg_final_rewards":0.418,"loss/avg_raw_advantages":0.0059,"loss/avg_raw_advantages_abs":0.1633,"policy/policy_entropy":0.1498,"policy/policy_loss":-0.0022,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0286,"reward/avg_pass_at_8":0.625,"reward/avg_raw_reward":0.418,"timing/step":1218.6808,"trainer/epoch":1}
+{"step":41,"async/staleness_mean":0.2188,"generate/avg_num_tokens":3203.291,"generate/avg_tokens_non_zero_rewards":3123.5,"generate/avg_tokens_zero_rewards":3245.0863,"generate/max_num_tokens":13902,"generate/std_num_tokens":1793.951,"loss/avg_final_rewards":0.3438,"loss/avg_raw_advantages":-0.0068,"loss/avg_raw_advantages_abs":0.1501,"policy/policy_entropy":0.1505,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0267,"reward/avg_pass_at_8":0.5333,"reward/avg_raw_reward":0.3438,"timing/step":3662.3125,"trainer/epoch":1}
+{"step":42,"async/staleness_mean":0.9062,"generate/avg_num_tokens":3331.1836,"generate/avg_tokens_non_zero_rewards":2943.854,"generate/avg_tokens_zero_rewards":3637.2552,"generate/max_num_tokens":11623,"generate/std_num_tokens":1556.8658,"loss/avg_final_rewards":0.4414,"loss/avg_raw_advantages":-0.0133,"loss/avg_raw_advantages_abs":0.1948,"policy/policy_entropy":0.1504,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0308,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.4414,"timing/step":1534.3597,"trainer/epoch":1}
+{"step":43,"async/staleness_mean":0.1719,"generate/avg_num_tokens":3190.0996,"generate/avg_tokens_non_zero_rewards":3053.0224,"generate/avg_tokens_zero_rewards":3295.872,"generate/max_num_tokens":11164,"generate/std_num_tokens":1502.4466,"loss/avg_final_rewards":0.4355,"loss/avg_raw_advantages":-0.0071,"loss/avg_raw_advantages_abs":0.1941,"policy/policy_entropy":0.1458,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0276,"reward/avg_pass_at_8":0.6667,"reward/avg_raw_reward":0.4355,"timing/step":4401.7553,"trainer/epoch":1}
+{"step":44,"async/staleness_mean":0.9375,"generate/avg_num_tokens":3215.6934,"generate/avg_tokens_non_zero_rewards":2875.5211,"generate/avg_tokens_zero_rewards":3416.4161,"generate/max_num_tokens":12180,"generate/std_num_tokens":1578.4323,"loss/avg_final_rewards":0.3711,"loss/avg_raw_advantages":-0.007,"loss/avg_raw_advantages_abs":0.1815,"policy/policy_entropy":0.1453,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0269,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.3711,"timing/step":1523.7192,"trainer/epoch":1}
+{"step":45,"async/staleness_mean":1.5938,"generate/avg_num_tokens":3762.9023,"generate/avg_tokens_non_zero_rewards":3104.2857,"generate/avg_tokens_zero_rewards":4195.5858,"generate/max_num_tokens":31796,"generate/std_num_tokens":3033.3303,"loss/avg_final_rewards":0.3965,"loss/avg_raw_advantages":-0.0017,"loss/avg_raw_advantages_abs":0.1568,"policy/policy_entropy":0.1536,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0283,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.3965,"timing/step":1062.3058,"trainer/epoch":1}
+{"step":46,"async/staleness_mean":2.2656,"generate/avg_num_tokens":3646.7539,"generate/avg_tokens_non_zero_rewards":3598.0478,"generate/avg_tokens_zero_rewards":3686.4787,"generate/max_num_tokens":17881,"generate/std_num_tokens":2052.2221,"loss/avg_final_rewards":0.4492,"loss/avg_raw_advantages":-0.0053,"loss/avg_raw_advantages_abs":0.2006,"policy/policy_entropy":0.15,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0297,"reward/avg_pass_at_8":0.6719,"reward/avg_raw_reward":0.4492,"timing/step":470.1386,"trainer/epoch":1}
+{"step":47,"async/staleness_mean":3.5469,"generate/avg_num_tokens":6660.0742,"generate/avg_tokens_non_zero_rewards":5136.8,"generate/avg_tokens_zero_rewards":6984.9431,"generate/max_num_tokens":31832,"generate/std_num_tokens":5486.724,"loss/avg_final_rewards":0.1758,"loss/avg_raw_advantages":-0.0159,"loss/avg_raw_advantages_abs":0.1279,"policy/policy_entropy":0.167,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0228,"reward/avg_pass_at_8":0.3594,"reward/avg_raw_reward":0.1758,"timing/step":948.8113,"trainer/epoch":1}
+{"step":48,"async/staleness_mean":4.4531,"generate/avg_num_tokens":9621.7012,"generate/avg_tokens_non_zero_rewards":7109.9741,"generate/avg_tokens_zero_rewards":10357.4596,"generate/max_num_tokens":31815,"generate/std_num_tokens":9164.0238,"loss/avg_final_rewards":0.2266,"loss/avg_raw_advantages":-0.0114,"loss/avg_raw_advantages_abs":0.0914,"policy/policy_entropy":0.1578,"policy/policy_loss":-0.0013,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0216,"reward/avg_pass_at_8":0.4062,"reward/avg_raw_reward":0.2266,"timing/step":1736.6484,"trainer/epoch":1}
diff --git a/viewer/build/inputs/marin/runs/marin-a3-nl2bash/run.json b/viewer/build/inputs/marin/runs/marin-a3-nl2bash/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..8a773160a1f05a6040e5dd947ad838e1975e0b54
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-a3-nl2bash/run.json
@@ -0,0 +1,27 @@
+{
+ "id": "marin-a3-nl2bash",
+ "title": "A3 RLOO on nl2bash-tasks-cleaned-oracle (Qwen3-8B agent)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/laion/a3-rl-DCAgent2_nl2bash-tasks-cleaned-oracle-40-8B/tree/main/training_logs",
+ "license": "unknown",
+ "model": "laion/a3-rl-DCAgent2_nl2bash-tasks-cleaned-oracle-40-8B",
+ "base_model": "laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink",
+ "method": "RLOO-N (SkyRL, binary verifier reward)",
+ "dataset": "DCAgent2/nl2bash-tasks-cleaned-oracle",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-05-26T11:57:42Z",
+ "attempts": 0,
+ "note": "Marin A3 sweep (issue #6187): one RLOO-N run per training dataset from the same Qwen3-8B-derived SFT agent, here DCAgent2/nl2bash-tasks-cleaned-oracle; EMA-best step 40 at reward 0.418 (peak 0.449 at step 46), per the issue. Our copy has every logged step of the final lineage (3 resumed job segments). The issue concluded this binary-reward setup was uninformative about dataset utility.",
+ "metrics_map": {
+  "reward": "reward/avg_raw_reward",
+  "loss": "policy/policy_loss",
+  "entropy": "policy/policy_entropy",
+  "grad_norm": "policy/raw_grad_norm",
+  "response_length": "generate/avg_num_tokens"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-a3-pymethods2test-large/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-a3-pymethods2test-large/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..9664659d33a57d74d8d8255875ce692b5adb956b
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-a3-pymethods2test-large/metrics.jsonl
@@ -0,0 +1,80 @@
+{"step":1,"async/staleness_mean":0.0,"generate/avg_num_tokens":4192.293,"generate/avg_tokens_non_zero_rewards":4001.5203,"generate/avg_tokens_zero_rewards":4829.2797,"generate/max_num_tokens":24079,"generate/std_num_tokens":2506.7135,"loss/avg_final_rewards":0.7695,"loss/avg_raw_advantages":-0.0021,"loss/avg_raw_advantages_abs":0.0903,"policy/policy_entropy":0.1167,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.012,"reward/avg_pass_at_8":0.8281,"reward/avg_raw_reward":0.7695,"timing/step":2875.5985,"trainer/epoch":0}
+{"step":2,"async/staleness_mean":0.7969,"generate/avg_num_tokens":5257.0879,"generate/avg_tokens_non_zero_rewards":4815.84,"generate/avg_tokens_zero_rewards":5603.0139,"generate/max_num_tokens":31833,"generate/std_num_tokens":4823.3388,"loss/avg_final_rewards":0.4395,"loss/avg_raw_advantages":0.0098,"loss/avg_raw_advantages_abs":0.1284,"policy/policy_entropy":0.1334,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0208,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.4395,"timing/step":2058.8732,"trainer/epoch":0}
+{"step":3,"async/staleness_mean":1.5469,"generate/avg_num_tokens":5455.3965,"generate/avg_tokens_non_zero_rewards":5425.0375,"generate/avg_tokens_zero_rewards":5469.196,"generate/max_num_tokens":31760,"generate/std_num_tokens":5367.2198,"loss/avg_final_rewards":0.3125,"loss/avg_raw_advantages":0.013,"loss/avg_raw_advantages_abs":0.1173,"policy/policy_entropy":0.1368,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0244,"reward/avg_pass_at_8":0.4219,"reward/avg_raw_reward":0.3125,"timing/step":832.7235,"trainer/epoch":0}
+{"step":4,"async/staleness_mean":1.6562,"generate/avg_num_tokens":5456.8906,"generate/avg_tokens_non_zero_rewards":5023.9922,"generate/avg_tokens_zero_rewards":5893.1843,"generate/max_num_tokens":31773,"generate/std_num_tokens":4390.4548,"loss/avg_final_rewards":0.502,"loss/avg_raw_advantages":-0.0034,"loss/avg_raw_advantages_abs":0.0818,"policy/policy_entropy":0.1275,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0125,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.502,"timing/step":1506.9729,"trainer/epoch":0}
+{"step":5,"async/staleness_mean":1.6875,"generate/avg_num_tokens":4792.168,"generate/avg_tokens_non_zero_rewards":4960.31,"generate/avg_tokens_zero_rewards":4656.1095,"generate/max_num_tokens":21648,"generate/std_num_tokens":3443.3735,"loss/avg_final_rewards":0.4473,"loss/avg_raw_advantages":0.002,"loss/avg_raw_advantages_abs":0.1262,"policy/policy_entropy":0.1283,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.015,"reward/avg_pass_at_8":0.5469,"reward/avg_raw_reward":0.4473,"timing/step":1502.3635,"trainer/epoch":0}
+{"step":6,"async/staleness_mean":2.1875,"generate/avg_num_tokens":5843.9004,"generate/avg_tokens_non_zero_rewards":5913.6589,"generate/avg_tokens_zero_rewards":5793.8054,"generate/max_num_tokens":31837,"generate/std_num_tokens":4968.0944,"loss/avg_final_rewards":0.418,"loss/avg_raw_advantages":0.0195,"loss/avg_raw_advantages_abs":0.1118,"policy/policy_entropy":0.129,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0133,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.418,"timing/step":1135.6277,"trainer/epoch":0}
+{"step":7,"async/staleness_mean":1.9688,"generate/avg_num_tokens":4991.7988,"generate/avg_tokens_non_zero_rewards":4943.9369,"generate/avg_tokens_zero_rewards":5028.4379,"generate/max_num_tokens":31826,"generate/std_num_tokens":4014.433,"loss/avg_final_rewards":0.4336,"loss/avg_raw_advantages":0.0158,"loss/avg_raw_advantages_abs":0.1432,"policy/policy_entropy":0.136,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0145,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.4336,"timing/step":1248.2931,"trainer/epoch":0}
+{"step":8,"async/staleness_mean":1.8906,"generate/avg_num_tokens":5594.0117,"generate/avg_tokens_non_zero_rewards":5319.9113,"generate/avg_tokens_zero_rewards":5851.5,"generate/max_num_tokens":31801,"generate/std_num_tokens":4759.5927,"loss/avg_final_rewards":0.4844,"loss/avg_raw_advantages":-0.0092,"loss/avg_raw_advantages_abs":0.1119,"policy/policy_entropy":0.1317,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0122,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.4844,"timing/step":1727.4666,"trainer/epoch":0}
+{"step":9,"async/staleness_mean":1.8281,"generate/avg_num_tokens":5525.2188,"generate/avg_tokens_non_zero_rewards":5002.9954,"generate/avg_tokens_zero_rewards":5906.3007,"generate/max_num_tokens":31777,"generate/std_num_tokens":4894.2365,"loss/avg_final_rewards":0.4219,"loss/avg_raw_advantages":0.0035,"loss/avg_raw_advantages_abs":0.0801,"policy/policy_entropy":0.1326,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0099,"reward/avg_pass_at_8":0.5156,"reward/avg_raw_reward":0.4219,"timing/step":1368.8331,"trainer/epoch":0}
+{"step":10,"async/staleness_mean":1.75,"generate/avg_num_tokens":5405.0176,"generate/avg_tokens_non_zero_rewards":4519.9746,"generate/avg_tokens_zero_rewards":5958.5206,"generate/max_num_tokens":31815,"generate/std_num_tokens":4909.1097,"loss/avg_final_rewards":0.3848,"loss/avg_raw_advantages":-0.0014,"loss/avg_raw_advantages_abs":0.0918,"policy/policy_entropy":0.1359,"policy/policy_loss":-0.0003,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0133,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.3848,"timing/step":1439.6074,"trainer/epoch":0}
+{"step":11,"async/staleness_mean":1.9062,"generate/avg_num_tokens":4465.0586,"generate/avg_tokens_non_zero_rewards":4697.9737,"generate/avg_tokens_zero_rewards":4213.2073,"generate/max_num_tokens":31776,"generate/std_num_tokens":4382.1066,"loss/avg_final_rewards":0.5195,"loss/avg_raw_advantages":-0.0057,"loss/avg_raw_advantages_abs":0.1603,"policy/policy_entropy":0.1193,"policy/policy_loss":-0.0036,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0164,"reward/avg_pass_at_8":0.6875,"reward/avg_raw_reward":0.5195,"timing/step":1156.4299,"trainer/epoch":0}
+{"step":12,"async/staleness_mean":2.0938,"generate/avg_num_tokens":5363.0527,"generate/avg_tokens_non_zero_rewards":4521.8653,"generate/avg_tokens_zero_rewards":5871.9843,"generate/max_num_tokens":31759,"generate/std_num_tokens":4307.6574,"loss/avg_final_rewards":0.377,"loss/avg_raw_advantages":-0.0043,"loss/avg_raw_advantages_abs":0.0705,"policy/policy_entropy":0.131,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0118,"reward/avg_pass_at_8":0.4375,"reward/avg_raw_reward":0.377,"timing/step":1280.5093,"trainer/epoch":0}
+{"step":13,"async/staleness_mean":1.8438,"generate/avg_num_tokens":5225.9648,"generate/avg_tokens_non_zero_rewards":4635.1852,"generate/avg_tokens_zero_rewards":5759.6431,"generate/max_num_tokens":31599,"generate/std_num_tokens":4392.6399,"loss/avg_final_rewards":0.4746,"loss/avg_raw_advantages":-0.0052,"loss/avg_raw_advantages_abs":0.0701,"policy/policy_entropy":0.1226,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0125,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.4746,"timing/step":1231.3013,"trainer/epoch":0}
+{"step":14,"async/staleness_mean":2.0625,"generate/avg_num_tokens":5098.8379,"generate/avg_tokens_non_zero_rewards":4982.8538,"generate/avg_tokens_zero_rewards":5218.504,"generate/max_num_tokens":31827,"generate/std_num_tokens":4200.4394,"loss/avg_final_rewards":0.5078,"loss/avg_raw_advantages":0.0053,"loss/avg_raw_advantages_abs":0.1294,"policy/policy_entropy":0.1213,"policy/policy_loss":-0.0029,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.015,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.5078,"timing/step":1253.8114,"trainer/epoch":0}
+{"step":15,"async/staleness_mean":2.2031,"generate/avg_num_tokens":5303.2578,"generate/avg_tokens_non_zero_rewards":4787.0615,"generate/avg_tokens_zero_rewards":5620.7918,"generate/max_num_tokens":31595,"generate/std_num_tokens":4592.2823,"loss/avg_final_rewards":0.3809,"loss/avg_raw_advantages":-0.0098,"loss/avg_raw_advantages_abs":0.0731,"policy/policy_entropy":0.1345,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0103,"reward/avg_pass_at_8":0.4688,"reward/avg_raw_reward":0.3809,"timing/step":1160.9981,"trainer/epoch":0}
+{"step":16,"async/staleness_mean":2.125,"generate/avg_num_tokens":5503.4707,"generate/avg_tokens_non_zero_rewards":4714.2294,"generate/avg_tokens_zero_rewards":6152.2776,"generate/max_num_tokens":31683,"generate/std_num_tokens":4822.9636,"loss/avg_final_rewards":0.4512,"loss/avg_raw_advantages":-0.0046,"loss/avg_raw_advantages_abs":0.0667,"policy/policy_entropy":0.1228,"policy/policy_loss":-0.0006,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0114,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.4512,"timing/step":1198.5693,"trainer/epoch":0}
+{"step":17,"async/staleness_mean":2.1406,"generate/avg_num_tokens":4977.7129,"generate/avg_tokens_non_zero_rewards":4686.6981,"generate/avg_tokens_zero_rewards":5183.3633,"generate/max_num_tokens":31791,"generate/std_num_tokens":4497.3766,"loss/avg_final_rewards":0.4141,"loss/avg_raw_advantages":0.0027,"loss/avg_raw_advantages_abs":0.1366,"policy/policy_entropy":0.1268,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0162,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.4141,"timing/step":1324.8522,"trainer/epoch":0}
+{"step":18,"async/staleness_mean":2.3594,"generate/avg_num_tokens":4896.666,"generate/avg_tokens_non_zero_rewards":4869.7656,"generate/avg_tokens_zero_rewards":4912.8062,"generate/max_num_tokens":31713,"generate/std_num_tokens":3970.0096,"loss/avg_final_rewards":0.375,"loss/avg_raw_advantages":0.0047,"loss/avg_raw_advantages_abs":0.1314,"policy/policy_entropy":0.1218,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0168,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.375,"timing/step":1196.595,"trainer/epoch":0}
+{"step":19,"async/staleness_mean":2.2656,"generate/avg_num_tokens":5069.6445,"generate/avg_tokens_non_zero_rewards":5041.7042,"generate/avg_tokens_zero_rewards":5089.5485,"generate/max_num_tokens":31746,"generate/std_num_tokens":4326.0408,"loss/avg_final_rewards":0.416,"loss/avg_raw_advantages":0.0035,"loss/avg_raw_advantages_abs":0.0926,"policy/policy_entropy":0.1361,"policy/policy_loss":-0.0053,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0128,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.416,"timing/step":2034.4556,"trainer/epoch":0}
+{"step":20,"async/staleness_mean":1.8281,"generate/avg_num_tokens":4947.582,"generate/avg_tokens_non_zero_rewards":4791.9533,"generate/avg_tokens_zero_rewards":5059.3423,"generate/max_num_tokens":31736,"generate/std_num_tokens":3768.1089,"loss/avg_final_rewards":0.418,"loss/avg_raw_advantages":-0.01,"loss/avg_raw_advantages_abs":0.1096,"policy/policy_entropy":0.1296,"policy/policy_loss":-0.0027,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0157,"reward/avg_pass_at_8":0.5469,"reward/avg_raw_reward":0.418,"timing/step":1215.6439,"trainer/epoch":0}
+{"step":21,"async/staleness_mean":0.1094,"generate/avg_num_tokens":4881.0703,"generate/avg_tokens_non_zero_rewards":4619.1404,"generate/avg_tokens_zero_rewards":5209.9251,"generate/max_num_tokens":21809,"generate/std_num_tokens":3151.7318,"loss/avg_final_rewards":0.5566,"loss/avg_raw_advantages":0.0038,"loss/avg_raw_advantages_abs":0.0888,"policy/policy_entropy":0.1267,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.01,"reward/avg_pass_at_8":0.623,"reward/avg_raw_reward":0.5566,"timing/step":4128.171,"trainer/epoch":0}
+{"step":22,"async/staleness_mean":0.9531,"generate/avg_num_tokens":5270.2227,"generate/avg_tokens_non_zero_rewards":4899.0374,"generate/avg_tokens_zero_rewards":5368.2889,"generate/max_num_tokens":31764,"generate/std_num_tokens":5057.6621,"loss/avg_final_rewards":0.209,"loss/avg_raw_advantages":0.0119,"loss/avg_raw_advantages_abs":0.0484,"policy/policy_entropy":0.132,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0122,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.209,"timing/step":973.4908,"trainer/epoch":0}
+{"step":23,"async/staleness_mean":1.7344,"generate/avg_num_tokens":5478.166,"generate/avg_tokens_non_zero_rewards":5498.642,"generate/avg_tokens_zero_rewards":5467.4405,"generate/max_num_tokens":31775,"generate/std_num_tokens":5485.7275,"loss/avg_final_rewards":0.3438,"loss/avg_raw_advantages":-0.0068,"loss/avg_raw_advantages_abs":0.152,"policy/policy_entropy":0.1245,"policy/policy_loss":-0.0016,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0152,"reward/avg_pass_at_8":0.5469,"reward/avg_raw_reward":0.3438,"timing/step":784.2654,"trainer/epoch":0}
+{"step":24,"async/staleness_mean":1.6406,"generate/avg_num_tokens":4716.4082,"generate/avg_tokens_non_zero_rewards":4747.716,"generate/avg_tokens_zero_rewards":4684.8549,"generate/max_num_tokens":31777,"generate/std_num_tokens":4097.8926,"loss/avg_final_rewards":0.502,"loss/avg_raw_advantages":0.0004,"loss/avg_raw_advantages_abs":0.1541,"policy/policy_entropy":0.114,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0134,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.502,"timing/step":1437.2086,"trainer/epoch":0}
+{"step":25,"async/staleness_mean":1.4375,"generate/avg_num_tokens":4553.209,"generate/avg_tokens_non_zero_rewards":4195.6736,"generate/avg_tokens_zero_rewards":5012.8973,"generate/max_num_tokens":31787,"generate/std_num_tokens":3536.9931,"loss/avg_final_rewards":0.5625,"loss/avg_raw_advantages":-0.0032,"loss/avg_raw_advantages_abs":0.0728,"policy/policy_entropy":0.118,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0145,"reward/avg_pass_at_8":0.6562,"reward/avg_raw_reward":0.5625,"timing/step":999.0684,"trainer/epoch":0}
+{"step":26,"async/staleness_mean":2.2812,"generate/avg_num_tokens":5104.5664,"generate/avg_tokens_non_zero_rewards":4828.5526,"generate/avg_tokens_zero_rewards":5326.1549,"generate/max_num_tokens":31736,"generate/std_num_tokens":4746.2648,"loss/avg_final_rewards":0.4453,"loss/avg_raw_advantages":0.001,"loss/avg_raw_advantages_abs":0.0947,"policy/policy_entropy":0.118,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0112,"reward/avg_pass_at_8":0.5469,"reward/avg_raw_reward":0.4453,"timing/step":878.2187,"trainer/epoch":0}
+{"step":27,"async/staleness_mean":2.2656,"generate/avg_num_tokens":4773.3457,"generate/avg_tokens_non_zero_rewards":4676.4102,"generate/avg_tokens_zero_rewards":4870.2812,"generate/max_num_tokens":31628,"generate/std_num_tokens":3592.542,"loss/avg_final_rewards":0.5,"loss/avg_raw_advantages":-0.0004,"loss/avg_raw_advantages_abs":0.0708,"policy/policy_entropy":0.129,"policy/policy_loss":-0.0011,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0115,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.5,"timing/step":932.2836,"trainer/epoch":0}
+{"step":28,"async/staleness_mean":2.1094,"generate/avg_num_tokens":5473.4512,"generate/avg_tokens_non_zero_rewards":5122.3896,"generate/avg_tokens_zero_rewards":5805.8251,"generate/max_num_tokens":31813,"generate/std_num_tokens":4291.0941,"loss/avg_final_rewards":0.4863,"loss/avg_raw_advantages":0.0135,"loss/avg_raw_advantages_abs":0.1157,"policy/policy_entropy":0.1245,"policy/policy_loss":-0.0042,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0123,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.4863,"timing/step":1119.2529,"trainer/epoch":0}
+{"step":29,"async/staleness_mean":2.5469,"generate/avg_num_tokens":5148.4551,"generate/avg_tokens_non_zero_rewards":4924.1006,"generate/avg_tokens_zero_rewards":5269.0541,"generate/max_num_tokens":31727,"generate/std_num_tokens":4432.698,"loss/avg_final_rewards":0.3496,"loss/avg_raw_advantages":0.0199,"loss/avg_raw_advantages_abs":0.1139,"policy/policy_entropy":0.1332,"policy/policy_loss":-0.0042,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0133,"reward/avg_pass_at_8":0.5,"reward/avg_raw_reward":0.3496,"timing/step":1315.1914,"trainer/epoch":0}
+{"step":30,"async/staleness_mean":2.0938,"generate/avg_num_tokens":5256.7539,"generate/avg_tokens_non_zero_rewards":4689.2149,"generate/avg_tokens_zero_rewards":5712.3838,"generate/max_num_tokens":31823,"generate/std_num_tokens":4880.1149,"loss/avg_final_rewards":0.4453,"loss/avg_raw_advantages":-0.0006,"loss/avg_raw_advantages_abs":0.1078,"policy/policy_entropy":0.1216,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0131,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.4453,"timing/step":1126.1993,"trainer/epoch":0}
+{"step":31,"async/staleness_mean":2.1562,"generate/avg_num_tokens":5447.8008,"generate/avg_tokens_non_zero_rewards":4882.6652,"generate/avg_tokens_zero_rewards":5876.9931,"generate/max_num_tokens":31794,"generate/std_num_tokens":5373.6525,"loss/avg_final_rewards":0.4316,"loss/avg_raw_advantages":0.0119,"loss/avg_raw_advantages_abs":0.1249,"policy/policy_entropy":0.1187,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0128,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.4316,"timing/step":1135.5162,"trainer/epoch":0}
+{"step":32,"async/staleness_mean":2.1562,"generate/avg_num_tokens":5149.9277,"generate/avg_tokens_non_zero_rewards":4759.6182,"generate/avg_tokens_zero_rewards":5443.9966,"generate/max_num_tokens":31786,"generate/std_num_tokens":4760.0625,"loss/avg_final_rewards":0.4297,"loss/avg_raw_advantages":0.0053,"loss/avg_raw_advantages_abs":0.1298,"policy/policy_entropy":0.1244,"policy/policy_loss":-0.0042,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0193,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.4297,"timing/step":1412.6928,"trainer/epoch":0}
+{"step":33,"async/staleness_mean":2.0156,"generate/avg_num_tokens":4476.2832,"generate/avg_tokens_non_zero_rewards":4271.9141,"generate/avg_tokens_zero_rewards":4605.1529,"generate/max_num_tokens":31642,"generate/std_num_tokens":3530.384,"loss/avg_final_rewards":0.3867,"loss/avg_raw_advantages":-0.0015,"loss/avg_raw_advantages_abs":0.0917,"policy/policy_entropy":0.1288,"policy/policy_loss":-0.0003,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.013,"reward/avg_pass_at_8":0.5,"reward/avg_raw_reward":0.3867,"timing/step":1360.6217,"trainer/epoch":0}
+{"step":34,"async/staleness_mean":1.8438,"generate/avg_num_tokens":5241.541,"generate/avg_tokens_non_zero_rewards":4209.3825,"generate/avg_tokens_zero_rewards":5815.6596,"generate/max_num_tokens":31785,"generate/std_num_tokens":4688.0521,"loss/avg_final_rewards":0.3574,"loss/avg_raw_advantages":-0.0011,"loss/avg_raw_advantages_abs":0.0807,"policy/policy_entropy":0.1295,"policy/policy_loss":-0.002,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0098,"reward/avg_pass_at_8":0.4375,"reward/avg_raw_reward":0.3574,"timing/step":1222.0475,"trainer/epoch":0}
+{"step":35,"async/staleness_mean":1.9375,"generate/avg_num_tokens":4957.7051,"generate/avg_tokens_non_zero_rewards":4424.7014,"generate/avg_tokens_zero_rewards":5362.4948,"generate/max_num_tokens":31815,"generate/std_num_tokens":4909.2384,"loss/avg_final_rewards":0.4316,"loss/avg_raw_advantages":-0.0126,"loss/avg_raw_advantages_abs":0.151,"policy/policy_entropy":0.1185,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0168,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.4316,"timing/step":1206.7027,"trainer/epoch":0}
+{"step":36,"async/staleness_mean":2.2188,"generate/avg_num_tokens":5280.5957,"generate/avg_tokens_non_zero_rewards":5239.2991,"generate/avg_tokens_zero_rewards":5310.2517,"generate/max_num_tokens":31783,"generate/std_num_tokens":4369.8009,"loss/avg_final_rewards":0.418,"loss/avg_raw_advantages":0.0091,"loss/avg_raw_advantages_abs":0.1401,"policy/policy_entropy":0.1373,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0154,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.418,"timing/step":1319.1682,"trainer/epoch":0}
+{"step":37,"async/staleness_mean":1.875,"generate/avg_num_tokens":4702.6836,"generate/avg_tokens_non_zero_rewards":4466.1733,"generate/avg_tokens_zero_rewards":4981.4638,"generate/max_num_tokens":31828,"generate/std_num_tokens":3856.0146,"loss/avg_final_rewards":0.541,"loss/avg_raw_advantages":-0.0118,"loss/avg_raw_advantages_abs":0.1465,"policy/policy_entropy":0.1245,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0155,"reward/avg_pass_at_8":0.6719,"reward/avg_raw_reward":0.541,"timing/step":1191.7158,"trainer/epoch":0}
+{"step":38,"async/staleness_mean":1.9062,"generate/avg_num_tokens":4688.2715,"generate/avg_tokens_non_zero_rewards":4292.636,"generate/avg_tokens_zero_rewards":5136.6583,"generate/max_num_tokens":31757,"generate/std_num_tokens":4297.222,"loss/avg_final_rewards":0.5312,"loss/avg_raw_advantages":0.0092,"loss/avg_raw_advantages_abs":0.0646,"policy/policy_entropy":0.1179,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0114,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.5312,"timing/step":1120.233,"trainer/epoch":0}
+{"step":39,"async/staleness_mean":2.25,"generate/avg_num_tokens":5307.8359,"generate/avg_tokens_non_zero_rewards":5155.7417,"generate/avg_tokens_zero_rewards":5442.0368,"generate/max_num_tokens":31780,"generate/std_num_tokens":5012.0495,"loss/avg_final_rewards":0.4688,"loss/avg_raw_advantages":0.0029,"loss/avg_raw_advantages_abs":0.0985,"policy/policy_entropy":0.117,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0123,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.4688,"timing/step":1066.0668,"trainer/epoch":0}
+{"step":40,"async/staleness_mean":1.875,"generate/avg_num_tokens":4436.6641,"generate/avg_tokens_non_zero_rewards":4166.7167,"generate/avg_tokens_zero_rewards":4662.1039,"generate/max_num_tokens":31753,"generate/std_num_tokens":3999.5304,"loss/avg_final_rewards":0.4551,"loss/avg_raw_advantages":-0.0054,"loss/avg_raw_advantages_abs":0.0715,"policy/policy_entropy":0.1236,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0129,"reward/avg_pass_at_8":0.5469,"reward/avg_raw_reward":0.4551,"timing/step":1481.8178,"trainer/epoch":0}
+{"step":41,"async/staleness_mean":1.8438,"generate/avg_num_tokens":4542.9355,"generate/avg_tokens_non_zero_rewards":4035.5451,"generate/avg_tokens_zero_rewards":5004.8881,"generate/max_num_tokens":31718,"generate/std_num_tokens":4393.3637,"loss/avg_final_rewards":0.4766,"loss/avg_raw_advantages":0.0045,"loss/avg_raw_advantages_abs":0.1199,"policy/policy_entropy":0.1242,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0259,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.4766,"timing/step":1157.2234,"trainer/epoch":0}
+{"step":42,"async/staleness_mean":2.0156,"generate/avg_num_tokens":5080.5547,"generate/avg_tokens_non_zero_rewards":5164.2338,"generate/avg_tokens_zero_rewards":5026.4727,"generate/max_num_tokens":31811,"generate/std_num_tokens":4388.8504,"loss/avg_final_rewards":0.3926,"loss/avg_raw_advantages":0.0045,"loss/avg_raw_advantages_abs":0.0991,"policy/policy_entropy":0.1305,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0115,"reward/avg_pass_at_8":0.4688,"reward/avg_raw_reward":0.3926,"timing/step":1086.2825,"trainer/epoch":0}
+{"step":43,"async/staleness_mean":1.6875,"generate/avg_num_tokens":4376.7949,"generate/avg_tokens_non_zero_rewards":4072.7086,"generate/avg_tokens_zero_rewards":4738.0598,"generate/max_num_tokens":31719,"generate/std_num_tokens":4099.6547,"loss/avg_final_rewards":0.543,"loss/avg_raw_advantages":0.004,"loss/avg_raw_advantages_abs":0.0827,"policy/policy_entropy":0.1201,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0099,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.543,"timing/step":1205.4114,"trainer/epoch":0}
+{"step":44,"async/staleness_mean":1.7969,"generate/avg_num_tokens":5107.6914,"generate/avg_tokens_non_zero_rewards":4460.8762,"generate/avg_tokens_zero_rewards":5529.1645,"generate/max_num_tokens":31857,"generate/std_num_tokens":4652.3757,"loss/avg_final_rewards":0.3945,"loss/avg_raw_advantages":0.0099,"loss/avg_raw_advantages_abs":0.1185,"policy/policy_entropy":0.1249,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0144,"reward/avg_pass_at_8":0.5156,"reward/avg_raw_reward":0.3945,"timing/step":980.7355,"trainer/epoch":0}
+{"step":45,"async/staleness_mean":2.3594,"generate/avg_num_tokens":4768.9492,"generate/avg_tokens_non_zero_rewards":4444.9615,"generate/avg_tokens_zero_rewards":5103.2222,"generate/max_num_tokens":31722,"generate/std_num_tokens":3864.159,"loss/avg_final_rewards":0.5078,"loss/avg_raw_advantages":-0.0016,"loss/avg_raw_advantages_abs":0.1191,"policy/policy_entropy":0.1323,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0142,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.5078,"timing/step":1139.241,"trainer/epoch":0}
+{"step":46,"async/staleness_mean":2.1406,"generate/avg_num_tokens":4766.8594,"generate/avg_tokens_non_zero_rewards":4459.6325,"generate/avg_tokens_zero_rewards":5025.4604,"generate/max_num_tokens":31694,"generate/std_num_tokens":3772.8036,"loss/avg_final_rewards":0.457,"loss/avg_raw_advantages":0.0014,"loss/avg_raw_advantages_abs":0.0708,"policy/policy_entropy":0.1301,"policy/policy_loss":-0.0017,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0122,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.457,"timing/step":996.6627,"trainer/epoch":0}
+{"step":47,"async/staleness_mean":2.2812,"generate/avg_num_tokens":4696.0488,"generate/avg_tokens_non_zero_rewards":4467.2452,"generate/avg_tokens_zero_rewards":4933.9681,"generate/max_num_tokens":31741,"generate/std_num_tokens":3822.6237,"loss/avg_final_rewards":0.5098,"loss/avg_raw_advantages":0.0086,"loss/avg_raw_advantages_abs":0.1125,"policy/policy_entropy":0.1265,"policy/policy_loss":-0.0018,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0132,"reward/avg_pass_at_8":0.5938,"reward/avg_raw_reward":0.5098,"timing/step":1240.2406,"trainer/epoch":0}
+{"step":48,"async/staleness_mean":2.125,"generate/avg_num_tokens":4586.2266,"generate/avg_tokens_non_zero_rewards":4308.5578,"generate/avg_tokens_zero_rewards":4762.7636,"generate/max_num_tokens":31792,"generate/std_num_tokens":3798.6281,"loss/avg_final_rewards":0.3887,"loss/avg_raw_advantages":-0.0035,"loss/avg_raw_advantages_abs":0.0731,"policy/policy_entropy":0.1356,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0134,"reward/avg_pass_at_8":0.5469,"reward/avg_raw_reward":0.3887,"timing/step":1163.4312,"trainer/epoch":0}
+{"step":49,"async/staleness_mean":1.9375,"generate/avg_num_tokens":4732.1387,"generate/avg_tokens_non_zero_rewards":3860.716,"generate/avg_tokens_zero_rewards":5519.3346,"generate/max_num_tokens":31737,"generate/std_num_tokens":4044.3982,"loss/avg_final_rewards":0.4746,"loss/avg_raw_advantages":0.0099,"loss/avg_raw_advantages_abs":0.1,"policy/policy_entropy":0.1271,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0118,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.4746,"timing/step":1178.3931,"trainer/epoch":0}
+{"step":50,"async/staleness_mean":1.9844,"generate/avg_num_tokens":4752.7832,"generate/avg_tokens_non_zero_rewards":3984.8378,"generate/avg_tokens_zero_rewards":5187.2477,"generate/max_num_tokens":31754,"generate/std_num_tokens":4564.5581,"loss/avg_final_rewards":0.3613,"loss/avg_raw_advantages":0.0104,"loss/avg_raw_advantages_abs":0.0732,"policy/policy_entropy":0.1246,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0142,"reward/avg_pass_at_8":0.4531,"reward/avg_raw_reward":0.3613,"timing/step":1369.6342,"trainer/epoch":0}
+{"step":51,"async/staleness_mean":2.0,"generate/avg_num_tokens":4994.0371,"generate/avg_tokens_non_zero_rewards":4122.0166,"generate/avg_tokens_zero_rewards":5470.8822,"generate/max_num_tokens":31799,"generate/std_num_tokens":4809.8043,"loss/avg_final_rewards":0.3535,"loss/avg_raw_advantages":0.007,"loss/avg_raw_advantages_abs":0.088,"policy/policy_entropy":0.1301,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0112,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.3535,"timing/step":1317.2383,"trainer/epoch":0}
+{"step":52,"async/staleness_mean":1.8594,"generate/avg_num_tokens":4473.2402,"generate/avg_tokens_non_zero_rewards":4444.8734,"generate/avg_tokens_zero_rewards":4496.1943,"generate/max_num_tokens":31718,"generate/std_num_tokens":4204.3242,"loss/avg_final_rewards":0.4473,"loss/avg_raw_advantages":-0.0028,"loss/avg_raw_advantages_abs":0.1468,"policy/policy_entropy":0.1284,"policy/policy_loss":-0.0016,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.015,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.4473,"timing/step":1203.2679,"trainer/epoch":0}
+{"step":53,"async/staleness_mean":0.5156,"generate/avg_num_tokens":5199.4434,"generate/avg_tokens_non_zero_rewards":4615.7731,"generate/avg_tokens_zero_rewards":5706.427,"generate/max_num_tokens":19708,"generate/std_num_tokens":3413.6197,"loss/avg_final_rewards":0.4648,"loss/avg_raw_advantages":0.0013,"loss/avg_raw_advantages_abs":0.1057,"policy/policy_entropy":0.137,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0141,"reward/avg_pass_at_8":0.5556,"reward/avg_raw_reward":0.4648,"timing/step":4341.8808,"trainer/epoch":0}
+{"step":54,"async/staleness_mean":1.0,"generate/avg_num_tokens":4652.5859,"generate/avg_tokens_non_zero_rewards":4194.3092,"generate/avg_tokens_zero_rewards":4846.0806,"generate/max_num_tokens":31805,"generate/std_num_tokens":4709.4531,"loss/avg_final_rewards":0.2969,"loss/avg_raw_advantages":-0.0034,"loss/avg_raw_advantages_abs":0.1147,"policy/policy_entropy":0.1323,"policy/policy_loss":-0.0011,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0166,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.2969,"timing/step":865.4975,"trainer/epoch":0}
+{"step":55,"async/staleness_mean":1.6875,"generate/avg_num_tokens":4469.4453,"generate/avg_tokens_non_zero_rewards":4121.8427,"generate/avg_tokens_zero_rewards":4654.6946,"generate/max_num_tokens":31781,"generate/std_num_tokens":4099.3488,"loss/avg_final_rewards":0.3477,"loss/avg_raw_advantages":0.0009,"loss/avg_raw_advantages_abs":0.0838,"policy/policy_entropy":0.1244,"policy/policy_loss":-0.0033,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0124,"reward/avg_pass_at_8":0.4375,"reward/avg_raw_reward":0.3477,"timing/step":891.5335,"trainer/epoch":0}
+{"step":56,"async/staleness_mean":1.8281,"generate/avg_num_tokens":4797.8691,"generate/avg_tokens_non_zero_rewards":4535.0826,"generate/avg_tokens_zero_rewards":5033.4037,"generate/max_num_tokens":31839,"generate/std_num_tokens":4085.0137,"loss/avg_final_rewards":0.4727,"loss/avg_raw_advantages":-0.004,"loss/avg_raw_advantages_abs":0.0812,"policy/policy_entropy":0.1286,"policy/policy_loss":-0.0022,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0124,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.4727,"timing/step":1874.4506,"trainer/epoch":0}
+{"step":57,"async/staleness_mean":1.9531,"generate/avg_num_tokens":4748.166,"generate/avg_tokens_non_zero_rewards":4372.1198,"generate/avg_tokens_zero_rewards":5024.7831,"generate/max_num_tokens":31734,"generate/std_num_tokens":4589.3974,"loss/avg_final_rewards":0.4238,"loss/avg_raw_advantages":-0.019,"loss/avg_raw_advantages_abs":0.1613,"policy/policy_entropy":0.1205,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0158,"reward/avg_pass_at_8":0.5781,"reward/avg_raw_reward":0.4238,"timing/step":1421.3428,"trainer/epoch":0}
+{"step":58,"async/staleness_mean":2.0156,"generate/avg_num_tokens":4414.9258,"generate/avg_tokens_non_zero_rewards":4027.8325,"generate/avg_tokens_zero_rewards":4681.9307,"generate/max_num_tokens":31744,"generate/std_num_tokens":4331.3861,"loss/avg_final_rewards":0.4082,"loss/avg_raw_advantages":0.02,"loss/avg_raw_advantages_abs":0.0943,"policy/policy_entropy":0.1266,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0086,"reward/avg_pass_at_8":0.5,"reward/avg_raw_reward":0.4082,"timing/step":1211.3842,"trainer/epoch":0}
+{"step":59,"async/staleness_mean":1.5469,"generate/avg_num_tokens":4602.1758,"generate/avg_tokens_non_zero_rewards":4262.5259,"generate/avg_tokens_zero_rewards":4981.124,"generate/max_num_tokens":31779,"generate/std_num_tokens":3628.5089,"loss/avg_final_rewards":0.5273,"loss/avg_raw_advantages":-0.0044,"loss/avg_raw_advantages_abs":0.0806,"policy/policy_entropy":0.1288,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0116,"reward/avg_pass_at_8":0.625,"reward/avg_raw_reward":0.5273,"timing/step":1271.1443,"trainer/epoch":0}
+{"step":60,"async/staleness_mean":2.125,"generate/avg_num_tokens":5046.2031,"generate/avg_tokens_non_zero_rewards":4003.8878,"generate/avg_tokens_zero_rewards":5742.2117,"generate/max_num_tokens":31794,"generate/std_num_tokens":4683.5018,"loss/avg_final_rewards":0.4004,"loss/avg_raw_advantages":-0.0136,"loss/avg_raw_advantages_abs":0.1153,"policy/policy_entropy":0.1261,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0149,"reward/avg_pass_at_8":0.5156,"reward/avg_raw_reward":0.4004,"timing/step":1231.3773,"trainer/epoch":0}
+{"step":61,"async/staleness_mean":2.0312,"generate/avg_num_tokens":4474.1406,"generate/avg_tokens_non_zero_rewards":4349.8018,"generate/avg_tokens_zero_rewards":4573.1754,"generate/max_num_tokens":31577,"generate/std_num_tokens":4069.0396,"loss/avg_final_rewards":0.4434,"loss/avg_raw_advantages":0.0248,"loss/avg_raw_advantages_abs":0.1317,"policy/policy_entropy":0.1278,"policy/policy_loss":-0.0033,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0172,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.4434,"timing/step":941.3057,"trainer/epoch":0}
+{"step":62,"async/staleness_mean":1.9688,"generate/avg_num_tokens":4016.3633,"generate/avg_tokens_non_zero_rewards":3720.6367,"generate/avg_tokens_zero_rewards":4367.6966,"generate/max_num_tokens":31692,"generate/std_num_tokens":3405.5035,"loss/avg_final_rewards":0.543,"loss/avg_raw_advantages":-0.0101,"loss/avg_raw_advantages_abs":0.087,"policy/policy_entropy":0.122,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0129,"reward/avg_pass_at_8":0.6406,"reward/avg_raw_reward":0.543,"timing/step":906.4568,"trainer/epoch":0}
+{"step":63,"async/staleness_mean":2.2344,"generate/avg_num_tokens":4799.0352,"generate/avg_tokens_non_zero_rewards":4425.4542,"generate/avg_tokens_zero_rewards":5128.6654,"generate/max_num_tokens":31672,"generate/std_num_tokens":4411.6362,"loss/avg_final_rewards":0.4688,"loss/avg_raw_advantages":0.0048,"loss/avg_raw_advantages_abs":0.0778,"policy/policy_entropy":0.1212,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0132,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.4688,"timing/step":1291.3037,"trainer/epoch":0}
+{"step":64,"async/staleness_mean":2.2188,"generate/avg_num_tokens":4530.0508,"generate/avg_tokens_non_zero_rewards":4097.4039,"generate/avg_tokens_zero_rewards":4814.2816,"generate/max_num_tokens":31839,"generate/std_num_tokens":3885.326,"loss/avg_final_rewards":0.3965,"loss/avg_raw_advantages":0.0035,"loss/avg_raw_advantages_abs":0.0729,"policy/policy_entropy":0.1266,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0113,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.3965,"timing/step":1254.7905,"trainer/epoch":0}
+{"step":65,"async/staleness_mean":1.9219,"generate/avg_num_tokens":4867.0156,"generate/avg_tokens_non_zero_rewards":4570.0317,"generate/avg_tokens_zero_rewards":5092.5601,"generate/max_num_tokens":31738,"generate/std_num_tokens":5141.2786,"loss/avg_final_rewards":0.4316,"loss/avg_raw_advantages":-0.0013,"loss/avg_raw_advantages_abs":0.08,"policy/policy_entropy":0.1177,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0109,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.4316,"timing/step":1262.3508,"trainer/epoch":0}
+{"step":66,"async/staleness_mean":1.9531,"generate/avg_num_tokens":4835.3867,"generate/avg_tokens_non_zero_rewards":4683.6935,"generate/avg_tokens_zero_rewards":4931.8307,"generate/max_num_tokens":31768,"generate/std_num_tokens":4588.801,"loss/avg_final_rewards":0.3887,"loss/avg_raw_advantages":0.0186,"loss/avg_raw_advantages_abs":0.1044,"policy/policy_entropy":0.129,"policy/policy_loss":-0.0029,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0383,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.3887,"timing/step":1226.6652,"trainer/epoch":0}
+{"step":67,"async/staleness_mean":2.1406,"generate/avg_num_tokens":4859.6602,"generate/avg_tokens_non_zero_rewards":4760.3577,"generate/avg_tokens_zero_rewards":4951.4962,"generate/max_num_tokens":31778,"generate/std_num_tokens":4213.4389,"loss/avg_final_rewards":0.4805,"loss/avg_raw_advantages":0.0169,"loss/avg_raw_advantages_abs":0.1201,"policy/policy_entropy":0.1157,"policy/policy_loss":-0.002,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0143,"reward/avg_pass_at_8":0.625,"reward/avg_raw_reward":0.4805,"timing/step":1502.8795,"trainer/epoch":0}
+{"step":68,"async/staleness_mean":2.0625,"generate/avg_num_tokens":4823.1309,"generate/avg_tokens_non_zero_rewards":3819.7772,"generate/avg_tokens_zero_rewards":5476.929,"generate/max_num_tokens":31747,"generate/std_num_tokens":4682.8852,"loss/avg_final_rewards":0.3945,"loss/avg_raw_advantages":-0.003,"loss/avg_raw_advantages_abs":0.0765,"policy/policy_entropy":0.1258,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0111,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.3945,"timing/step":1347.7896,"trainer/epoch":0}
+{"step":69,"async/staleness_mean":2.0625,"generate/avg_num_tokens":4802.7988,"generate/avg_tokens_non_zero_rewards":4466.5288,"generate/avg_tokens_zero_rewards":5032.8783,"generate/max_num_tokens":31776,"generate/std_num_tokens":4001.0803,"loss/avg_final_rewards":0.4062,"loss/avg_raw_advantages":0.0129,"loss/avg_raw_advantages_abs":0.0779,"policy/policy_entropy":0.1312,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0104,"reward/avg_pass_at_8":0.5312,"reward/avg_raw_reward":0.4062,"timing/step":1173.5764,"trainer/epoch":0}
+{"step":70,"async/staleness_mean":1.9844,"generate/avg_num_tokens":4320.1016,"generate/avg_tokens_non_zero_rewards":3786.6414,"generate/avg_tokens_zero_rewards":4833.1226,"generate/max_num_tokens":31673,"generate/std_num_tokens":4150.9558,"loss/avg_final_rewards":0.4902,"loss/avg_raw_advantages":0.0049,"loss/avg_raw_advantages_abs":0.1045,"policy/policy_entropy":0.1204,"policy/policy_loss":-0.0007,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0155,"reward/avg_pass_at_8":0.6094,"reward/avg_raw_reward":0.4902,"timing/step":982.2804,"trainer/epoch":0}
+{"step":71,"async/staleness_mean":1.9844,"generate/avg_num_tokens":4748.3926,"generate/avg_tokens_non_zero_rewards":4197.352,"generate/avg_tokens_zero_rewards":5044.5976,"generate/max_num_tokens":31719,"generate/std_num_tokens":4557.159,"loss/avg_final_rewards":0.3496,"loss/avg_raw_advantages":-0.006,"loss/avg_raw_advantages_abs":0.0866,"policy/policy_entropy":0.1196,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0111,"reward/avg_pass_at_8":0.4375,"reward/avg_raw_reward":0.3496,"timing/step":1222.2327,"trainer/epoch":0}
+{"step":72,"async/staleness_mean":2.1562,"generate/avg_num_tokens":4384.8965,"generate/avg_tokens_non_zero_rewards":4009.738,"generate/avg_tokens_zero_rewards":4688.47,"generate/max_num_tokens":31676,"generate/std_num_tokens":3724.2524,"loss/avg_final_rewards":0.4473,"loss/avg_raw_advantages":-0.0023,"loss/avg_raw_advantages_abs":0.1007,"policy/policy_entropy":0.1237,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0121,"reward/avg_pass_at_8":0.5156,"reward/avg_raw_reward":0.4473,"timing/step":1228.542,"trainer/epoch":0}
+{"step":73,"async/staleness_mean":2.1719,"generate/avg_num_tokens":4876.4766,"generate/avg_tokens_non_zero_rewards":4516.1187,"generate/avg_tokens_zero_rewards":5145.8225,"generate/max_num_tokens":31688,"generate/std_num_tokens":4021.3811,"loss/avg_final_rewards":0.4277,"loss/avg_raw_advantages":-0.0084,"loss/avg_raw_advantages_abs":0.0792,"policy/policy_entropy":0.1229,"policy/policy_loss":-0.0017,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0115,"reward/avg_pass_at_8":0.5156,"reward/avg_raw_reward":0.4277,"timing/step":1018.1799,"trainer/epoch":0}
+{"step":74,"async/staleness_mean":2.3281,"generate/avg_num_tokens":4804.1309,"generate/avg_tokens_non_zero_rewards":4542.4787,"generate/avg_tokens_zero_rewards":4955.9537,"generate/max_num_tokens":31743,"generate/std_num_tokens":4592.2684,"loss/avg_final_rewards":0.3672,"loss/avg_raw_advantages":0.0062,"loss/avg_raw_advantages_abs":0.1369,"policy/policy_entropy":0.1199,"policy/policy_loss":-0.0033,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.017,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.3672,"timing/step":1390.0971,"trainer/epoch":0}
+{"step":75,"async/staleness_mean":2.5156,"generate/avg_num_tokens":4587.1035,"generate/avg_tokens_non_zero_rewards":4325.1543,"generate/avg_tokens_zero_rewards":4739.0988,"generate/max_num_tokens":31723,"generate/std_num_tokens":4230.4597,"loss/avg_final_rewards":0.3672,"loss/avg_raw_advantages":0.0006,"loss/avg_raw_advantages_abs":0.0935,"policy/policy_entropy":0.1223,"policy/policy_loss":-0.0042,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0152,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.3672,"timing/step":1209.4139,"trainer/epoch":0}
+{"step":76,"async/staleness_mean":3.0938,"generate/avg_num_tokens":4055.0,"generate/avg_tokens_non_zero_rewards":4114.375,"generate/avg_tokens_zero_rewards":4021.6921,"generate/max_num_tokens":31784,"generate/std_num_tokens":3911.3755,"loss/avg_final_rewards":0.3594,"loss/avg_raw_advantages":0.0034,"loss/avg_raw_advantages_abs":0.1224,"policy/policy_entropy":0.1159,"policy/policy_loss":-0.0039,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0131,"reward/avg_pass_at_8":0.4844,"reward/avg_raw_reward":0.3594,"timing/step":2079.0748,"trainer/epoch":0}
+{"step":77,"async/staleness_mean":1.125,"generate/avg_num_tokens":4684.8711,"generate/avg_tokens_non_zero_rewards":4627.4862,"generate/avg_tokens_zero_rewards":4716.2508,"generate/max_num_tokens":29309,"generate/std_num_tokens":3669.1501,"loss/avg_final_rewards":0.3535,"loss/avg_raw_advantages":-0.0044,"loss/avg_raw_advantages_abs":0.0207,"policy/policy_entropy":0.1248,"policy/policy_loss":-0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0043,"reward/avg_pass_at_8":0.3962,"reward/avg_raw_reward":0.3535,"timing/step":4232.7558,"trainer/epoch":0}
+{"step":78,"async/staleness_mean":1.0,"generate/avg_num_tokens":5120.0469,"generate/avg_tokens_non_zero_rewards":6577.6081,"generate/avg_tokens_zero_rewards":4873.7922,"generate/max_num_tokens":26429,"generate/std_num_tokens":4703.8288,"loss/avg_final_rewards":0.1445,"loss/avg_raw_advantages":0.0011,"loss/avg_raw_advantages_abs":0.1266,"policy/policy_entropy":0.1302,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0133,"reward/avg_pass_at_8":0.2969,"reward/avg_raw_reward":0.1445,"timing/step":1225.2097,"trainer/epoch":0}
+{"step":79,"async/staleness_mean":0.0,"generate/avg_num_tokens":3803.4238,"generate/avg_tokens_non_zero_rewards":3557.0632,"generate/avg_tokens_zero_rewards":4512.6439,"generate/max_num_tokens":23523,"generate/std_num_tokens":2552.2554,"loss/avg_final_rewards":0.7422,"loss/avg_raw_advantages":-0.0062,"loss/avg_raw_advantages_abs":0.083,"policy/policy_entropy":0.114,"policy/policy_loss":0.0,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.1022,"reward/avg_pass_at_8":0.7969,"reward/avg_raw_reward":0.7422,"timing/step":2217.0772,"trainer/epoch":1}
+{"step":80,"async/staleness_mean":0.75,"generate/avg_num_tokens":4761.9473,"generate/avg_tokens_non_zero_rewards":4151.458,"generate/avg_tokens_zero_rewards":5534.5133,"generate/max_num_tokens":31689,"generate/std_num_tokens":3837.8046,"loss/avg_final_rewards":0.5586,"loss/avg_raw_advantages":0.0217,"loss/avg_raw_advantages_abs":0.098,"policy/policy_entropy":0.1188,"policy/policy_loss":-0.0006,"policy/ppo_clip_ratio":0.0,"policy/raw_grad_norm":0.0114,"reward/avg_pass_at_8":0.6719,"reward/avg_raw_reward":0.5586,"timing/step":2250.5857,"trainer/epoch":1}
diff --git a/viewer/build/inputs/marin/runs/marin-a3-pymethods2test-large/run.json b/viewer/build/inputs/marin/runs/marin-a3-pymethods2test-large/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..bcba157cda8c0b3c00be8ece820e1eff1476154a
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-a3-pymethods2test-large/run.json
@@ -0,0 +1,27 @@
+{
+ "id": "marin-a3-pymethods2test-large",
+ "title": "A3 RLOO on exp_rpt_pymethods2test-large (Qwen3-8B agent)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/laion/a3-rl-DCAgent_exp_rpt_pymethods2test-large-80-8B/tree/main/training_logs",
+ "license": "apache-2.0",
+ "model": "laion/a3-rl-DCAgent_exp_rpt_pymethods2test-large-80-8B",
+ "base_model": "laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink",
+ "method": "RLOO-N (SkyRL, binary verifier reward)",
+ "dataset": "DCAgent/exp_rpt_pymethods2test-large",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-09-04T16:21:14Z",
+ "attempts": 0,
+ "note": "Marin A3 sweep (issue #6187): one RLOO-N run per training dataset from the same Qwen3-8B-derived SFT agent, here DCAgent/exp_rpt_pymethods2test-large; the issue calls it the paper hero dataset (0.74 reward, 0.83 pass@8 at step 80). Our copy has every logged step of the final lineage (7 resumed job segments, 2 superseded rows dropped), cut at step 80 because the model card says later steps are not part of the legitimate run. The issue concluded this binary-reward setup was uninformative about dataset utility.",
+ "metrics_map": {
+  "reward": "reward/avg_raw_reward",
+  "loss": "policy/policy_loss",
+  "entropy": "policy/policy_entropy",
+  "grad_norm": "policy/raw_grad_norm",
+  "response_length": "generate/avg_num_tokens"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr2/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr2/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..9b4cc0b3173671cbea7c5958c57fb9b772a7ea19
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr2/metrics.jsonl
@@ -0,0 +1,19 @@
+{"step":0,"val/pass_at_1":0.34375,"val/avg_score":0.341015625,"val/passed":44,"val/turn_cap_rate":0.0546875}
+{"step":1,"async/staleness_mean":0.0,"generate/avg_num_tokens":3169.005859375,"generate/avg_tokens_non_zero_rewards":3047.5511363636365,"generate/avg_tokens_zero_rewards":3232.625,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":16680,"generate/std_num_tokens":2301.8342443880583,"loss/avg_final_rewards":0.34208986163139343,"loss/avg_raw_advantages":-0.020328659564256668,"loss/avg_raw_advantages_abs":0.13818322122097015,"policy/policy_entropy":0.33798813761677593,"policy/policy_loss":0.0005956882123427931,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.020572011387230305,"policy/raw_grad_norm":0.144287109375,"reward/avg_pass_at_8":0.46875,"reward/avg_raw_reward":0.34208984374999996,"timing/step":1197.5906174411066,"trainer/epoch":0}
+{"step":2,"async/staleness_mean":1.0,"generate/avg_num_tokens":3110.166015625,"generate/avg_tokens_non_zero_rewards":3008.1951219512193,"generate/avg_tokens_zero_rewards":3204.46992481203,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":15321,"generate/std_num_tokens":2193.8297238401246,"loss/avg_final_rewards":0.4786132574081421,"loss/avg_raw_advantages":-0.02599477395415306,"loss/avg_raw_advantages_abs":0.15201282501220703,"policy/policy_entropy":0.23885099159087986,"policy/policy_loss":0.0007072385169522022,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.024321202359715244,"policy/raw_grad_norm":0.1138916015625,"reward/avg_pass_at_8":0.625,"reward/avg_raw_reward":0.4786132812499999,"timing/step":836.4066986110993,"trainer/epoch":0}
+{"step":3,"async/staleness_mean":1.9375,"generate/avg_num_tokens":3501.435546875,"generate/avg_tokens_non_zero_rewards":3145.368715083799,"generate/avg_tokens_zero_rewards":3692.834834834835,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":23355,"generate/std_num_tokens":2772.1238536379096,"loss/avg_final_rewards":0.34707027673721313,"loss/avg_raw_advantages":-0.024716880172491074,"loss/avg_raw_advantages_abs":0.17512236535549164,"policy/policy_entropy":0.1889580829301849,"policy/policy_loss":0.001008056457976636,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.036330787639599293,"policy/raw_grad_norm":0.236328125,"reward/avg_pass_at_8":0.546875,"reward/avg_raw_reward":0.3470703125,"timing/step":913.7465231099632,"trainer/epoch":0,"val/pass_at_1":0.359375,"val/avg_score":0.35234375,"val/passed":46,"val/turn_cap_rate":0.140625}
+{"step":4,"async/staleness_mean":1.75,"generate/avg_num_tokens":3881.056640625,"generate/avg_tokens_non_zero_rewards":3660.344680851064,"generate/avg_tokens_zero_rewards":4068.303249097473,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":18340,"generate/std_num_tokens":3362.801656821283,"loss/avg_final_rewards":0.4541015625,"loss/avg_raw_advantages":-0.02971545234322548,"loss/avg_raw_advantages_abs":0.12146639823913574,"policy/policy_entropy":0.11838510842062533,"policy/policy_loss":0.0006702039972878993,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.02975204315953306,"policy/raw_grad_norm":0.0953369140625,"reward/avg_pass_at_8":0.546875,"reward/avg_raw_reward":0.4541015625,"timing/step":889.9785334360786,"trainer/epoch":0}
+{"step":5,"async/staleness_mean":1.75,"generate/avg_num_tokens":5361.0859375,"generate/avg_tokens_non_zero_rewards":5343.271889400921,"generate/avg_tokens_zero_rewards":5374.189830508474,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":23187,"generate/std_num_tokens":4496.000063471946,"loss/avg_final_rewards":0.4136718511581421,"loss/avg_raw_advantages":-0.059510089457035065,"loss/avg_raw_advantages_abs":0.16911280155181885,"policy/policy_entropy":0.09194204691448249,"policy/policy_loss":0.0009682493318905472,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.022816467586380895,"policy/raw_grad_norm":0.13134765625,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.413671875,"timing/step":996.7525708028115,"trainer/epoch":0}
+{"step":6,"async/staleness_mean":1.5,"generate/avg_num_tokens":4458.87109375,"generate/avg_tokens_non_zero_rewards":4671.420560747663,"generate/avg_tokens_zero_rewards":4306.234899328859,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":19872,"generate/std_num_tokens":3870.8484321845617,"loss/avg_final_rewards":0.40693360567092896,"loss/avg_raw_advantages":-0.05148852616548538,"loss/avg_raw_advantages_abs":0.1130906492471695,"policy/policy_entropy":0.0621955449169036,"policy/policy_loss":0.0005404666471804376,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.02080482004384976,"policy/raw_grad_norm":0.0806884765625,"reward/avg_pass_at_8":0.46875,"reward/avg_raw_reward":0.40693359375,"timing/step":949.7337679369375,"trainer/epoch":0,"val/pass_at_1":0.359375,"val/avg_score":0.355078125,"val/passed":46,"val/turn_cap_rate":0.0859375}
+{"step":7,"async/staleness_mean":1.6875,"generate/avg_num_tokens":4579.322265625,"generate/avg_tokens_non_zero_rewards":4203.926829268293,"generate/avg_tokens_zero_rewards":4829.99348534202,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":20889,"generate/std_num_tokens":4123.921052034155,"loss/avg_final_rewards":0.38720703125,"loss/avg_raw_advantages":-0.05643348768353462,"loss/avg_raw_advantages_abs":0.10127931088209152,"policy/policy_entropy":0.05551820420078002,"policy/policy_loss":0.0003398132812435506,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.022684094990836456,"policy/raw_grad_norm":0.04833984375,"reward/avg_pass_at_8":0.421875,"reward/avg_raw_reward":0.38720703125,"timing/step":979.0248667930719,"trainer/epoch":0}
+{"step":8,"async/staleness_mean":1.671875,"generate/avg_num_tokens":3923.87109375,"generate/avg_tokens_non_zero_rewards":3488.4464285714284,"generate/avg_tokens_zero_rewards":4262.534722222223,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":22216,"generate/std_num_tokens":3455.0974664854866,"loss/avg_final_rewards":0.4271484315395355,"loss/avg_raw_advantages":-0.03237992152571678,"loss/avg_raw_advantages_abs":0.07515560835599899,"policy/policy_entropy":0.0504411113797687,"policy/policy_loss":0.00031748439323564526,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.020362420014862437,"policy/raw_grad_norm":0.0975341796875,"reward/avg_pass_at_8":0.484375,"reward/avg_raw_reward":0.4271484375,"timing/step":921.379292229889,"trainer/epoch":0}
+{"step":9,"async/staleness_mean":1.984375,"generate/avg_num_tokens":3512.30078125,"generate/avg_tokens_non_zero_rewards":3417.864077669903,"generate/avg_tokens_zero_rewards":3656.0492610837437,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":15068,"generate/std_num_tokens":3268.448468310215,"loss/avg_final_rewards":0.595703125,"loss/avg_raw_advantages":-0.01284950040280819,"loss/avg_raw_advantages_abs":0.06535952538251877,"policy/policy_entropy":0.050410433934303,"policy/policy_loss":0.00029762777739961166,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.012124416214646772,"policy/raw_grad_norm":0.0872802734375,"reward/avg_pass_at_8":0.640625,"reward/avg_raw_reward":0.595703125,"timing/step":877.7770353299566,"trainer/epoch":0,"val/pass_at_1":0.4375,"val/avg_score":0.435546875,"val/passed":56,"val/turn_cap_rate":0.0390625}
+{"step":10,"async/staleness_mean":1.984375,"generate/avg_num_tokens":3033.501953125,"generate/avg_tokens_non_zero_rewards":2860.9162995594716,"generate/avg_tokens_zero_rewards":3170.964912280702,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":18054,"generate/std_num_tokens":2950.8963812918246,"loss/avg_final_rewards":0.43867185711860657,"loss/avg_raw_advantages":-0.04082788899540901,"loss/avg_raw_advantages_abs":0.08856792747974396,"policy/policy_entropy":0.04837490466888994,"policy/policy_loss":0.00027923968082177453,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.010592285847451421,"policy/raw_grad_norm":0.077880859375,"reward/avg_pass_at_8":0.46875,"reward/avg_raw_reward":0.438671875,"timing/step":861.4091469449922,"trainer/epoch":0}
+{"step":11,"async/staleness_mean":2.0,"generate/avg_num_tokens":2887.61328125,"generate/avg_tokens_non_zero_rewards":2516.802197802198,"generate/avg_tokens_zero_rewards":3311.175732217573,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":16128,"generate/std_num_tokens":3032.386360269517,"loss/avg_final_rewards":0.5287109613418579,"loss/avg_raw_advantages":-0.03458466753363609,"loss/avg_raw_advantages_abs":0.07965916395187378,"policy/policy_entropy":0.047808086790610105,"policy/policy_loss":0.0002547272488300223,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.00924236840364756,"policy/raw_grad_norm":0.1026611328125,"reward/avg_pass_at_8":0.578125,"reward/avg_raw_reward":0.5287109375000001,"timing/step":865.8828692450188,"trainer/epoch":0}
+{"step":12,"async/staleness_mean":1.53125,"generate/avg_num_tokens":2202.90625,"generate/avg_tokens_non_zero_rewards":1955.3356401384083,"generate/avg_tokens_zero_rewards":2523.748878923767,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":15027,"generate/std_num_tokens":2255.361813363809,"loss/avg_final_rewards":0.561718761920929,"loss/avg_raw_advantages":-0.007593624293804169,"loss/avg_raw_advantages_abs":0.05278369411826134,"policy/policy_entropy":0.043530179289518856,"policy/policy_loss":0.00019258220800111303,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.006955705969630799,"policy/raw_grad_norm":0.0836181640625,"reward/avg_pass_at_8":0.59375,"reward/avg_raw_reward":0.56171875,"timing/step":812.169394148048,"trainer/epoch":0,"val/pass_at_1":0.4609375,"val/avg_score":0.460546875,"val/passed":59,"val/turn_cap_rate":0.0078125}
+{"step":13,"async/staleness_mean":1.578125,"generate/avg_num_tokens":2165.09765625,"generate/avg_tokens_non_zero_rewards":2050.3623188405795,"generate/avg_tokens_zero_rewards":2299.2796610169494,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":17296,"generate/std_num_tokens":2136.5049278832726,"loss/avg_final_rewards":0.5366211533546448,"loss/avg_raw_advantages":-0.04266875982284546,"loss/avg_raw_advantages_abs":0.08567553758621216,"policy/policy_entropy":0.03967576705326792,"policy/policy_loss":0.00019057253030041466,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.008383233656786615,"policy/raw_grad_norm":0.0908203125,"reward/avg_pass_at_8":0.578125,"reward/avg_raw_reward":0.53662109375,"timing/step":814.6181545020081,"trainer/epoch":0}
+{"step":14,"async/staleness_mean":1.578125,"generate/avg_num_tokens":1745.55078125,"generate/avg_tokens_non_zero_rewards":1616.888030888031,"generate/avg_tokens_zero_rewards":1877.2648221343873,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":16855,"generate/std_num_tokens":1625.8323124968222,"loss/avg_final_rewards":0.5048827528953552,"loss/avg_raw_advantages":-0.009111667983233929,"loss/avg_raw_advantages_abs":0.03608344867825508,"policy/policy_entropy":0.03488813224248588,"policy/policy_loss":0.0001153757903011865,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.004651798823942954,"policy/raw_grad_norm":0.077392578125,"reward/avg_pass_at_8":0.53125,"reward/avg_raw_reward":0.5048828125,"timing/step":790.6542232320644,"trainer/epoch":0}
+{"step":15,"async/staleness_mean":1.890625,"generate/avg_num_tokens":1611.859375,"generate/avg_tokens_non_zero_rewards":1367.7348484848485,"generate/avg_tokens_zero_rewards":1871.733870967742,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":16654,"generate/std_num_tokens":1608.4713943114932,"loss/avg_final_rewards":0.5148437023162842,"loss/avg_raw_advantages":-0.03163832798600197,"loss/avg_raw_advantages_abs":0.10191994160413742,"policy/policy_entropy":0.03233787130739074,"policy/policy_loss":0.00011077359067712678,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.004108040203391283,"policy/raw_grad_norm":0.076904296875,"reward/avg_pass_at_8":0.546875,"reward/avg_raw_reward":0.51484375,"timing/step":780.7512752939947,"trainer/epoch":0,"val/pass_at_1":0.4453125,"val/avg_score":0.441015625,"val/passed":57,"val/turn_cap_rate":0.0859375}
+{"step":16,"async/staleness_mean":1.734375,"generate/avg_num_tokens":1595.240234375,"generate/avg_tokens_non_zero_rewards":1433.0642570281125,"generate/avg_tokens_zero_rewards":1748.783269961977,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":13935,"generate/std_num_tokens":1060.3658543266188,"loss/avg_final_rewards":0.4862304627895355,"loss/avg_raw_advantages":-0.0023246118798851967,"loss/avg_raw_advantages_abs":0.029960589483380318,"policy/policy_entropy":0.03520431253127754,"policy/policy_loss":0.00010947280679829419,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0019810999947367236,"policy/raw_grad_norm":0.0634765625,"reward/avg_pass_at_8":0.53125,"reward/avg_raw_reward":0.48623046875,"timing/step":773.9093815900851,"trainer/epoch":0}
+{"step":17,"async/staleness_mean":1.734375,"generate/avg_num_tokens":2764.517578125,"generate/avg_tokens_non_zero_rewards":1756.5095785440612,"generate/avg_tokens_zero_rewards":3812.6852589641435,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":18960,"generate/std_num_tokens":3766.739370339553,"loss/avg_final_rewards":0.5052734613418579,"loss/avg_raw_advantages":-0.007282214239239693,"loss/avg_raw_advantages_abs":0.040688592940568924,"policy/policy_entropy":0.0449187800695654,"policy/policy_loss":8.809234077489236e-05,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.003578624970941746,"policy/raw_grad_norm":0.0391845703125,"reward/avg_pass_at_8":0.53125,"reward/avg_raw_reward":0.5052734375,"timing/step":926.391248482978,"trainer/epoch":0}
+{"step":18,"async/staleness_mean":1.703125,"generate/avg_num_tokens":2957.24609375,"generate/avg_tokens_non_zero_rewards":2089.0084388185655,"generate/avg_tokens_zero_rewards":3705.509090909091,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":19754,"generate/std_num_tokens":3817.2444236934994,"loss/avg_final_rewards":0.45839840173721313,"loss/avg_raw_advantages":-0.0050569092854857445,"loss/avg_raw_advantages_abs":0.0917782336473465,"policy/policy_entropy":0.045910545653896406,"policy/policy_loss":0.00015974731468304526,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.002598824180495285,"policy/raw_grad_norm":0.05810546875,"reward/avg_pass_at_8":0.5,"reward/avg_raw_reward":0.45839843750000003,"timing/step":965.5253673281986,"trainer/epoch":0,"val/pass_at_1":0.4296875,"val/avg_score":0.421875,"val/passed":55,"val/turn_cap_rate":0.15625}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr2/run.json b/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr2/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..3292e3d99124e7f60cac15c7efbee140145fd071
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr2/run.json
@@ -0,0 +1,29 @@
+{
+ "id": "marin-q3c-cal-agent-rloo-lr2",
+ "title": "Qwen3-Coder-30B-A3B RLOO on calendar agent (lr 2e-6)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/penfever/qwen3coder-calendar-agent-v49-lr2-step12/blob/main/training_logs/finelog.log",
+ "license": "unknown",
+ "model": "penfever/qwen3coder-calendar-agent-v49-lr2-step12",
+ "base_model": "Qwen/Qwen3-Coder-30B-A3B-Instruct",
+ "method": "RLOO-N (MarinSkyRL, asynchronous)",
+ "dataset": "open-thoughts/TaskTrove::laion__nemotron-gym-agent-calendar-v2",
+ "eval_suite": "fixed 128-task holdout (Harbor, pass@1 at temperature 0)",
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2026-09-02T21:21:18",
+ "updated_at": "2026-09-07T00:42:30Z",
+ "attempts": 0,
+ "note": "Marin Qwen3-Coder agentic data-source sweep (issue #8942), calendar agent source, recipe: asynchronous shaped RLOO-N, group 8, sequence-mean loss, DAPO disabled, lr 2e-6, max staleness 2. Training metrics are the per-step dicts the run mirrored to its log (1 attempt); val/* is the fixed 128-task holdout at checkpoints, with step 0 = the untrained base model on the same holdout. Marin found the holdout overlaps the training source, so the scores select configurations but are not clean generalization estimates.",
+ "metrics_map": {
+  "reward": "reward/avg_raw_reward",
+  "loss": "policy/policy_loss",
+  "entropy": "policy/policy_entropy",
+  "lr": "policy/policy_lr",
+  "grad_norm": "policy/raw_grad_norm",
+  "response_length": "generate/avg_num_tokens",
+  "eval:holdout_pass@1": "val/pass_at_1"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr4/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr4/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..7bf17bface60400b5819a7218233d8cae0b15488
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr4/metrics.jsonl
@@ -0,0 +1,15 @@
+{"step":0,"val/pass_at_1":0.34375,"val/avg_score":0.341015625,"val/passed":44,"val/turn_cap_rate":0.0546875}
+{"step":1,"async/staleness_mean":0.0,"generate/avg_num_tokens":3258.30078125,"generate/avg_tokens_non_zero_rewards":3009.4545454545455,"generate/avg_tokens_zero_rewards":3401.483076923077,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":15883,"generate/std_num_tokens":2412.092858973694,"loss/avg_final_rewards":0.36328125,"loss/avg_raw_advantages":-0.01877858117222786,"loss/avg_raw_advantages_abs":0.08647201210260391,"policy/policy_entropy":0.3429131949087605,"policy/policy_loss":0.0003610016692618956,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.02055206497425388,"policy/raw_grad_norm":0.097900390625,"reward/avg_pass_at_8":0.453125,"reward/avg_raw_reward":0.36328125,"timing/step":1314.7745120348409,"trainer/epoch":0}
+{"step":2,"async/staleness_mean":1.0,"generate/avg_num_tokens":3266.564453125,"generate/avg_tokens_non_zero_rewards":3232.5172413793102,"generate/avg_tokens_zero_rewards":3288.9320388349515,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":15455,"generate/std_num_tokens":2303.0115346342263,"loss/avg_final_rewards":0.3946288824081421,"loss/avg_raw_advantages":-0.03380077704787254,"loss/avg_raw_advantages_abs":0.1611316204071045,"policy/policy_entropy":0.1798987213987857,"policy/policy_loss":0.000882684250427701,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.033205747065949254,"policy/raw_grad_norm":0.135986328125,"reward/avg_pass_at_8":0.53125,"reward/avg_raw_reward":0.39462890625,"timing/step":861.3972484134138,"trainer/epoch":0}
+{"step":3,"async/staleness_mean":2.0,"generate/avg_num_tokens":3446.9453125,"generate/avg_tokens_non_zero_rewards":3192.1979695431473,"generate/avg_tokens_zero_rewards":3606.263492063492,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":14918,"generate/std_num_tokens":2464.671014933439,"loss/avg_final_rewards":0.3822265863418579,"loss/avg_raw_advantages":-0.012645360082387924,"loss/avg_raw_advantages_abs":0.15931321680545807,"policy/policy_entropy":0.1437556112650782,"policy/policy_loss":0.0009703533769425121,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.039731398748699576,"policy/raw_grad_norm":0.1630859375,"reward/avg_pass_at_8":0.53125,"reward/avg_raw_reward":0.3822265625,"timing/step":905.4366959445179,"trainer/epoch":0,"val/pass_at_1":0.4453125,"val/avg_score":0.444921875,"val/passed":57,"val/turn_cap_rate":0.0078125}
+{"step":4,"async/staleness_mean":1.984375,"generate/avg_num_tokens":2052.61328125,"generate/avg_tokens_non_zero_rewards":1818.5573770491803,"generate/avg_tokens_zero_rewards":2265.708955223881,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":17062,"generate/std_num_tokens":1431.3124777777766,"loss/avg_final_rewards":0.4754882752895355,"loss/avg_raw_advantages":-0.01460456196218729,"loss/avg_raw_advantages_abs":0.06350195407867432,"policy/policy_entropy":0.06603187214932404,"policy/policy_loss":0.00045276512628333876,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.00948260566292447,"policy/raw_grad_norm":0.07373046875,"reward/avg_pass_at_8":0.53125,"reward/avg_raw_reward":0.47548828125000003,"timing/step":780.4206026559696,"trainer/epoch":0}
+{"step":5,"async/staleness_mean":1.96875,"generate/avg_num_tokens":2265.8828125,"generate/avg_tokens_non_zero_rewards":2036.1479591836735,"generate/avg_tokens_zero_rewards":2408.3765822784812,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":13682,"generate/std_num_tokens":1643.0199953187089,"loss/avg_final_rewards":0.38115233182907104,"loss/avg_raw_advantages":-0.014263740740716457,"loss/avg_raw_advantages_abs":0.05251633748412132,"policy/policy_entropy":0.04388834274141118,"policy/policy_loss":0.00012059892196703004,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.01027956759207882,"policy/raw_grad_norm":0.06280517578125,"reward/avg_pass_at_8":0.40625,"reward/avg_raw_reward":0.38115234375,"timing/step":812.6122711673379,"trainer/epoch":0}
+{"step":6,"async/staleness_mean":1.96875,"generate/avg_num_tokens":1283.65234375,"generate/avg_tokens_non_zero_rewards":1190.7259786476868,"generate/avg_tokens_zero_rewards":1396.6926406926407,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":7890,"generate/std_num_tokens":505.5879083219671,"loss/avg_final_rewards":0.548632800579071,"loss/avg_raw_advantages":-0.0007544859545305371,"loss/avg_raw_advantages_abs":0.0035512458998709917,"policy/policy_entropy":0.02852481407171581,"policy/policy_loss":-1.5519672160735354e-05,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.0009133670209848788,"policy/raw_grad_norm":0.0172119140625,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.5486328125,"timing/step":756.4714208105579,"trainer/epoch":0,"val/pass_at_1":0.4609375,"val/avg_score":0.4609375,"val/passed":59,"val/turn_cap_rate":0}
+{"step":7,"async/staleness_mean":1.984375,"generate/avg_num_tokens":1248.970703125,"generate/avg_tokens_non_zero_rewards":1144.6309963099632,"generate/avg_tokens_zero_rewards":1366.298755186722,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":8793,"generate/std_num_tokens":486.3455773686732,"loss/avg_final_rewards":0.5291992425918579,"loss/avg_raw_advantages":0.0022934735752642155,"loss/avg_raw_advantages_abs":0.01935821957886219,"policy/policy_entropy":0.024887905921787024,"policy/policy_loss":4.0540489862905815e-06,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.0009020073212013813,"policy/raw_grad_norm":0.03582763671875,"reward/avg_pass_at_8":0.546875,"reward/avg_raw_reward":0.52919921875,"timing/step":754.9154837308452,"trainer/epoch":0}
+{"step":8,"async/staleness_mean":1.828125,"generate/avg_num_tokens":1270.369140625,"generate/avg_tokens_non_zero_rewards":1198.4738955823293,"generate/avg_tokens_zero_rewards":1338.4372623574145,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":2780,"generate/std_num_tokens":412.39438807205414,"loss/avg_final_rewards":0.486328125,"loss/avg_raw_advantages":-0.001359981601126492,"loss/avg_raw_advantages_abs":0.030472196638584137,"policy/policy_entropy":0.020796455290110316,"policy/policy_loss":7.066901889629662e-05,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.0013078707961540204,"policy/raw_grad_norm":0.1002197265625,"reward/avg_pass_at_8":0.5,"reward/avg_raw_reward":0.486328125,"timing/step":762.5740822041407,"trainer/epoch":0}
+{"step":9,"async/staleness_mean":1.8125,"generate/avg_num_tokens":1307.755859375,"generate/avg_tokens_non_zero_rewards":1231.0196078431372,"generate/avg_tokens_zero_rewards":1421.7427184466019,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":4242,"generate/std_num_tokens":474.48180715094884,"loss/avg_final_rewards":0.59765625,"loss/avg_raw_advantages":0.0024578634183853865,"loss/avg_raw_advantages_abs":0.024736523628234863,"policy/policy_entropy":0.018660222129256,"policy/policy_loss":5.2358314860612154e-05,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.0003075657068620785,"policy/raw_grad_norm":0.03485107421875,"reward/avg_pass_at_8":0.609375,"reward/avg_raw_reward":0.59765625,"timing/step":764.1869538594037,"trainer/epoch":0,"val/pass_at_1":0.4609375,"val/avg_score":0.4609375,"val/passed":59,"val/turn_cap_rate":0}
+{"step":10,"async/staleness_mean":1.8125,"generate/avg_num_tokens":1315.171875,"generate/avg_tokens_non_zero_rewards":1181.7900355871886,"generate/avg_tokens_zero_rewards":1477.4242424242425,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":5891,"generate/std_num_tokens":481.48725660341665,"loss/avg_final_rewards":0.548828125,"loss/avg_raw_advantages":-0.0004911343567073345,"loss/avg_raw_advantages_abs":0.011280394159257412,"policy/policy_entropy":0.02154614836035762,"policy/policy_loss":3.325467696413398e-05,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.00047591524344170466,"policy/raw_grad_norm":0.02557373046875,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.548828125,"timing/step":747.0789433037862,"trainer/epoch":0}
+{"step":11,"async/staleness_mean":1.984375,"generate/avg_num_tokens":1425.4296875,"generate/avg_tokens_non_zero_rewards":1387.2847222222222,"generate/avg_tokens_zero_rewards":1474.4732142857142,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":3994,"generate/std_num_tokens":470.2107810864212,"loss/avg_final_rewards":0.5624023675918579,"loss/avg_raw_advantages":-0.0012276413617655635,"loss/avg_raw_advantages_abs":0.014891757629811764,"policy/policy_entropy":0.019480210423353128,"policy/policy_loss":0.0001193937359857955,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.0008961566391008091,"policy/raw_grad_norm":0.072509765625,"reward/avg_pass_at_8":0.578125,"reward/avg_raw_reward":0.56240234375,"timing/step":763.7978097638115,"trainer/epoch":0}
+{"step":12,"async/staleness_mean":1.96875,"generate/avg_num_tokens":1408.634765625,"generate/avg_tokens_non_zero_rewards":1316.4825174825176,"generate/avg_tokens_zero_rewards":1525.2522123893805,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":12411,"generate/std_num_tokens":675.449128215424,"loss/avg_final_rewards":0.5584961175918579,"loss/avg_raw_advantages":-0.016240207478404045,"loss/avg_raw_advantages_abs":0.024128973484039307,"policy/policy_entropy":0.018671778838324826,"policy/policy_loss":3.617058973759413e-05,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.0004153201936105688,"policy/raw_grad_norm":0.0103607177734375,"reward/avg_pass_at_8":0.5625,"reward/avg_raw_reward":0.55849609375,"timing/step":744.7515858206898,"trainer/epoch":0,"val/pass_at_1":0.4453125,"val/avg_score":0.44453125,"val/passed":57,"val/turn_cap_rate":0.015625}
+{"step":13,"async/staleness_mean":1.953125,"generate/avg_num_tokens":1548.177734375,"generate/avg_tokens_non_zero_rewards":1449.823275862069,"generate/avg_tokens_zero_rewards":1629.6714285714286,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":12336,"generate/std_num_tokens":711.2155346797952,"loss/avg_final_rewards":0.4530273377895355,"loss/avg_raw_advantages":-0.0006657633348368108,"loss/avg_raw_advantages_abs":0.0008905019494704902,"policy/policy_entropy":0.016578597751504276,"policy/policy_loss":9.77545823843684e-07,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.00014028424195089428,"policy/raw_grad_norm":0.00021600723266601562,"reward/avg_pass_at_8":0.453125,"reward/avg_raw_reward":0.45302734375,"timing/step":753.2786856554449,"trainer/epoch":0}
+{"step":14,"async/staleness_mean":1.9375,"generate/avg_num_tokens":1741.0703125,"generate/avg_tokens_non_zero_rewards":1448.3484162895927,"generate/avg_tokens_zero_rewards":1963.3780068728522,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":16036,"generate/std_num_tokens":1635.1196269003997,"loss/avg_final_rewards":0.4305664002895355,"loss/avg_raw_advantages":-0.03447751700878143,"loss/avg_raw_advantages_abs":0.053240541368722916,"policy/policy_entropy":0.01576114430645248,"policy/policy_loss":8.285757849080255e-05,"policy/policy_lr":3.999999989900971e-06,"policy/ppo_clip_ratio":0.0011577582673680809,"policy/raw_grad_norm":0.0352783203125,"reward/avg_pass_at_8":0.453125,"reward/avg_raw_reward":0.43056640625,"timing/step":817.7870323034003,"trainer/epoch":0}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr4/run.json b/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr4/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..c073dcb4bcf25ad9308e566361c222ce1ad26dbf
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-cal-agent-rloo-lr4/run.json
@@ -0,0 +1,29 @@
+{
+ "id": "marin-q3c-cal-agent-rloo-lr4",
+ "title": "Qwen3-Coder-30B-A3B RLOO on calendar agent (lr 4e-6)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/penfever/qwen3coder-calendar-agent-v49-lr4-step9/blob/main/training_logs/finelog.log",
+ "license": "unknown",
+ "model": "penfever/qwen3coder-calendar-agent-v49-lr4-step9",
+ "base_model": "Qwen/Qwen3-Coder-30B-A3B-Instruct",
+ "method": "RLOO-N (MarinSkyRL, asynchronous)",
+ "dataset": "open-thoughts/TaskTrove::laion__nemotron-gym-agent-calendar-v2",
+ "eval_suite": "fixed 128-task holdout (Harbor, pass@1 at temperature 0)",
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2026-09-02T21:27:18",
+ "updated_at": "2026-09-07T00:42:25Z",
+ "attempts": 0,
+ "note": "Marin Qwen3-Coder agentic data-source sweep (issue #8942), calendar agent source, recipe: asynchronous shaped RLOO-N, group 8, sequence-mean loss, DAPO disabled, lr 4e-6, max staleness 2. Training metrics are the per-step dicts the run mirrored to its log (2 attempts, 2 superseded rows dropped); val/* is the fixed 128-task holdout at checkpoints, with step 0 = the untrained base model on the same holdout. Marin found the holdout overlaps the training source, so the scores select configurations but are not clean generalization estimates.",
+ "metrics_map": {
+  "reward": "reward/avg_raw_reward",
+  "loss": "policy/policy_loss",
+  "entropy": "policy/policy_entropy",
+  "lr": "policy/policy_lr",
+  "grad_norm": "policy/raw_grad_norm",
+  "response_length": "generate/avg_num_tokens",
+  "eval:holdout_pass@1": "val/pass_at_1"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-cal-if-rloo-lr2/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-q3c-cal-if-rloo-lr2/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..11d6593de7508dcb2ce418dd84207f441dc24e71
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-cal-if-rloo-lr2/metrics.jsonl
@@ -0,0 +1,19 @@
+{"step":0,"val/pass_at_1":0.21875,"val/avg_score":0.21875,"val/passed":28,"val/turn_cap_rate":0.0234375}
+{"step":1,"async/staleness_mean":0.0,"generate/avg_num_tokens":2922.529296875,"generate/avg_tokens_non_zero_rewards":2628.1650485436894,"generate/avg_tokens_zero_rewards":2996.6601466992665,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":16976,"generate/std_num_tokens":1699.099749890863,"loss/avg_final_rewards":0.201171875,"loss/avg_raw_advantages":-0.015550758689641953,"loss/avg_raw_advantages_abs":0.11316736787557602,"policy/policy_entropy":0.3233463108772412,"policy/policy_loss":0.00047632897621951997,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.008489559246299905,"policy/raw_grad_norm":0.125244140625,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.201171875,"timing/step":1247.5515871401876,"trainer/epoch":0}
+{"step":2,"async/staleness_mean":1.0,"generate/avg_num_tokens":3196.943359375,"generate/avg_tokens_non_zero_rewards":2677.0419161676646,"generate/avg_tokens_zero_rewards":3448.6057971014493,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":23248,"generate/std_num_tokens":2582.2836525111284,"loss/avg_final_rewards":0.326171875,"loss/avg_raw_advantages":-0.05848308652639389,"loss/avg_raw_advantages_abs":0.14437760412693024,"policy/policy_entropy":0.22240215388592333,"policy/policy_loss":0.0006850036152172834,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.014397729029042239,"policy/raw_grad_norm":0.1220703125,"reward/avg_pass_at_8":0.421875,"reward/avg_raw_reward":0.326171875,"timing/step":899.112334751524,"trainer/epoch":0}
+{"step":3,"async/staleness_mean":1.984375,"generate/avg_num_tokens":3433.09375,"generate/avg_tokens_non_zero_rewards":3004.1635220125786,"generate/avg_tokens_zero_rewards":3626.2946175637394,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":15908,"generate/std_num_tokens":2426.7649639859414,"loss/avg_final_rewards":0.310546875,"loss/avg_raw_advantages":-0.027315860614180565,"loss/avg_raw_advantages_abs":0.10836391150951385,"policy/policy_entropy":0.1688442649319768,"policy/policy_loss":0.0007813010888639838,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.018787344419251895,"policy/raw_grad_norm":0.096435546875,"reward/avg_pass_at_8":0.390625,"reward/avg_raw_reward":0.310546875,"timing/step":907.9915293175727,"trainer/epoch":0,"val/pass_at_1":0.296875,"val/avg_score":0.296875,"val/passed":38,"val/turn_cap_rate":0.0234375}
+{"step":4,"async/staleness_mean":1.65625,"generate/avg_num_tokens":2338.025390625,"generate/avg_tokens_non_zero_rewards":2220.559585492228,"generate/avg_tokens_zero_rewards":2409.094043887147,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":16983,"generate/std_num_tokens":1620.7816586148151,"loss/avg_final_rewards":0.376953125,"loss/avg_raw_advantages":-0.00914244819432497,"loss/avg_raw_advantages_abs":0.05165892094373703,"policy/policy_entropy":0.08989189460407943,"policy/policy_loss":0.00025026549701578915,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.004808870648048469,"policy/raw_grad_norm":0.086181640625,"reward/avg_pass_at_8":0.4375,"reward/avg_raw_reward":0.376953125,"timing/step":804.7161148218438,"trainer/epoch":0}
+{"step":5,"async/staleness_mean":1.65625,"generate/avg_num_tokens":2521.55078125,"generate/avg_tokens_non_zero_rewards":1991.0967741935483,"generate/avg_tokens_zero_rewards":2691.077319587629,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":12800,"generate/std_num_tokens":1698.88877093676,"loss/avg_final_rewards":0.2421875,"loss/avg_raw_advantages":-0.0002022742119152099,"loss/avg_raw_advantages_abs":0.007534603122621775,"policy/policy_entropy":0.06430556328268722,"policy/policy_loss":2.057745587080717e-05,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.00040736651135375723,"policy/raw_grad_norm":0.03472900390625,"reward/avg_pass_at_8":0.25,"reward/avg_raw_reward":0.2421875,"timing/step":829.9793928796425,"trainer/epoch":0}
+{"step":6,"async/staleness_mean":1.671875,"generate/avg_num_tokens":2351.5078125,"generate/avg_tokens_non_zero_rewards":2334.445497630332,"generate/avg_tokens_zero_rewards":2363.468438538206,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":13835,"generate/std_num_tokens":1844.949622432538,"loss/avg_final_rewards":0.412109375,"loss/avg_raw_advantages":-0.022126171737909317,"loss/avg_raw_advantages_abs":0.0651857927441597,"policy/policy_entropy":0.056418789899908006,"policy/policy_loss":0.0003275337512604892,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0050245242255186895,"policy/raw_grad_norm":0.0999755859375,"reward/avg_pass_at_8":0.453125,"reward/avg_raw_reward":0.412109375,"timing/step":814.493153183721,"trainer/epoch":0,"val/pass_at_1":0.3046875,"val/avg_score":0.3046875,"val/passed":39,"val/turn_cap_rate":0.09375}
+{"step":7,"async/staleness_mean":1.96875,"generate/avg_num_tokens":2665.869140625,"generate/avg_tokens_non_zero_rewards":2442.811111111111,"generate/avg_tokens_zero_rewards":2786.8042168674697,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":13313,"generate/std_num_tokens":2343.36020684992,"loss/avg_final_rewards":0.3515625,"loss/avg_raw_advantages":-0.009583254344761372,"loss/avg_raw_advantages_abs":0.03796368092298508,"policy/policy_entropy":0.05372556674410589,"policy/policy_loss":0.00018093397375196218,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0023538639416074147,"policy/raw_grad_norm":0.0587158203125,"reward/avg_pass_at_8":0.375,"reward/avg_raw_reward":0.3515625,"timing/step":837.664447597228,"trainer/epoch":0}
+{"step":8,"async/staleness_mean":1.96875,"generate/avg_num_tokens":3034.578125,"generate/avg_tokens_non_zero_rewards":2631.346153846154,"generate/avg_tokens_zero_rewards":3211.275280898876,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":17092,"generate/std_num_tokens":2852.41176287545,"loss/avg_final_rewards":0.3046875,"loss/avg_raw_advantages":-0.019987449049949646,"loss/avg_raw_advantages_abs":0.03976084291934967,"policy/policy_entropy":0.049168585654115304,"policy/policy_loss":0.0002641555620357394,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0022013890393282054,"policy/raw_grad_norm":0.058349609375,"reward/avg_pass_at_8":0.328125,"reward/avg_raw_reward":0.3046875,"timing/step":899.393081064336,"trainer/epoch":0}
+{"step":9,"async/staleness_mean":1.9375,"generate/avg_num_tokens":2632.48828125,"generate/avg_tokens_non_zero_rewards":2642.7224880382773,"generate/avg_tokens_zero_rewards":2625.4290429042903,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":14082,"generate/std_num_tokens":2362.6197613203485,"loss/avg_final_rewards":0.408203125,"loss/avg_raw_advantages":-0.006909183692187071,"loss/avg_raw_advantages_abs":0.04882024601101875,"policy/policy_entropy":0.04640811731223948,"policy/policy_loss":0.0001382353948429227,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0018512427323003067,"policy/raw_grad_norm":0.044189453125,"reward/avg_pass_at_8":0.4375,"reward/avg_raw_reward":0.408203125,"timing/step":869.2640024060383,"trainer/epoch":0,"val/pass_at_1":0.296875,"val/avg_score":0.296875,"val/passed":38,"val/turn_cap_rate":0.0546875}
+{"step":10,"async/staleness_mean":1.96875,"generate/avg_num_tokens":3102.42578125,"generate/avg_tokens_non_zero_rewards":2488.9593023255816,"generate/avg_tokens_zero_rewards":3412.7676470588235,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":16033,"generate/std_num_tokens":2765.429942690481,"loss/avg_final_rewards":0.3359375,"loss/avg_raw_advantages":-0.013159617781639099,"loss/avg_raw_advantages_abs":0.024752289056777954,"policy/policy_entropy":0.044459557422669604,"policy/policy_loss":9.228897397406399e-05,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0012809775325877126,"policy/raw_grad_norm":0.030731201171875,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.3359375,"timing/step":889.8330702623352,"trainer/epoch":0}
+{"step":11,"async/staleness_mean":1.96875,"generate/avg_num_tokens":3238.13671875,"generate/avg_tokens_non_zero_rewards":2270.303225806452,"generate/avg_tokens_zero_rewards":3658.344537815126,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":19247,"generate/std_num_tokens":3393.55023192828,"loss/avg_final_rewards":0.302734375,"loss/avg_raw_advantages":-0.026760205626487732,"loss/avg_raw_advantages_abs":0.06007860228419304,"policy/policy_entropy":0.04191497477586381,"policy/policy_loss":0.00012307526776567101,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0017760449400157086,"policy/raw_grad_norm":0.04730224609375,"reward/avg_pass_at_8":0.328125,"reward/avg_raw_reward":0.302734375,"timing/step":947.7256898907945,"trainer/epoch":0}
+{"step":12,"async/staleness_mean":1.984375,"generate/avg_num_tokens":2615.6796875,"generate/avg_tokens_non_zero_rewards":2025.364,"generate/avg_tokens_zero_rewards":3178.9580152671756,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":15463,"generate/std_num_tokens":2653.739819615405,"loss/avg_final_rewards":0.48828125,"loss/avg_raw_advantages":-0.022558946162462234,"loss/avg_raw_advantages_abs":0.06458038836717606,"policy/policy_entropy":0.04119368302053772,"policy/policy_loss":0.00016294774832203984,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0025851095797406742,"policy/raw_grad_norm":0.0633544921875,"reward/avg_pass_at_8":0.53125,"reward/avg_raw_reward":0.48828125,"timing/step":873.0298640858382,"trainer/epoch":0,"val/pass_at_1":0.296875,"val/avg_score":0.296875,"val/passed":38,"val/turn_cap_rate":0.0703125}
+{"step":13,"async/staleness_mean":1.6875,"generate/avg_num_tokens":2355.857421875,"generate/avg_tokens_non_zero_rewards":1540.9831460674156,"generate/avg_tokens_zero_rewards":2790.131736526946,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":17332,"generate/std_num_tokens":2416.81613040527,"loss/avg_final_rewards":0.34765625,"loss/avg_raw_advantages":-0.001377171603962779,"loss/avg_raw_advantages_abs":0.012774012982845306,"policy/policy_entropy":0.04099735175259411,"policy/policy_loss":0.00016055197920650244,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0010651398997651995,"policy/raw_grad_norm":0.0892333984375,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.34765625,"timing/step":859.3556041838601,"trainer/epoch":0}
+{"step":14,"async/staleness_mean":1.6875,"generate/avg_num_tokens":2572.556640625,"generate/avg_tokens_non_zero_rewards":1660.6912751677853,"generate/avg_tokens_zero_rewards":2946.848484848485,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":15063,"generate/std_num_tokens":2528.232650040209,"loss/avg_final_rewards":0.291015625,"loss/avg_raw_advantages":-0.00018373012426309288,"loss/avg_raw_advantages_abs":0.0015214678132906556,"policy/policy_entropy":0.037931958577246405,"policy/policy_loss":2.402684185653925e-05,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.00042363112515886314,"policy/raw_grad_norm":0.0394287109375,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.291015625,"timing/step":877.4724658243358,"trainer/epoch":0}
+{"step":15,"async/staleness_mean":1.703125,"generate/avg_num_tokens":2467.619140625,"generate/avg_tokens_non_zero_rewards":1419.9806451612903,"generate/avg_tokens_zero_rewards":2922.4761904761904,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":20581,"generate/std_num_tokens":2670.6801278289604,"loss/avg_final_rewards":0.302734375,"loss/avg_raw_advantages":-0.0032388262916356325,"loss/avg_raw_advantages_abs":0.016803132370114326,"policy/policy_entropy":0.03846031984721776,"policy/policy_loss":0.0001407616655342281,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0013565665376518155,"policy/raw_grad_norm":0.056884765625,"reward/avg_pass_at_8":0.328125,"reward/avg_raw_reward":0.302734375,"timing/step":866.9504282530397,"trainer/epoch":0,"val/pass_at_1":0.2890625,"val/avg_score":0.2890625,"val/passed":37,"val/turn_cap_rate":0.125}
+{"step":16,"async/staleness_mean":1.953125,"generate/avg_num_tokens":1988.51171875,"generate/avg_tokens_non_zero_rewards":1306.1990049751244,"generate/avg_tokens_zero_rewards":2429.491961414791,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":16664,"generate/std_num_tokens":2385.2919206540887,"loss/avg_final_rewards":0.392578125,"loss/avg_raw_advantages":-0.020614368841052055,"loss/avg_raw_advantages_abs":0.03734636306762695,"policy/policy_entropy":0.03604317925055511,"policy/policy_loss":0.00011708831880241632,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0021453153890433896,"policy/raw_grad_norm":0.064208984375,"reward/avg_pass_at_8":0.40625,"reward/avg_raw_reward":0.392578125,"timing/step":829.8454401083291,"trainer/epoch":0}
+{"step":17,"async/staleness_mean":1.953125,"generate/avg_num_tokens":1831.455078125,"generate/avg_tokens_non_zero_rewards":1629.86875,"generate/avg_tokens_zero_rewards":1923.0852272727273,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":13342,"generate/std_num_tokens":1539.3687150747137,"loss/avg_final_rewards":0.3125,"loss/avg_raw_advantages":-0.01566789299249649,"loss/avg_raw_advantages_abs":0.02782127447426319,"policy/policy_entropy":0.03298378288309323,"policy/policy_loss":0.00010075257159769535,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.00047483830030614627,"policy/raw_grad_norm":0.05096435546875,"reward/avg_pass_at_8":0.328125,"reward/avg_raw_reward":0.3125,"timing/step":799.2809429997578,"trainer/epoch":0}
+{"step":18,"async/staleness_mean":1.921875,"generate/avg_num_tokens":1623.966796875,"generate/avg_tokens_non_zero_rewards":1263.1387559808613,"generate/avg_tokens_zero_rewards":1872.854785478548,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":19269,"generate/std_num_tokens":1441.1131605379494,"loss/avg_final_rewards":0.408203125,"loss/avg_raw_advantages":-0.015875305980443954,"loss/avg_raw_advantages_abs":0.02556450478732586,"policy/policy_entropy":0.03677595766203012,"policy/policy_loss":0.0001014711451716721,"policy/policy_lr":1.9999999949504854e-06,"policy/ppo_clip_ratio":0.0012722727988148108,"policy/raw_grad_norm":0.04461669921875,"reward/avg_pass_at_8":0.4375,"reward/avg_raw_reward":0.408203125,"timing/step":783.585354629904,"trainer/epoch":0,"val/pass_at_1":0.3203125,"val/avg_score":0.3203125,"val/passed":41,"val/turn_cap_rate":0.09375}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-cal-if-rloo-lr2/run.json b/viewer/build/inputs/marin/runs/marin-q3c-cal-if-rloo-lr2/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..6f59f5106d90059b668c488f71268cafae2c8d37
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-cal-if-rloo-lr2/run.json
@@ -0,0 +1,29 @@
+{
+ "id": "marin-q3c-cal-if-rloo-lr2",
+ "title": "Qwen3-Coder-30B-A3B RLOO on calendar instruction-following (lr 2e-6)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/penfever/qwen3coder-calendar-if-v49-lr2-step18/blob/main/training_logs/finelog.log",
+ "license": "unknown",
+ "model": "penfever/qwen3coder-calendar-if-v49-lr2-step18",
+ "base_model": "Qwen/Qwen3-Coder-30B-A3B-Instruct",
+ "method": "RLOO-N (MarinSkyRL, asynchronous)",
+ "dataset": "open-thoughts/TaskTrove::laion__nemotron-gym-instruction-following-calendar-v3",
+ "eval_suite": "fixed 128-task holdout (Harbor, pass@1 at temperature 0)",
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2026-09-02T21:21:02",
+ "updated_at": "2026-09-07T01:24:46Z",
+ "attempts": 0,
+ "note": "Marin Qwen3-Coder agentic data-source sweep (issue #8942), calendar instruction-following source, recipe: asynchronous RLOO-N, group 8, sequence-mean loss, no DAPO, no reward shaping, lr 2e-6, max staleness 2. Training metrics are the per-step dicts the run mirrored to its log (1 attempt); val/* is the fixed 128-task holdout at checkpoints, with step 0 = the untrained base model on the same holdout. Marin found the holdout overlaps the training source, so the scores select configurations but are not clean generalization estimates.",
+ "metrics_map": {
+  "reward": "reward/avg_raw_reward",
+  "loss": "policy/policy_loss",
+  "entropy": "policy/policy_entropy",
+  "lr": "policy/policy_lr",
+  "grad_norm": "policy/raw_grad_norm",
+  "response_length": "generate/avg_num_tokens",
+  "eval:holdout_pass@1": "val/pass_at_1"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-tt-x10-fsdp2/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-q3c-tt-x10-fsdp2/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..bcc1b0e1c4b5ddd818470e0778accfd371100e33
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-tt-x10-fsdp2/metrics.jsonl
@@ -0,0 +1,131 @@
+{"step":1,"reward":0.212890625,"avg_pass_at_8":0.3125,"entropy":0.2841771899256855,"grad_norm":0.0657958984375,"tokens":11881.736328125,"tis_log_ratio_mean":0.038364515829016455}
+{"step":2,"reward":0.087890625,"avg_pass_at_8":0.234375,"entropy":0.22218329785391688,"grad_norm":0.0667724609375,"tokens":12495.234375,"tis_log_ratio_mean":0.03849506180267781}
+{"step":3,"reward":0.1328125,"avg_pass_at_8":0.234375,"entropy":0.16953804343938828,"grad_norm":0.060791015625,"tokens":12662.1484375,"tis_log_ratio_mean":0.09063192247413099}
+{"step":4,"reward":0.087890625,"avg_pass_at_8":0.1875,"entropy":0.13060367346042767,"grad_norm":0.03411865234375,"tokens":11763.46875,"tis_log_ratio_mean":0.14461265184218064}
+{"step":5,"reward":0.15625,"avg_pass_at_8":0.28125,"entropy":0.09753880253992975,"grad_norm":0.0433349609375,"tokens":12134.107421875,"tis_log_ratio_mean":0.10195304278749973}
+{"step":6,"reward":0.220703125,"avg_pass_at_8":0.359375,"entropy":0.09256732041831128,"grad_norm":0.0457763671875,"tokens":12589.193359375,"tis_log_ratio_mean":0.10138594143791124}
+{"step":7,"reward":0.19921875,"avg_pass_at_8":0.3125,"entropy":0.07342620013514534,"grad_norm":0.05181884765625,"tokens":12317.18359375,"tis_log_ratio_mean":0.05984293416258879}
+{"step":8,"reward":0.15625,"avg_pass_at_8":0.296875,"entropy":0.0664285022940021,"grad_norm":0.04241943359375,"tokens":12594.4140625,"tis_log_ratio_mean":0.03522976358362939}
+{"step":9,"reward":0.142578125,"avg_pass_at_8":0.28125,"entropy":0.05864239588845521,"grad_norm":0.04180908203125,"tokens":12068.154296875,"tis_log_ratio_mean":0.027953602751949802}
+{"step":10,"reward":0.16796875,"avg_pass_at_8":0.3125,"entropy":0.0568410100240726,"grad_norm":0.04449462890625,"tokens":12847.015625,"tis_log_ratio_mean":0.024628574421512894}
+{"step":11,"reward":0.15234375,"avg_pass_at_8":0.296875,"entropy":0.053056443139212206,"grad_norm":0.0452880859375,"tokens":12536.08203125,"tis_log_ratio_mean":0.022202180218300782}
+{"step":12,"reward":0.12890625,"avg_pass_at_8":0.3125,"entropy":0.051567029440775514,"grad_norm":0.04400634765625,"tokens":12282.0859375,"tis_log_ratio_mean":0.020878274139249697}
+{"step":13,"reward":0.19921875,"avg_pass_at_8":0.375,"entropy":0.048805676226038486,"grad_norm":0.05438232421875,"tokens":12786.90234375,"tis_log_ratio_mean":0.01941614526003832}
+{"step":14,"reward":0.19921875,"avg_pass_at_8":0.296875,"entropy":0.04660979693289846,"grad_norm":0.03485107421875,"tokens":12327.34375,"tis_log_ratio_mean":0.018360236805165187}
+{"step":15,"reward":0.193359375,"avg_pass_at_8":0.34375,"entropy":0.04514222368015908,"grad_norm":0.05419921875,"tokens":12222.05078125,"tis_log_ratio_mean":0.017846548245870508}
+{"step":16,"reward":0.154296875,"avg_pass_at_8":0.28125,"entropy":0.042855857784161344,"grad_norm":0.04254150390625,"tokens":13332.435546875,"tis_log_ratio_mean":0.016569633662584238}
+{"step":17,"reward":0.25,"avg_pass_at_8":0.375,"entropy":0.04131283948663622,"grad_norm":0.0418701171875,"tokens":12548.912109375,"tis_log_ratio_mean":0.016559631236304995}
+{"step":18,"reward":0.203125,"avg_pass_at_8":0.328125,"entropy":0.03891567382379435,"grad_norm":0.05523681640625,"tokens":12550.705078125,"tis_log_ratio_mean":0.015734463297121692}
+{"step":19,"reward":0.134765625,"avg_pass_at_8":0.296875,"entropy":0.04044313328631688,"grad_norm":0.0438232421875,"tokens":12908.900390625,"tis_log_ratio_mean":0.015913555289444048}
+{"step":20,"reward":0.1796875,"avg_pass_at_8":0.3125,"entropy":0.03743738950288389,"grad_norm":0.03448486328125,"tokens":13096.10546875,"tis_log_ratio_mean":0.015082018857356161}
+{"step":21,"reward":0.2421875,"avg_pass_at_8":0.328125,"entropy":0.03658617738983594,"grad_norm":0.03643798828125,"tokens":12645.8125,"tis_log_ratio_mean":0.01441338995937258}
+{"step":22,"reward":0.158203125,"avg_pass_at_8":0.359375,"entropy":0.03569843286823016,"grad_norm":0.04046630859375,"tokens":12698.052734375,"tis_log_ratio_mean":0.014125670662906487}
+{"step":23,"reward":0.193359375,"avg_pass_at_8":0.359375,"entropy":0.03394435811787844,"grad_norm":0.04620361328125,"tokens":12710.998046875,"tis_log_ratio_mean":0.0132341858552536}
+{"step":24,"reward":0.158203125,"avg_pass_at_8":0.25,"entropy":0.03395247203297913,"grad_norm":0.028564453125,"tokens":12332.021484375,"tis_log_ratio_mean":0.01289007104060147}
+{"step":25,"reward":0.16015625,"avg_pass_at_8":0.265625,"entropy":0.03358004772599088,"grad_norm":0.03521728515625,"tokens":12002.28125,"tis_log_ratio_mean":0.012765458937792573}
+{"step":26,"reward":0.138671875,"avg_pass_at_8":0.28125,"entropy":0.033016397661413066,"grad_norm":0.03424072265625,"tokens":12812.439453125,"tis_log_ratio_mean":0.012117673104512505}
+{"step":27,"reward":0.228515625,"avg_pass_at_8":0.359375,"entropy":0.031657723418902606,"grad_norm":0.0445556640625,"tokens":12256.541015625,"tis_log_ratio_mean":0.011358821244357387}
+{"step":28,"reward":0.1796875,"avg_pass_at_8":0.3125,"entropy":0.03244724746036809,"grad_norm":0.0372314453125,"tokens":12348.115234375,"tis_log_ratio_mean":0.01094988789918716}
+{"step":29,"reward":0.19140625,"avg_pass_at_8":0.328125,"entropy":0.03243779667536728,"grad_norm":0.0343017578125,"tokens":13087.103515625,"tis_log_ratio_mean":0.011190733315743273}
+{"step":30,"reward":0.208984375,"avg_pass_at_8":0.3125,"entropy":0.02962814005149994,"grad_norm":0.0364990234375,"tokens":12577.455078125,"tis_log_ratio_mean":0.010096439207700314}
+{"step":31,"reward":0.20703125,"avg_pass_at_8":0.328125,"entropy":0.0309488231287105,"grad_norm":0.041259765625,"tokens":12363.822265625,"tis_log_ratio_mean":0.010903368882281939}
+{"step":32,"reward":0.181640625,"avg_pass_at_8":0.265625,"entropy":0.02925875797518529,"grad_norm":0.02789306640625,"tokens":12903.921875,"tis_log_ratio_mean":0.01017761023103958}
+{"step":33,"reward":0.203125,"avg_pass_at_8":0.34375,"entropy":0.030067210784181952,"grad_norm":0.0631103515625,"tokens":12612.9140625,"tis_log_ratio_mean":0.010808022936544148}
+{"step":34,"reward":0.1640625,"avg_pass_at_8":0.296875,"entropy":0.02850124496035278,"grad_norm":0.03546142578125,"tokens":13280.998046875,"tis_log_ratio_mean":0.010313762260921067}
+{"step":35,"reward":0.208984375,"avg_pass_at_8":0.34375,"entropy":0.03092884058423806,"grad_norm":0.03924560546875,"tokens":12773.3984375,"tis_log_ratio_mean":0.010966236462991219}
+{"step":36,"reward":0.26953125,"avg_pass_at_8":0.359375,"entropy":0.032130426552612334,"grad_norm":0.03912353515625,"tokens":13144.921875,"tis_log_ratio_mean":0.011368247018253896}
+{"step":37,"reward":0.205078125,"avg_pass_at_8":0.296875,"entropy":0.02857135566591751,"grad_norm":0.03680419921875,"tokens":12472.890625,"tis_log_ratio_mean":0.010153336690564174}
+{"step":38,"reward":0.3046875,"avg_pass_at_8":0.421875,"entropy":0.030453038096311502,"grad_norm":0.0467529296875,"tokens":12788.86328125,"tis_log_ratio_mean":0.010748489661636995}
+{"step":39,"reward":0.25390625,"avg_pass_at_8":0.328125,"entropy":0.030632267269538715,"grad_norm":0.037109375,"tokens":12523.921875,"tis_log_ratio_mean":0.011051126886741258}
+{"step":40,"reward":0.1953125,"avg_pass_at_8":0.296875,"entropy":0.030233249824959785,"grad_norm":0.03253173828125,"tokens":13367.421875,"tis_log_ratio_mean":0.010567939076281618}
+{"step":41,"reward":0.279296875,"avg_pass_at_8":0.4375,"entropy":0.02989778813207522,"grad_norm":0.03314208984375,"tokens":12535.595703125,"tis_log_ratio_mean":0.010793829402246047}
+{"step":42,"reward":0.193359375,"avg_pass_at_8":0.34375,"entropy":0.02982971494202502,"grad_norm":0.03607177734375,"tokens":12638.52734375,"tis_log_ratio_mean":0.010689664333767723}
+{"step":43,"reward":0.228515625,"avg_pass_at_8":0.328125,"entropy":0.03052262075652834,"grad_norm":0.03955078125,"tokens":12657.53125,"tis_log_ratio_mean":0.010411221523099812}
+{"step":44,"reward":0.1484375,"avg_pass_at_8":0.265625,"entropy":0.029005808028159663,"grad_norm":0.03387451171875,"tokens":12091.994140625,"tis_log_ratio_mean":0.01026588813692797}
+{"step":45,"reward":0.20703125,"avg_pass_at_8":0.296875,"entropy":0.028449535981053486,"grad_norm":0.027496337890625,"tokens":13019.103515625,"tis_log_ratio_mean":0.009740504043293186}
+{"step":46,"reward":0.203125,"avg_pass_at_8":0.296875,"entropy":0.03021659243677277,"grad_norm":0.0467529296875,"tokens":13155.5078125,"tis_log_ratio_mean":0.010293671719409758}
+{"step":47,"reward":0.240234375,"avg_pass_at_8":0.390625,"entropy":0.030966883699875325,"grad_norm":0.03729248046875,"tokens":12550.833984375,"tis_log_ratio_mean":0.010248874641547445}
+{"step":48,"reward":0.220703125,"avg_pass_at_8":0.390625,"entropy":0.02938420452119317,"grad_norm":0.044677734375,"tokens":13721.046875,"tis_log_ratio_mean":0.009808252561924746}
+{"step":49,"reward":0.259765625,"avg_pass_at_8":0.40625,"entropy":0.027371705378754996,"grad_norm":0.030853271484375,"tokens":12779.29296875,"tis_log_ratio_mean":0.009135908836469753}
+{"step":50,"reward":0.201171875,"avg_pass_at_8":0.375,"entropy":0.031289247184759006,"grad_norm":0.03594970703125,"tokens":13823.228515625,"tis_log_ratio_mean":0.010198387328273384}
+{"step":51,"reward":0.294921875,"avg_pass_at_8":0.421875,"entropy":0.028124889126047492,"grad_norm":0.04296875,"tokens":13054.509765625,"tis_log_ratio_mean":0.009511162501439685}
+{"step":52,"reward":0.181640625,"avg_pass_at_8":0.265625,"entropy":0.028007985587464646,"grad_norm":0.0322265625,"tokens":13133.361328125,"tis_log_ratio_mean":0.009548205816827249}
+{"step":53,"reward":0.22265625,"avg_pass_at_8":0.375,"entropy":0.029032153950538486,"grad_norm":0.03997802734375,"tokens":12777.341796875,"tis_log_ratio_mean":0.009956562164006755}
+{"step":54,"reward":0.2421875,"avg_pass_at_8":0.34375,"entropy":0.02751605203957297,"grad_norm":0.0350341796875,"tokens":13278.8359375,"tis_log_ratio_mean":0.009461242421821225}
+{"step":55,"reward":0.287109375,"avg_pass_at_8":0.421875,"entropy":0.027387330548663158,"grad_norm":0.0325927734375,"tokens":13895.283203125,"tis_log_ratio_mean":0.009503483528533252}
+{"step":56,"reward":0.169921875,"avg_pass_at_8":0.328125,"entropy":0.02758093578449916,"grad_norm":0.035888671875,"tokens":12757.833984375,"tis_log_ratio_mean":0.0096796070538403}
+{"step":57,"reward":0.205078125,"avg_pass_at_8":0.328125,"entropy":0.027183092141058296,"grad_norm":0.033203125,"tokens":12691.109375,"tis_log_ratio_mean":0.009581870112015167}
+{"step":58,"reward":0.2109375,"avg_pass_at_8":0.296875,"entropy":0.027204874844755977,"grad_norm":0.03155517578125,"tokens":12914.486328125,"tis_log_ratio_mean":0.009408349818841089}
+{"step":59,"reward":0.16015625,"avg_pass_at_8":0.265625,"entropy":0.026098899441421963,"grad_norm":0.022918701171875,"tokens":12813.265625,"tis_log_ratio_mean":0.009095330358832143}
+{"step":60,"reward":0.23828125,"avg_pass_at_8":0.359375,"entropy":0.026620148346410133,"grad_norm":0.032958984375,"tokens":12866.810546875,"tis_log_ratio_mean":0.00890859115315834}
+{"step":61,"reward":0.169921875,"avg_pass_at_8":0.28125,"entropy":0.027887248012120835,"grad_norm":0.030975341796875,"tokens":11839.19140625,"tis_log_ratio_mean":0.009386354246089468}
+{"step":62,"reward":0.259765625,"avg_pass_at_8":0.390625,"entropy":0.027947976093855686,"grad_norm":0.04302978515625,"tokens":11692.138671875,"tis_log_ratio_mean":0.009609241533325985}
+{"step":63,"reward":0.201171875,"avg_pass_at_8":0.3125,"entropy":0.02903481676185038,"grad_norm":0.02935791015625,"tokens":11817.130859375,"tis_log_ratio_mean":0.009614631126169115}
+{"step":64,"reward":0.189453125,"avg_pass_at_8":0.34375,"entropy":0.027791766842710786,"grad_norm":0.0382080078125,"tokens":10968.287109375,"tis_log_ratio_mean":0.00962878475911566}
+{"step":65,"reward":0.259765625,"avg_pass_at_8":0.375,"entropy":0.029161494036088698,"grad_norm":0.029510498046875,"tokens":11231.85546875,"tis_log_ratio_mean":0.009696890971099492}
+{"step":66,"reward":0.197265625,"avg_pass_at_8":0.328125,"entropy":0.029056368875899352,"grad_norm":0.05419921875,"tokens":10758.220703125,"tis_log_ratio_mean":0.010006335822254186}
+{"step":67,"reward":0.275390625,"avg_pass_at_8":0.40625,"entropy":0.029272589934407733,"grad_norm":0.0487060546875,"tokens":11061.978515625,"tis_log_ratio_mean":0.010036646322987508}
+{"step":68,"reward":0.26953125,"avg_pass_at_8":0.46875,"entropy":0.029200913282693364,"grad_norm":0.04052734375,"tokens":11505.048828125,"tis_log_ratio_mean":0.01006036519902409}
+{"step":69,"reward":0.22265625,"avg_pass_at_8":0.28125,"entropy":0.027148673427291214,"grad_norm":0.024871826171875,"tokens":11390.96875,"tis_log_ratio_mean":0.009945427700586151}
+{"step":70,"reward":0.171875,"avg_pass_at_8":0.25,"entropy":0.02843844138260465,"grad_norm":0.03619384765625,"tokens":10790.607421875,"tis_log_ratio_mean":0.010516655500396155}
+{"step":71,"reward":0.28515625,"avg_pass_at_8":0.375,"entropy":0.0306850428605685,"grad_norm":0.04302978515625,"tokens":10056.451171875,"tis_log_ratio_mean":0.010788282568682916}
+{"step":72,"reward":0.232421875,"avg_pass_at_8":0.328125,"entropy":0.02988124210969545,"grad_norm":0.0428466796875,"tokens":10550.240234375,"tis_log_ratio_mean":0.010693700241972692}
+{"step":73,"reward":0.232421875,"avg_pass_at_8":0.34375,"entropy":0.031069430653587915,"grad_norm":0.076416015625,"tokens":8945.734375,"tis_log_ratio_mean":0.010977997284498997}
+{"step":74,"reward":0.236328125,"avg_pass_at_8":0.34375,"entropy":0.030875944896251895,"grad_norm":0.05029296875,"tokens":8423.21875,"tis_log_ratio_mean":0.011183002883626614}
+{"step":75,"reward":0.24609375,"avg_pass_at_8":0.359375,"entropy":0.03141133471217472,"grad_norm":0.03704833984375,"tokens":9757.416015625,"tis_log_ratio_mean":0.011101966993010137}
+{"step":76,"reward":0.15625,"avg_pass_at_8":0.3125,"entropy":0.03016999464307446,"grad_norm":0.051513671875,"tokens":9065.568359375,"tis_log_ratio_mean":0.009808475118916249}
+{"step":77,"reward":0.21875,"avg_pass_at_8":0.359375,"entropy":0.030204133305232972,"grad_norm":0.0450439453125,"tokens":8089.38671875,"tis_log_ratio_mean":0.009717524277220946}
+{"step":78,"reward":0.244140625,"avg_pass_at_8":0.375,"entropy":0.03067694982746616,"grad_norm":0.0452880859375,"tokens":8266.53125,"tis_log_ratio_mean":0.009917856954416493}
+{"step":79,"reward":0.154296875,"avg_pass_at_8":0.25,"entropy":0.029473103117197752,"grad_norm":0.04559326171875,"tokens":8943.947265625,"tis_log_ratio_mean":0.009989923401008127}
+{"step":80,"reward":0.17578125,"avg_pass_at_8":0.234375,"entropy":0.030776130486628972,"grad_norm":0.056396484375,"tokens":8618.27734375,"tis_log_ratio_mean":0.010737046046415344}
+{"step":81,"reward":0.16796875,"avg_pass_at_8":0.25,"entropy":0.030294847732875496,"grad_norm":0.04229736328125,"tokens":8587.7890625,"tis_log_ratio_mean":0.011067064486269373}
+{"step":82,"reward":0.294921875,"avg_pass_at_8":0.421875,"entropy":0.030869852038449608,"grad_norm":0.048583984375,"tokens":9556.98828125,"tis_log_ratio_mean":0.011962324206251651}
+{"step":83,"reward":0.302734375,"avg_pass_at_8":0.421875,"entropy":0.02902125303808134,"grad_norm":0.04351806640625,"tokens":9309.201171875,"tis_log_ratio_mean":0.01167204885132378}
+{"step":84,"reward":0.220703125,"avg_pass_at_8":0.359375,"entropy":0.03206025120744016,"grad_norm":0.0452880859375,"tokens":8866.61328125,"tis_log_ratio_mean":0.012416040139214601}
+{"step":85,"reward":0.20703125,"avg_pass_at_8":0.328125,"entropy":0.02951743867015466,"grad_norm":0.04656982421875,"tokens":8920.86328125,"tis_log_ratio_mean":0.01213949977682205}
+{"step":86,"reward":0.1953125,"avg_pass_at_8":0.34375,"entropy":0.030636480951216072,"grad_norm":0.049560546875,"tokens":8653.85546875,"tis_log_ratio_mean":0.012725080690870527}
+{"step":87,"reward":0.220703125,"avg_pass_at_8":0.3125,"entropy":0.028880212877993472,"grad_norm":0.04705810546875,"tokens":8024.61328125,"tis_log_ratio_mean":0.00992833813870675}
+{"step":88,"reward":0.193359375,"avg_pass_at_8":0.3125,"entropy":0.030465519274002872,"grad_norm":0.0540771484375,"tokens":8904.87109375,"tis_log_ratio_mean":0.011851582581584807}
+{"step":89,"reward":0.154296875,"avg_pass_at_8":0.25,"entropy":0.030161284681526013,"grad_norm":0.04217529296875,"tokens":8971.01171875,"tis_log_ratio_mean":0.012485835279221646}
+{"step":90,"reward":0.224609375,"avg_pass_at_8":0.3125,"entropy":0.031217851268593222,"grad_norm":0.03680419921875,"tokens":9764.037109375,"tis_log_ratio_mean":0.013571985386079177}
+{"step":91,"reward":0.283203125,"avg_pass_at_8":0.40625,"entropy":0.03072588321811054,"grad_norm":0.04400634765625,"tokens":8531.015625,"tis_log_ratio_mean":0.013256323050882202}
+{"step":92,"reward":0.12109375,"avg_pass_at_8":0.21875,"entropy":0.030266602989286184,"grad_norm":0.04656982421875,"tokens":9535.240234375,"tis_log_ratio_mean":0.013386551494477317}
+{"step":93,"reward":0.236328125,"avg_pass_at_8":0.359375,"entropy":0.03157717621070333,"grad_norm":0.03814697265625,"tokens":8697.197265625,"tis_log_ratio_mean":0.01356871890311595}
+{"step":94,"reward":0.205078125,"avg_pass_at_8":0.296875,"entropy":0.028351451794151217,"grad_norm":0.03875732421875,"tokens":10050.4296875,"tis_log_ratio_mean":0.012061884459399153}
+{"step":95,"reward":0.28125,"avg_pass_at_8":0.375,"entropy":0.029586737306090072,"grad_norm":0.0404052734375,"tokens":9361.25,"tis_log_ratio_mean":0.012686615977145266}
+{"step":96,"reward":0.26171875,"avg_pass_at_8":0.375,"entropy":0.028367519276798703,"grad_norm":0.040771484375,"tokens":8762.1484375,"tis_log_ratio_mean":0.012179035584267695}
+{"step":97,"reward":0.142578125,"avg_pass_at_8":0.3125,"entropy":0.028749061428243294,"grad_norm":0.051513671875,"tokens":8839.486328125,"tis_log_ratio_mean":0.012086589234968415}
+{"step":98,"reward":0.25390625,"avg_pass_at_8":0.40625,"entropy":0.027298774002701975,"grad_norm":0.04180908203125,"tokens":9277.3125,"tis_log_ratio_mean":0.01207058996806154}
+{"step":99,"reward":0.1953125,"avg_pass_at_8":0.3125,"entropy":0.02528718973917421,"grad_norm":0.03314208984375,"tokens":9087.712890625,"tis_log_ratio_mean":0.012222951369039947}
+{"step":100,"reward":0.212890625,"avg_pass_at_8":0.375,"entropy":0.02481368707231013,"grad_norm":0.04888916015625,"tokens":9057.140625,"tis_log_ratio_mean":0.012854296277510002}
+{"step":101,"reward":0.22265625,"avg_pass_at_8":0.375,"entropy":0.024845084742992185,"grad_norm":0.03515625,"tokens":8838.267578125,"tis_log_ratio_mean":0.012943789715791354}
+{"step":102,"reward":0.1796875,"avg_pass_at_8":0.328125,"entropy":0.023100286729459185,"grad_norm":0.03948974609375,"tokens":8778.7890625,"tis_log_ratio_mean":0.01172922586920322}
+{"step":103,"reward":0.1484375,"avg_pass_at_8":0.25,"entropy":0.02291044098819839,"grad_norm":0.0291748046875,"tokens":9222.0625,"tis_log_ratio_mean":0.010485118804353988}
+{"step":104,"reward":0.185546875,"avg_pass_at_8":0.34375,"entropy":0.021337949663575273,"grad_norm":0.03851318359375,"tokens":9168.283203125,"tis_log_ratio_mean":0.00943335782721988}
+{"step":105,"reward":0.1875,"avg_pass_at_8":0.34375,"entropy":0.020512918639724376,"grad_norm":0.03253173828125,"tokens":8979.609375,"tis_log_ratio_mean":0.008232188210968161}
+{"step":106,"reward":0.15234375,"avg_pass_at_8":0.25,"entropy":0.020784744549018797,"grad_norm":0.04254150390625,"tokens":9041.8828125,"tis_log_ratio_mean":0.007534047388617182}
+{"step":107,"reward":0.212890625,"avg_pass_at_8":0.375,"entropy":0.020715639744594228,"grad_norm":0.03704833984375,"tokens":9587.263671875,"tis_log_ratio_mean":0.007625855079822941}
+{"step":108,"reward":0.1953125,"avg_pass_at_8":0.328125,"entropy":0.02319042348972289,"grad_norm":0.03924560546875,"tokens":9752.072265625,"tis_log_ratio_mean":0.008176897834346164}
+{"step":109,"reward":0.244140625,"avg_pass_at_8":0.375,"entropy":0.02238455408223672,"grad_norm":0.0357666015625,"tokens":9610.7421875,"tis_log_ratio_mean":0.008344108191522537}
+{"step":110,"reward":0.19921875,"avg_pass_at_8":0.359375,"entropy":0.02211651918332791,"grad_norm":0.04931640625,"tokens":10630.197265625,"tis_log_ratio_mean":0.008396779932809295}
+{"step":111,"reward":0.21484375,"avg_pass_at_8":0.328125,"entropy":0.023869622134952806,"grad_norm":0.04449462890625,"tokens":9603.0234375,"tis_log_ratio_mean":0.009957528061931953}
+{"step":112,"reward":0.173828125,"avg_pass_at_8":0.265625,"entropy":0.02290310490934644,"grad_norm":0.034423828125,"tokens":10343.5,"tis_log_ratio_mean":0.009010585992655251}
+{"step":113,"reward":0.18359375,"avg_pass_at_8":0.296875,"entropy":0.02170805272180587,"grad_norm":0.03399658203125,"tokens":10329.326171875,"tis_log_ratio_mean":0.00844007851992501}
+{"step":114,"reward":0.31640625,"avg_pass_at_8":0.421875,"entropy":0.022855756091303192,"grad_norm":0.0362548828125,"tokens":10306.609375,"tis_log_ratio_mean":0.008500853640725836}
+{"step":115,"reward":0.1171875,"avg_pass_at_8":0.265625,"entropy":0.0217873677611351,"grad_norm":0.06939697265625,"tokens":10864.84375,"tis_log_ratio_mean":0.008366413821931928}
+{"step":116,"reward":0.33203125,"avg_pass_at_8":0.421875,"entropy":0.021444061640067957,"grad_norm":0.030609130859375,"tokens":9638.8046875,"tis_log_ratio_mean":0.008688700883794809}
+{"step":117,"reward":0.279296875,"avg_pass_at_8":0.390625,"entropy":0.021509501690161414,"grad_norm":0.04095458984375,"tokens":10569.3359375,"tis_log_ratio_mean":0.009384592554852134}
+{"step":118,"reward":0.21484375,"avg_pass_at_8":0.328125,"entropy":0.020106458068767097,"grad_norm":0.030548095703125,"tokens":9987.4140625,"tis_log_ratio_mean":0.009645613168686396}
+{"step":119,"reward":0.271484375,"avg_pass_at_8":0.40625,"entropy":0.019727750004676636,"grad_norm":0.031005859375,"tokens":11005.328125,"tis_log_ratio_mean":0.009348023195343558}
+{"step":120,"reward":0.20703125,"avg_pass_at_8":0.359375,"entropy":0.018726605470874347,"grad_norm":0.0355224609375,"tokens":11316.013671875,"tis_log_ratio_mean":0.0090948855431634}
+{"step":121,"reward":0.171875,"avg_pass_at_8":0.25,"entropy":0.018549661894212477,"grad_norm":0.023162841796875,"tokens":11738.21875,"tis_log_ratio_mean":0.00890883397005382}
+{"step":122,"reward":0.208984375,"avg_pass_at_8":0.296875,"entropy":0.017353089358948637,"grad_norm":0.022674560546875,"tokens":11436.73046875,"tis_log_ratio_mean":0.008552061837690417}
+{"step":123,"reward":0.18359375,"avg_pass_at_8":0.3125,"entropy":0.016328347330272663,"grad_norm":0.028900146484375,"tokens":11837.998046875,"tis_log_ratio_mean":0.007505549854613491}
+{"step":124,"reward":0.171875,"avg_pass_at_8":0.265625,"entropy":0.01668986696313368,"grad_norm":0.023895263671875,"tokens":12577.373046875,"tis_log_ratio_mean":0.007292221354873618}
+{"step":125,"reward":0.212890625,"avg_pass_at_8":0.359375,"entropy":0.01560962187795667,"grad_norm":0.02288818359375,"tokens":12170.55078125,"tis_log_ratio_mean":0.0067350550343689974}
+{"step":126,"reward":0.248046875,"avg_pass_at_8":0.40625,"entropy":0.015482696348044556,"grad_norm":0.027252197265625,"tokens":12163.478515625,"tis_log_ratio_mean":0.006610192500374978}
+{"step":127,"reward":0.181640625,"avg_pass_at_8":0.328125,"entropy":0.014299407914222684,"grad_norm":0.02288818359375,"tokens":12578.37109375,"tis_log_ratio_mean":0.005982442955428269}
+{"step":128,"reward":0.166015625,"avg_pass_at_8":0.375,"entropy":0.014562470947566908,"grad_norm":0.0274658203125,"tokens":12808.64453125,"tis_log_ratio_mean":0.00599842362862546}
+{"step":129,"reward":0.21484375,"avg_pass_at_8":0.40625,"entropy":0.013737520610447973,"grad_norm":0.03387451171875,"tokens":12796.728515625,"tis_log_ratio_mean":0.005632446040181094}
+{"step":130,"reward":0.146484375,"avg_pass_at_8":0.25,"entropy":0.013513566274923505,"grad_norm":0.02020263671875,"tokens":12773.41015625,"tis_log_ratio_mean":0.00586021634444478}
+{"step":131,"reward":0.166015625,"avg_pass_at_8":0.296875,"entropy":0.012879661524493713,"grad_norm":0.0299072265625,"tokens":13502.77734375,"tis_log_ratio_mean":0.0059986837823089445}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-tt-x10-fsdp2/run.json b/viewer/build/inputs/marin/runs/marin-q3c-tt-x10-fsdp2/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..b28a857b33f282615802576430806e35c5c748b2
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-tt-x10-fsdp2/run.json
@@ -0,0 +1,26 @@
+{
+ "id": "marin-q3c-tt-x10-fsdp2",
+ "title": "TaskTrove RL, FSDP2 backend (Qwen3-Coder-30B-A3B)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/laion/tt-x10-fsdp2-fa2-117-30B/tree/main/training_logs",
+ "license": "apache-2.0",
+ "model": "laion/tt-x10-fsdp2-fa2-117-30B",
+ "base_model": "Qwen/Qwen3-Coder-30B-A3B-Instruct",
+ "method": "GRPO (SkyRL + Terminus-2, pass-ratio shaped verifier reward)",
+ "dataset": "DCAgent/exp_rpt_multifile",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-09-04T16:22:37Z",
+ "attempts": 0,
+ "note": "Marin TaskTrove RL hyperparameter ablation (issue #7785) on Qwen3-Coder-30B-A3B-Instruct with DCAgent/exp_rpt_multifile tasks and the Terminus-2 harness; arm: X10b training backend: FSDP2 + FlashAttention 2, lr 8e-6, temperature 1.2. Our copy is the per-step curve Marin stitched from W&B (its trailing-EMA column left out).",
+ "metrics_map": {
+  "reward": "reward",
+  "entropy": "entropy",
+  "grad_norm": "grad_norm",
+  "response_length": "tokens"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-tt-x15-megatron/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-q3c-tt-x15-megatron/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..6fc2608da6ee493d6ee7c76949dffc8d7b3a62c1
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-tt-x15-megatron/metrics.jsonl
@@ -0,0 +1,101 @@
+{"step":1,"reward":0.208984375,"avg_pass_at_8":0.40625,"entropy":0.28380009054671973,"grad_norm":0.20195640623569489,"tokens":11957.6953125,"tis_log_ratio_mean":0.03879948745452566}
+{"step":2,"reward":0.115234375,"avg_pass_at_8":0.265625,"entropy":0.18324961440521292,"grad_norm":0.1760411113500595,"tokens":12894.6796875,"tis_log_ratio_mean":0.08047457538486924}
+{"step":3,"reward":0.140625,"avg_pass_at_8":0.28125,"entropy":0.15693244856083766,"grad_norm":0.0973483994603157,"tokens":12006.486328125,"tis_log_ratio_mean":0.040257213353470434}
+{"step":4,"reward":0.13671875,"avg_pass_at_8":0.234375,"entropy":0.13055996870389208,"grad_norm":0.08374636620283127,"tokens":11356.103515625,"tis_log_ratio_mean":0.031027401058963733}
+{"step":5,"reward":0.12109375,"avg_pass_at_8":0.171875,"entropy":0.10914250410860404,"grad_norm":0.0662873163819313,"tokens":10752.634765625,"tis_log_ratio_mean":0.026213129080133513}
+{"step":6,"reward":0.201171875,"avg_pass_at_8":0.359375,"entropy":0.0992232505523134,"grad_norm":0.055875904858112335,"tokens":10838.822265625,"tis_log_ratio_mean":0.040491714818926994}
+{"step":7,"reward":0.220703125,"avg_pass_at_8":0.359375,"entropy":0.08605229249224067,"grad_norm":0.052110519260168076,"tokens":10235.841796875,"tis_log_ratio_mean":0.03386010333633749}
+{"step":8,"reward":0.150390625,"avg_pass_at_8":0.34375,"entropy":0.0795121548435418,"grad_norm":0.0495506152510643,"tokens":10783.67578125,"tis_log_ratio_mean":0.02351990335591836}
+{"step":9,"reward":0.158203125,"avg_pass_at_8":0.265625,"entropy":0.06820493974373676,"grad_norm":0.039372142404317856,"tokens":11311.109375,"tis_log_ratio_mean":0.024784139131952543}
+{"step":10,"reward":0.189453125,"avg_pass_at_8":0.296875,"entropy":0.06720394286094233,"grad_norm":0.032950326800346375,"tokens":10775.3671875,"tis_log_ratio_mean":0.02816865162094473}
+{"step":11,"reward":0.138671875,"avg_pass_at_8":0.234375,"entropy":0.059770767868030816,"grad_norm":0.03556487336754799,"tokens":10556.32421875,"tis_log_ratio_mean":0.023838659817556618}
+{"step":12,"reward":0.1328125,"avg_pass_at_8":0.25,"entropy":0.057798539637587965,"grad_norm":0.030953196808695793,"tokens":10504.240234375,"tis_log_ratio_mean":0.028407111112755956}
+{"step":13,"reward":0.1640625,"avg_pass_at_8":0.328125,"entropy":0.05396210770413745,"grad_norm":0.038232702761888504,"tokens":10968.626953125,"tis_log_ratio_mean":0.02425438290083548}
+{"step":14,"reward":0.171875,"avg_pass_at_8":0.328125,"entropy":0.05111169814335881,"grad_norm":0.04912637919187546,"tokens":10553.677734375,"tis_log_ratio_mean":0.01996984917059308}
+{"step":15,"reward":0.119140625,"avg_pass_at_8":0.25,"entropy":0.04949884647066938,"grad_norm":0.029686804860830307,"tokens":10711.8125,"tis_log_ratio_mean":0.022283174423137098}
+{"step":16,"reward":0.142578125,"avg_pass_at_8":0.25,"entropy":0.0478212947564316,"grad_norm":0.03400680795311928,"tokens":12657.220703125,"tis_log_ratio_mean":0.021065440352685982}
+{"step":17,"reward":0.232421875,"avg_pass_at_8":0.421875,"entropy":0.047510785767372,"grad_norm":0.0400405079126358,"tokens":11585.21484375,"tis_log_ratio_mean":0.01808502074527496}
+{"step":18,"reward":0.177734375,"avg_pass_at_8":0.328125,"entropy":0.046791273438429926,"grad_norm":0.035172123461961746,"tokens":11229.455078125,"tis_log_ratio_mean":0.020748747818288393}
+{"step":19,"reward":0.1484375,"avg_pass_at_8":0.34375,"entropy":0.04391411290271208,"grad_norm":0.03131328895688057,"tokens":11505.431640625,"tis_log_ratio_mean":0.018782067854772322}
+{"step":20,"reward":0.146484375,"avg_pass_at_8":0.234375,"entropy":0.037673404531233246,"grad_norm":0.027123216539621353,"tokens":12338.1328125,"tis_log_ratio_mean":0.01719331451022299}
+{"step":21,"reward":0.193359375,"avg_pass_at_8":0.328125,"entropy":0.035175977704057004,"grad_norm":0.028621729463338852,"tokens":12146.90625,"tis_log_ratio_mean":0.018719438132393407}
+{"step":22,"reward":0.14453125,"avg_pass_at_8":0.296875,"entropy":0.03437250474235043,"grad_norm":0.02626977488398552,"tokens":11635.396484375,"tis_log_ratio_mean":0.016605473649178748}
+{"step":23,"reward":0.201171875,"avg_pass_at_8":0.359375,"entropy":0.03006787772028474,"grad_norm":0.02914234809577465,"tokens":12961.05859375,"tis_log_ratio_mean":0.014169360549203702}
+{"step":24,"reward":0.16015625,"avg_pass_at_8":0.296875,"entropy":0.03030111043517536,"grad_norm":0.025229381397366524,"tokens":11709.1875,"tis_log_ratio_mean":0.016277045840979554}
+{"step":25,"reward":0.15625,"avg_pass_at_8":0.234375,"entropy":0.034945957182571874,"grad_norm":0.02751891501247883,"tokens":13984.34375,"tis_log_ratio_mean":0.019390785493669682}
+{"step":26,"reward":0.146484375,"avg_pass_at_8":0.25,"entropy":0.027067872822954087,"grad_norm":0.023381037637591362,"tokens":14325.361328125,"tis_log_ratio_mean":0.013600780663182377}
+{"step":27,"reward":0.1953125,"avg_pass_at_8":0.34375,"entropy":0.02622751688977587,"grad_norm":0.025417208671569824,"tokens":13526.552734375,"tis_log_ratio_mean":0.013845963384483184}
+{"step":28,"reward":0.22265625,"avg_pass_at_8":0.40625,"entropy":0.02686344806352281,"grad_norm":0.026991698890924454,"tokens":12715.685546875,"tis_log_ratio_mean":0.013580091088442714}
+{"step":29,"reward":0.18359375,"avg_pass_at_8":0.3125,"entropy":0.027546874021936674,"grad_norm":0.027726875618100166,"tokens":13227.87890625,"tis_log_ratio_mean":0.015239666638080962}
+{"step":30,"reward":0.177734375,"avg_pass_at_8":0.296875,"entropy":0.026558556372037856,"grad_norm":0.026201946660876274,"tokens":13108.8203125,"tis_log_ratio_mean":0.014960829257688602}
+{"step":31,"reward":0.275390625,"avg_pass_at_8":0.453125,"entropy":0.02491572662984254,"grad_norm":0.03018501028418541,"tokens":14046.927734375,"tis_log_ratio_mean":0.01332841400471807}
+{"step":32,"reward":0.18359375,"avg_pass_at_8":0.3125,"entropy":0.023597900850290898,"grad_norm":0.030108008533716202,"tokens":15153.35546875,"tis_log_ratio_mean":0.01289054514199961}
+{"step":33,"reward":0.205078125,"avg_pass_at_8":0.375,"entropy":0.022782319501857273,"grad_norm":0.026987791061401367,"tokens":13900.43359375,"tis_log_ratio_mean":0.013242687222373206}
+{"step":34,"reward":0.150390625,"avg_pass_at_8":0.265625,"entropy":0.02198731954217692,"grad_norm":0.025769177824258804,"tokens":14393.548828125,"tis_log_ratio_mean":0.012399274958966089}
+{"step":35,"reward":0.212890625,"avg_pass_at_8":0.328125,"entropy":0.022274382772593526,"grad_norm":0.022737322375178337,"tokens":15026.42578125,"tis_log_ratio_mean":0.011683876431561657}
+{"step":36,"reward":0.162109375,"avg_pass_at_8":0.328125,"entropy":0.02151524323198828,"grad_norm":0.026578430086374283,"tokens":15314.123046875,"tis_log_ratio_mean":0.011316415322653484}
+{"step":37,"reward":0.216796875,"avg_pass_at_8":0.34375,"entropy":0.020070513177415705,"grad_norm":0.031216923147439957,"tokens":14620.84375,"tis_log_ratio_mean":0.010617028958222363}
+{"step":38,"reward":0.271484375,"avg_pass_at_8":0.453125,"entropy":0.019342027647326177,"grad_norm":0.030968215316534042,"tokens":14905.142578125,"tis_log_ratio_mean":0.010256622203087318}
+{"step":39,"reward":0.224609375,"avg_pass_at_8":0.390625,"entropy":0.019655574318676372,"grad_norm":0.02511611580848694,"tokens":15209.525390625,"tis_log_ratio_mean":0.010830225144673022}
+{"step":40,"reward":0.240234375,"avg_pass_at_8":0.375,"entropy":0.019524238567100838,"grad_norm":0.024492397904396057,"tokens":15218.685546875,"tis_log_ratio_mean":0.010586443410829816}
+{"step":41,"reward":0.18359375,"avg_pass_at_8":0.296875,"entropy":0.01956303241149726,"grad_norm":0.02695755660533905,"tokens":15683.1796875,"tis_log_ratio_mean":0.010300105025635276}
+{"step":42,"reward":0.134765625,"avg_pass_at_8":0.28125,"entropy":0.019306482887714083,"grad_norm":0.0217769555747509,"tokens":15135.251953125,"tis_log_ratio_mean":0.010191034092258633}
+{"step":43,"reward":0.21484375,"avg_pass_at_8":0.296875,"entropy":0.01947490777092753,"grad_norm":0.024594906717538834,"tokens":14987.998046875,"tis_log_ratio_mean":0.010296048583768425}
+{"step":44,"reward":0.14453125,"avg_pass_at_8":0.25,"entropy":0.020008591887744842,"grad_norm":0.021484268829226494,"tokens":13937.09765625,"tis_log_ratio_mean":0.01109534449824423}
+{"step":45,"reward":0.08203125,"avg_pass_at_8":0.125,"entropy":0.018497942000976764,"grad_norm":0.017940938472747803,"tokens":15377.01953125,"tis_log_ratio_mean":0.010187213998506195}
+{"step":46,"reward":0.16015625,"avg_pass_at_8":0.265625,"entropy":0.0180558448219017,"grad_norm":0.023389659821987152,"tokens":15197.205078125,"tis_log_ratio_mean":0.009801067089938442}
+{"step":47,"reward":0.228515625,"avg_pass_at_8":0.421875,"entropy":0.017513232594865258,"grad_norm":0.02789674699306488,"tokens":15983.25,"tis_log_ratio_mean":0.009791816185497737}
+{"step":48,"reward":0.23046875,"avg_pass_at_8":0.390625,"entropy":0.01702760207672327,"grad_norm":0.02901029773056507,"tokens":15627.125,"tis_log_ratio_mean":0.009561383883010421}
+{"step":49,"reward":0.20703125,"avg_pass_at_8":0.3125,"entropy":0.017318538779818482,"grad_norm":0.020607849583029747,"tokens":14943.44921875,"tis_log_ratio_mean":0.010215631610662967}
+{"step":50,"reward":0.189453125,"avg_pass_at_8":0.28125,"entropy":0.018237074678836507,"grad_norm":0.024501772597432137,"tokens":14884.583984375,"tis_log_ratio_mean":0.010509410354643478}
+{"step":51,"reward":0.244140625,"avg_pass_at_8":0.421875,"entropy":0.019424339329816576,"grad_norm":0.04047199711203575,"tokens":14745.19921875,"tis_log_ratio_mean":0.010038193337095436}
+{"step":52,"reward":0.150390625,"avg_pass_at_8":0.265625,"entropy":0.06501297822433116,"grad_norm":0.03430159389972687,"tokens":13412.27734375,"tis_log_ratio_mean":0.04482977876250516}
+{"step":53,"reward":0.19921875,"avg_pass_at_8":0.375,"entropy":0.029081797672915854,"grad_norm":0.0413086824119091,"tokens":13819.90625,"tis_log_ratio_mean":0.04973612193316512}
+{"step":54,"reward":0.240234375,"avg_pass_at_8":0.359375,"entropy":0.021708972970372997,"grad_norm":0.021884219720959663,"tokens":13132.80859375,"tis_log_ratio_mean":0.06473713517698343}
+{"step":55,"reward":0.126953125,"avg_pass_at_8":0.265625,"entropy":0.01730329568090383,"grad_norm":0.0220363549888134,"tokens":13841.787109375,"tis_log_ratio_mean":0.012940252210682957}
+{"step":56,"reward":0.134765625,"avg_pass_at_8":0.265625,"entropy":0.015859588795137824,"grad_norm":0.01752507872879505,"tokens":14798.53515625,"tis_log_ratio_mean":0.009623677470699477}
+{"step":57,"reward":0.1328125,"avg_pass_at_8":0.25,"entropy":0.015599822476360714,"grad_norm":0.01599693112075329,"tokens":13839.533203125,"tis_log_ratio_mean":0.009627907483263698}
+{"step":58,"reward":0.083984375,"avg_pass_at_8":0.203125,"entropy":0.014008130634465488,"grad_norm":0.015376968309283257,"tokens":12856.60546875,"tis_log_ratio_mean":0.00812156598749425}
+{"step":59,"reward":0.05078125,"avg_pass_at_8":0.15625,"entropy":0.013305543288879562,"grad_norm":0.013282292522490025,"tokens":12804.419921875,"tis_log_ratio_mean":0.007885103695116413}
+{"step":60,"reward":0.080078125,"avg_pass_at_8":0.1875,"entropy":0.013582145929831313,"grad_norm":0.014613457955420017,"tokens":13667.490234375,"tis_log_ratio_mean":0.008013823374312778}
+{"step":61,"reward":0.091796875,"avg_pass_at_8":0.203125,"entropy":0.014827042250544764,"grad_norm":0.013647147454321384,"tokens":13353.837890625,"tis_log_ratio_mean":0.008521898822436924}
+{"step":62,"reward":0.142578125,"avg_pass_at_8":0.234375,"entropy":0.014874127516122826,"grad_norm":0.014650963246822357,"tokens":13697.2421875,"tis_log_ratio_mean":0.008342467674992804}
+{"step":63,"reward":0.09375,"avg_pass_at_8":0.265625,"entropy":0.014775633096178353,"grad_norm":0.013611107133328915,"tokens":13763.412109375,"tis_log_ratio_mean":0.008059417741606012}
+{"step":64,"reward":0.111328125,"avg_pass_at_8":0.21875,"entropy":0.015684132975366083,"grad_norm":0.01736508123576641,"tokens":13141.935546875,"tis_log_ratio_mean":0.008590416489823838}
+{"step":65,"reward":0.095703125,"avg_pass_at_8":0.1875,"entropy":0.014850527240923839,"grad_norm":0.01192401722073555,"tokens":13143.5390625,"tis_log_ratio_mean":0.008769816534368147}
+{"step":66,"reward":0.1171875,"avg_pass_at_8":0.328125,"entropy":0.0131793683858632,"grad_norm":0.019544003531336784,"tokens":13002.341796875,"tis_log_ratio_mean":0.007673890992009547}
+{"step":67,"reward":0.095703125,"avg_pass_at_8":0.21875,"entropy":0.011721476694219746,"grad_norm":0.01832517422735691,"tokens":12023.30859375,"tis_log_ratio_mean":0.007435109231664683}
+{"step":68,"reward":0.10546875,"avg_pass_at_8":0.28125,"entropy":0.013029860050664865,"grad_norm":0.014709926210343838,"tokens":13366.576171875,"tis_log_ratio_mean":0.008103573467451497}
+{"step":69,"reward":0.095703125,"avg_pass_at_8":0.1875,"entropy":0.013776918771327473,"grad_norm":0.0132818054407835,"tokens":14198.638671875,"tis_log_ratio_mean":0.008552698302082717}
+{"step":70,"reward":0.08203125,"avg_pass_at_8":0.21875,"entropy":0.013082287365250522,"grad_norm":0.013494989834725857,"tokens":13854.41796875,"tis_log_ratio_mean":0.00775652703941887}
+{"step":71,"reward":0.12890625,"avg_pass_at_8":0.25,"entropy":0.01257556774362456,"grad_norm":0.014938576146960258,"tokens":14066.126953125,"tis_log_ratio_mean":0.007207598023342143}
+{"step":72,"reward":0.06640625,"avg_pass_at_8":0.234375,"entropy":0.012152429171692347,"grad_norm":0.013156929984688759,"tokens":14561.115234375,"tis_log_ratio_mean":0.007443324982887134}
+{"step":73,"reward":0.095703125,"avg_pass_at_8":0.25,"entropy":0.01166447547984717,"grad_norm":0.01610151119530201,"tokens":13685.494140625,"tis_log_ratio_mean":0.006867967626931204}
+{"step":74,"reward":0.1328125,"avg_pass_at_8":0.25,"entropy":0.011587170273742231,"grad_norm":0.017074616625905037,"tokens":13497.849609375,"tis_log_ratio_mean":0.007014049957888346}
+{"step":75,"reward":0.078125,"avg_pass_at_8":0.203125,"entropy":0.010882317621508264,"grad_norm":0.017167704179883003,"tokens":13300.873046875,"tis_log_ratio_mean":0.006594639553441084}
+{"step":76,"reward":0.095703125,"avg_pass_at_8":0.15625,"entropy":0.011490128739751526,"grad_norm":0.013622788712382317,"tokens":14515.5234375,"tis_log_ratio_mean":0.006766945659364865}
+{"step":77,"reward":0.083984375,"avg_pass_at_8":0.203125,"entropy":0.011007365490513621,"grad_norm":0.014603457413613796,"tokens":12801.55078125,"tis_log_ratio_mean":0.006185150935380079}
+{"step":78,"reward":0.029296875,"avg_pass_at_8":0.078125,"entropy":0.010783515261209686,"grad_norm":0.010431727394461632,"tokens":13792.759765625,"tis_log_ratio_mean":0.007173382323344413}
+{"step":79,"reward":0.025390625,"avg_pass_at_8":0.078125,"entropy":0.009709339030450792,"grad_norm":0.012834833934903145,"tokens":10749.4140625,"tis_log_ratio_mean":0.005043381663199398}
+{"step":80,"reward":0.01171875,"avg_pass_at_8":0.09375,"entropy":0.005842892507644137,"grad_norm":0.013382860459387302,"tokens":9077.505859375,"tis_log_ratio_mean":0.0031812634838388476}
+{"step":81,"reward":0.009765625,"avg_pass_at_8":0.046875,"entropy":0.004876266244536964,"grad_norm":0.0124436030164361,"tokens":8178.64453125,"tis_log_ratio_mean":0.003160090742767352}
+{"step":82,"reward":0.0078125,"avg_pass_at_8":0.046875,"entropy":0.004734864871352329,"grad_norm":0.010083426721394062,"tokens":8307.58203125,"tis_log_ratio_mean":0.002627384877541772}
+{"step":83,"reward":0.017578125,"avg_pass_at_8":0.03125,"entropy":0.004628976187632361,"grad_norm":0.00922521110624075,"tokens":8142.046875,"tis_log_ratio_mean":0.002568632257862191}
+{"step":84,"reward":0.0,"avg_pass_at_8":0.0,"entropy":0.004764419196362724,"grad_norm":0.008718364872038364,"tokens":8368.6328125,"tis_log_ratio_mean":0.0031707382072454493}
+{"step":85,"reward":0.005859375,"avg_pass_at_8":0.046875,"entropy":0.0045769202670271625,"grad_norm":0.01027734950184822,"tokens":8037.625,"tis_log_ratio_mean":0.0025995669832354906}
+{"step":86,"reward":0.0,"avg_pass_at_8":0.0,"entropy":0.005000907969588297,"grad_norm":0.00927400216460228,"tokens":8412.037109375,"tis_log_ratio_mean":0.0026737586770195776}
+{"step":87,"reward":0.01953125,"avg_pass_at_8":0.046875,"entropy":0.0052621469667428755,"grad_norm":0.009100525639951229,"tokens":8270.173828125,"tis_log_ratio_mean":0.002948913346926929}
+{"step":88,"reward":0.01171875,"avg_pass_at_8":0.046875,"entropy":0.005899567382584792,"grad_norm":0.009215905331075191,"tokens":8804.10546875,"tis_log_ratio_mean":0.003219244339106808}
+{"step":89,"reward":0.03125,"avg_pass_at_8":0.125,"entropy":0.006737047274327779,"grad_norm":0.00983156356960535,"tokens":9199.109375,"tis_log_ratio_mean":0.0034877278890235175}
+{"step":90,"reward":0.017578125,"avg_pass_at_8":0.046875,"entropy":0.007792984229126887,"grad_norm":0.008721471764147282,"tokens":8973.79296875,"tis_log_ratio_mean":0.004256129757322924}
+{"step":91,"reward":0.029296875,"avg_pass_at_8":0.109375,"entropy":0.007726218957031961,"grad_norm":0.010015777312219143,"tokens":8897.896484375,"tis_log_ratio_mean":0.003926137936559826}
+{"step":92,"reward":0.009765625,"avg_pass_at_8":0.046875,"entropy":0.007923210539956926,"grad_norm":0.008899352513253689,"tokens":8843.322265625,"tis_log_ratio_mean":0.004391970237520582}
+{"step":93,"reward":0.021484375,"avg_pass_at_8":0.109375,"entropy":0.007826762632248574,"grad_norm":0.00953613966703415,"tokens":8713.794921875,"tis_log_ratio_mean":0.005461695624944696}
+{"step":94,"reward":0.03515625,"avg_pass_at_8":0.0625,"entropy":0.0063756551271580975,"grad_norm":0.009874533861875534,"tokens":8322.857421875,"tis_log_ratio_mean":0.003692385547765298}
+{"step":95,"reward":0.0078125,"avg_pass_at_8":0.03125,"entropy":0.006243172675567621,"grad_norm":0.00907274428755045,"tokens":8002.880859375,"tis_log_ratio_mean":0.0033519496157623507}
+{"step":96,"reward":0.01953125,"avg_pass_at_8":0.046875,"entropy":0.005606744040960621,"grad_norm":0.008685912936925888,"tokens":7674.302734375,"tis_log_ratio_mean":0.0034769170592880982}
+{"step":97,"reward":0.015625,"avg_pass_at_8":0.0625,"entropy":0.005897639412069111,"grad_norm":0.007625251077115536,"tokens":7617.8046875,"tis_log_ratio_mean":0.0028614974348784017}
+{"step":98,"reward":0.01953125,"avg_pass_at_8":0.046875,"entropy":0.005992065715872741,"grad_norm":0.006407018285244703,"tokens":7630.611328125,"tis_log_ratio_mean":0.002722906548569881}
+{"step":99,"reward":0.0078125,"avg_pass_at_8":0.0625,"entropy":0.006267066774853447,"grad_norm":0.006610449869185686,"tokens":7877.609375,"tis_log_ratio_mean":0.0031985354089556495}
+{"step":100,"reward":0.005859375,"avg_pass_at_8":0.03125,"entropy":0.005822780703056196,"grad_norm":0.007009792607277632,"tokens":7668.25390625,"tis_log_ratio_mean":0.002807933654366934}
+{"step":101,"reward":0.041015625,"avg_pass_at_8":0.078125,"entropy":0.005608550804936385,"grad_norm":0.008033922873437405,"tokens":7613.501953125,"tis_log_ratio_mean":0.0026493279283386073}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-tt-x15-megatron/run.json b/viewer/build/inputs/marin/runs/marin-q3c-tt-x15-megatron/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..52c92a8d3e1981816792ab05e2c43a126aa70409
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-tt-x15-megatron/run.json
@@ -0,0 +1,26 @@
+{
+ "id": "marin-q3c-tt-x15-megatron",
+ "title": "TaskTrove RL, Megatron backend, collapsed (Qwen3-Coder-30B-A3B)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/laion/tt-x15-megatron-51-30B/tree/main/training_logs",
+ "license": "apache-2.0",
+ "model": "laion/tt-x15-megatron-51-30B",
+ "base_model": "Qwen/Qwen3-Coder-30B-A3B-Instruct",
+ "method": "GRPO (SkyRL + Terminus-2, pass-ratio shaped verifier reward)",
+ "dataset": "DCAgent/exp_rpt_multifile",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-09-04T16:22:40Z",
+ "attempts": 0,
+ "note": "Marin TaskTrove RL hyperparameter ablation (issue #7785) on Qwen3-Coder-30B-A3B-Instruct with DCAgent/exp_rpt_multifile tasks and the Terminus-2 harness; arm: X15 Megatron backend with lr 8e-6, lower clip 0.3 and temperature 1.2, an attempt to prevent an earlier Megatron arm's late collapse; Marin marks it collapsed (reward fell to about 0 at steps 84 to 86). Our copy is the per-step curve Marin stitched from W&B (its trailing-EMA column left out).",
+ "metrics_map": {
+  "reward": "reward",
+  "entropy": "entropy",
+  "grad_norm": "grad_norm",
+  "response_length": "tokens"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-tt-x3-kl0p001/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-q3c-tt-x3-kl0p001/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..de18145c02feec2402c584748fe498355f362d88
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-tt-x3-kl0p001/metrics.jsonl
@@ -0,0 +1,75 @@
+{"step":1,"async/staleness_mean":0.0,"generate/avg_num_tokens":11520.150390625,"generate/avg_tokens_non_zero_rewards":10283.037037037036,"generate/avg_tokens_zero_rewards":11752.647331786542,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24133,"generate/std_num_tokens":3174.1665316649714,"loss/avg_final_rewards":0.158203125,"loss/avg_raw_advantages":-0.004655978176742792,"loss/avg_raw_advantages_abs":0.1155080571770668,"policy/policy_entropy":0.12057892512530088,"policy/policy_kl":0.011378814902855083,"policy/policy_loss":1.479408282989425e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.0065977229714917485,"policy/raw_grad_norm":0.0009613037109375,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.158203125,"reward/policy_ref_kl":0.011411887593567371,"timing/step":5360.391353664978,"trainer/epoch":0}
+{"step":2,"async/staleness_mean":0.96875,"generate/avg_num_tokens":12130.35546875,"generate/avg_tokens_non_zero_rewards":12249.4375,"generate/avg_tokens_zero_rewards":12113.34375,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":29231,"generate/std_num_tokens":3616.652141080127,"loss/avg_final_rewards":0.125,"loss/avg_raw_advantages":-0.0023999004624783993,"loss/avg_raw_advantages_abs":0.04737769812345505,"policy/policy_entropy":0.1314482360612601,"policy/policy_kl":0.010211955945123918,"policy/policy_loss":2.088674577294114e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.0032432157549919793,"policy/raw_grad_norm":0.001171112060546875,"reward/avg_pass_at_8":0.1875,"reward/avg_raw_reward":0.125,"reward/policy_ref_kl":0.01015262771397829,"timing/step":2362.740868670022,"trainer/epoch":0}
+{"step":3,"async/staleness_mean":1.515625,"generate/avg_num_tokens":11949.158203125,"generate/avg_tokens_non_zero_rewards":10437.015384615384,"generate/avg_tokens_zero_rewards":12169.044742729306,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":23772,"generate/std_num_tokens":3307.467880662244,"loss/avg_final_rewards":0.126953125,"loss/avg_raw_advantages":-0.0015606010565534234,"loss/avg_raw_advantages_abs":0.07942964136600494,"policy/policy_entropy":0.13389885774813592,"policy/policy_kl":0.00930634442192968,"policy/policy_loss":7.357469868907174e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.004376971557576326,"policy/raw_grad_norm":0.0009164810180664062,"reward/avg_pass_at_8":0.234375,"reward/avg_raw_reward":0.126953125,"reward/policy_ref_kl":0.009207329712808132,"timing/step":2865.7047030749964,"trainer/epoch":0}
+{"step":4,"async/staleness_mean":0.625,"generate/avg_num_tokens":12177.072265625,"generate/avg_tokens_non_zero_rewards":11653.55357142857,"generate/avg_tokens_zero_rewards":12323.6575,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30226,"generate/std_num_tokens":3760.3423205639874,"loss/avg_final_rewards":0.21875,"loss/avg_raw_advantages":-0.002428284380584955,"loss/avg_raw_advantages_abs":0.12967264652252197,"policy/policy_entropy":0.14373120106756687,"policy/policy_kl":0.009528914582915604,"policy/policy_loss":6.66695314066601e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008088960392342415,"policy/raw_grad_norm":0.0007610321044921875,"reward/avg_pass_at_8":0.3269230769230769,"reward/avg_raw_reward":0.21875,"reward/policy_ref_kl":0.009471283294260502,"timing/step":4825.538106569991,"trainer/epoch":0}
+{"step":5,"async/staleness_mean":0.984375,"generate/avg_num_tokens":13186.36328125,"generate/avg_tokens_non_zero_rewards":12721.5,"generate/avg_tokens_zero_rewards":13236.67316017316,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26507,"generate/std_num_tokens":4120.369872664101,"loss/avg_final_rewards":0.09765625,"loss/avg_raw_advantages":-0.0022999641951173544,"loss/avg_raw_advantages_abs":0.10895732045173645,"policy/policy_entropy":0.14602772565558553,"policy/policy_kl":0.009254388263798319,"policy/policy_loss":1.5198289133877552e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.004555513134619105,"policy/raw_grad_norm":0.0009555816650390625,"reward/avg_pass_at_8":0.234375,"reward/avg_raw_reward":0.09765625,"reward/policy_ref_kl":0.009296870790421963,"timing/step":2336.7251445800066,"trainer/epoch":0}
+{"step":7,"async/staleness_mean":0.59375,"generate/avg_num_tokens":12402.6796875,"generate/avg_tokens_non_zero_rewards":11121.279411764706,"generate/avg_tokens_zero_rewards":12598.93018018018,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24931,"generate/std_num_tokens":3682.4973617471746,"loss/avg_final_rewards":0.1328125,"loss/avg_raw_advantages":-9.09359150682576e-05,"loss/avg_raw_advantages_abs":0.09268297255039215,"policy/policy_entropy":0.1535300884861499,"policy/policy_kl":0.009366340120323002,"policy/policy_loss":7.232201930662541e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006652169173321454,"policy/raw_grad_norm":0.00067138671875,"reward/avg_pass_at_8":0.2830188679245283,"reward/avg_raw_reward":0.1328125,"reward/policy_ref_kl":0.009449854493141174,"timing/step":5680.3754920979845,"trainer/epoch":0}
+{"step":8,"async/staleness_mean":1.0,"generate/avg_num_tokens":12703.255859375,"generate/avg_tokens_non_zero_rewards":11361.797101449276,"generate/avg_tokens_zero_rewards":13198.232620320856,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25080,"generate/std_num_tokens":4218.916626682181,"loss/avg_final_rewards":0.26953125,"loss/avg_raw_advantages":-0.00150024495087564,"loss/avg_raw_advantages_abs":0.1288275569677353,"policy/policy_entropy":0.1594758138526231,"policy/policy_kl":0.009739218265167437,"policy/policy_loss":6.705167088227881e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007151501808039029,"policy/raw_grad_norm":0.0007829666137695312,"reward/avg_pass_at_8":0.453125,"reward/avg_raw_reward":0.26953125,"reward/policy_ref_kl":0.00981323141604662,"timing/step":2529.278858130012,"trainer/epoch":0}
+{"step":9,"async/staleness_mean":1.5,"generate/avg_num_tokens":12213.91796875,"generate/avg_tokens_non_zero_rewards":10949.69,"generate/avg_tokens_zero_rewards":12520.769417475729,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27445,"generate/std_num_tokens":3986.414058279963,"loss/avg_final_rewards":0.1953125,"loss/avg_raw_advantages":-0.0021864010486751795,"loss/avg_raw_advantages_abs":0.12060174345970154,"policy/policy_entropy":0.164930478669703,"policy/policy_kl":0.010383207249105908,"policy/policy_loss":1.6173328774016227e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00635735374999058,"policy/raw_grad_norm":0.0007534027099609375,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.1953125,"reward/policy_ref_kl":0.010384080931544304,"timing/step":2593.0344647429883,"trainer/epoch":0}
+{"step":10,"async/staleness_mean":1.796875,"generate/avg_num_tokens":12446.64453125,"generate/avg_tokens_non_zero_rewards":11086.1125,"generate/avg_tokens_zero_rewards":12698.594907407407,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26786,"generate/std_num_tokens":4062.766223321337,"loss/avg_final_rewards":0.15625,"loss/avg_raw_advantages":0.0003447741037234664,"loss/avg_raw_advantages_abs":0.09824231266975403,"policy/policy_entropy":0.170739711727947,"policy/policy_kl":0.01077629512292333,"policy/policy_loss":1.3042485917935664e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006561215333931614,"policy/raw_grad_norm":0.0006866455078125,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.15625,"reward/policy_ref_kl":0.010884546674787998,"timing/step":2607.6530492189922,"trainer/epoch":0}
+{"step":11,"async/staleness_mean":1.734375,"generate/avg_num_tokens":12828.693359375,"generate/avg_tokens_non_zero_rewards":10499.039603960397,"generate/avg_tokens_zero_rewards":13401.187347931873,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25531,"generate/std_num_tokens":4329.152854227765,"loss/avg_final_rewards":0.197265625,"loss/avg_raw_advantages":-0.0028160614892840385,"loss/avg_raw_advantages_abs":0.09344282001256943,"policy/policy_entropy":0.1708759746979922,"policy/policy_kl":0.01105841840035282,"policy/policy_loss":1.873289072307216e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.0067140512428522925,"policy/raw_grad_norm":0.0007772445678710938,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.197265625,"reward/policy_ref_kl":0.011041730642318726,"timing/step":3293.791356369009,"trainer/epoch":0}
+{"step":12,"async/staleness_mean":0.59375,"generate/avg_num_tokens":14282.462890625,"generate/avg_tokens_non_zero_rewards":12157.8125,"generate/avg_tokens_zero_rewards":14772.766826923076,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":28449,"generate/std_num_tokens":5050.1083271362,"loss/avg_final_rewards":0.1875,"loss/avg_raw_advantages":-0.0003190449206158519,"loss/avg_raw_advantages_abs":0.12273643165826797,"policy/policy_entropy":0.1737018742132932,"policy/policy_kl":0.01136889161716681,"policy/policy_loss":2.716034607885831e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009474808177401428,"policy/raw_grad_norm":0.0006437301635742188,"reward/avg_pass_at_8":0.2916666666666667,"reward/avg_raw_reward":0.1875,"reward/policy_ref_kl":0.011390856467187405,"timing/step":3895.7628284870007,"trainer/epoch":0}
+{"step":13,"async/staleness_mean":0.984375,"generate/avg_num_tokens":13343.310546875,"generate/avg_tokens_non_zero_rewards":11512.985294117647,"generate/avg_tokens_zero_rewards":13623.63063063063,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26996,"generate/std_num_tokens":4827.6946660208605,"loss/avg_final_rewards":0.1328125,"loss/avg_raw_advantages":0.002555670216679573,"loss/avg_raw_advantages_abs":0.09375318884849548,"policy/policy_entropy":0.1716453975532204,"policy/policy_kl":0.011846716020954773,"policy/policy_loss":-1.5221991134239943e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00539899025716295,"policy/raw_grad_norm":0.0007801055908203125,"reward/avg_pass_at_8":0.25,"reward/avg_raw_reward":0.1328125,"reward/policy_ref_kl":0.011785060167312622,"timing/step":2333.01166681599,"trainer/epoch":0}
+{"step":14,"async/staleness_mean":1.265625,"generate/avg_num_tokens":13112.001953125,"generate/avg_tokens_non_zero_rewards":12019.342592592593,"generate/avg_tokens_zero_rewards":13404.09900990099,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27977,"generate/std_num_tokens":4519.398179868566,"loss/avg_final_rewards":0.2109375,"loss/avg_raw_advantages":-0.00024403379939030856,"loss/avg_raw_advantages_abs":0.1029505655169487,"policy/policy_entropy":0.180516378255561,"policy/policy_kl":0.012922705325763673,"policy/policy_loss":2.644551653219196e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00883393854564929,"policy/raw_grad_norm":0.00063323974609375,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.2109375,"reward/policy_ref_kl":0.012995418161153793,"timing/step":2226.93960427001,"trainer/epoch":0}
+{"step":15,"async/staleness_mean":2.953125,"generate/avg_num_tokens":590.986328125,"generate/avg_tokens_non_zero_rewards":10815.166666666666,"generate/avg_tokens_zero_rewards":469.7509881422925,"generate/failed_trajectory_fraction":0.953125,"generate/max_num_tokens":25927,"generate/std_num_tokens":2886.1717551462016,"loss/avg_final_rewards":0.01171875,"loss/avg_raw_advantages":-0.030360322445631027,"loss/avg_raw_advantages_abs":0.15290628373622894,"policy/policy_entropy":0.00837914140720386,"policy/policy_kl":0.0006221270996320527,"policy/policy_loss":2.948053270301898e-05,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.000583669519983232,"policy/raw_grad_norm":0.004241943359375,"reward/avg_pass_at_8":0.015625,"reward/avg_raw_reward":0.01171875,"reward/policy_ref_kl":0.0006309784948825836,"timing/step":587.5361071719963,"trainer/epoch":0}
+{"step":16,"async/staleness_mean":1.921875,"generate/avg_num_tokens":9451.427734375,"generate/avg_tokens_non_zero_rewards":12487.6,"generate/avg_tokens_zero_rewards":9158.86295503212,"generate/failed_trajectory_fraction":0.296875,"generate/max_num_tokens":26843,"generate/std_num_tokens":7714.8902051545865,"loss/avg_final_rewards":0.087890625,"loss/avg_raw_advantages":-0.012057358399033546,"loss/avg_raw_advantages_abs":0.07266092300415039,"policy/policy_entropy":0.13196935725864023,"policy/policy_kl":0.010434669879032299,"policy/policy_loss":1.0351788397144901e-05,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.002872511637633579,"policy/raw_grad_norm":0.0009679794311523438,"reward/avg_pass_at_8":0.25,"reward/avg_raw_reward":0.087890625,"reward/policy_ref_kl":0.010366416536271572,"timing/step":3355.813335865998,"trainer/epoch":0}
+{"step":17,"async/staleness_mean":1.296875,"generate/avg_num_tokens":13019.73046875,"generate/avg_tokens_non_zero_rewards":11584.86170212766,"generate/avg_tokens_zero_rewards":13342.404306220096,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":28744,"generate/std_num_tokens":4835.879246176739,"loss/avg_final_rewards":0.18359375,"loss/avg_raw_advantages":-0.00376077345572412,"loss/avg_raw_advantages_abs":0.11722420156002045,"policy/policy_entropy":0.18961325683631003,"policy/policy_kl":0.015988921353709884,"policy/policy_loss":4.4630642364040796e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007356617323239334,"policy/raw_grad_norm":0.0007162094116210938,"reward/avg_pass_at_8":0.328125,"reward/avg_raw_reward":0.18359375,"reward/policy_ref_kl":0.016019770875573158,"timing/step":2311.427478128986,"trainer/epoch":0}
+{"step":18,"async/staleness_mean":1.328125,"generate/avg_num_tokens":13198.310546875,"generate/avg_tokens_non_zero_rewards":11591.757281553399,"generate/avg_tokens_zero_rewards":13602.894865525672,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27395,"generate/std_num_tokens":4799.945513530077,"loss/avg_final_rewards":0.201171875,"loss/avg_raw_advantages":-0.009775816462934017,"loss/avg_raw_advantages_abs":0.12495778501033783,"policy/policy_entropy":0.19386467593722045,"policy/policy_kl":0.016832266192068346,"policy/policy_loss":1.0172352958193187e-05,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007168849582740222,"policy/raw_grad_norm":0.000789642333984375,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.201171875,"reward/policy_ref_kl":0.016779445111751556,"timing/step":2265.080029439967,"trainer/epoch":0}
+{"step":19,"async/staleness_mean":3.90625,"generate/avg_num_tokens":632.615234375,"generate/avg_tokens_non_zero_rewards":16561.333333333332,"generate/avg_tokens_zero_rewards":538.7328094302554,"generate/failed_trajectory_fraction":0.953125,"generate/max_num_tokens":24127,"generate/std_num_tokens":2979.4973953518634,"loss/avg_final_rewards":0.005859375,"loss/avg_raw_advantages":0.021190010011196136,"loss/avg_raw_advantages_abs":0.19794359803199768,"policy/policy_entropy":0.008327799660037272,"policy/policy_kl":0.0007430063042193069,"policy/policy_loss":-1.9086663996858988e-05,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00026922848701360635,"policy/raw_grad_norm":0.0093536376953125,"reward/avg_pass_at_8":0.015625,"reward/avg_raw_reward":0.005859375,"reward/policy_ref_kl":0.0007349271327257156,"timing/step":587.8864458530443,"trainer/epoch":0}
+{"step":20,"async/staleness_mean":3.296875,"generate/avg_num_tokens":6384.888671875,"generate/avg_tokens_non_zero_rewards":14596.142857142857,"generate/avg_tokens_zero_rewards":6271.069306930693,"generate/failed_trajectory_fraction":0.484375,"generate/max_num_tokens":24740,"generate/std_num_tokens":6940.398236482214,"loss/avg_final_rewards":0.013671875,"loss/avg_raw_advantages":0.0022123847156763077,"loss/avg_raw_advantages_abs":0.04962588846683502,"policy/policy_entropy":0.10471462336136028,"policy/policy_kl":0.01040853738959413,"policy/policy_loss":3.0178705401340267e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.0010135387833543064,"policy/raw_grad_norm":0.0012359619140625,"reward/avg_pass_at_8":0.0625,"reward/avg_raw_reward":0.013671875,"reward/policy_ref_kl":0.010325618088245392,"timing/step":1954.3406890810002,"trainer/epoch":0}
+{"step":21,"async/staleness_mean":1.484375,"generate/avg_num_tokens":10269.890625,"generate/avg_tokens_non_zero_rewards":11812.981481481482,"generate/avg_tokens_zero_rewards":10087.954148471616,"generate/failed_trajectory_fraction":0.203125,"generate/max_num_tokens":30591,"generate/std_num_tokens":7119.678675415212,"loss/avg_final_rewards":0.10546875,"loss/avg_raw_advantages":-0.002249879762530327,"loss/avg_raw_advantages_abs":0.10369190573692322,"policy/policy_entropy":0.16701123374514282,"policy/policy_kl":0.01808081350463908,"policy/policy_loss":4.3307347041832145e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005469236296448798,"policy/raw_grad_norm":0.0007600784301757812,"reward/avg_pass_at_8":0.2978723404255319,"reward/avg_raw_reward":0.10546875,"reward/policy_ref_kl":0.01795804314315319,"timing/step":3634.414853741997,"trainer/epoch":0}
+{"step":22,"async/staleness_mean":0.546875,"generate/avg_num_tokens":13763.82421875,"generate/avg_tokens_non_zero_rewards":11697.275,"generate/avg_tokens_zero_rewards":14146.518518518518,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27322,"generate/std_num_tokens":5428.976571835474,"loss/avg_final_rewards":0.15625,"loss/avg_raw_advantages":-0.0057094041258096695,"loss/avg_raw_advantages_abs":0.1270723193883896,"policy/policy_entropy":0.21655491250567138,"policy/policy_kl":0.025198107643518597,"policy/policy_loss":3.4922253746572096e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008068953055044403,"policy/raw_grad_norm":0.000537872314453125,"reward/avg_pass_at_8":0.4186046511627907,"reward/avg_raw_reward":0.15625,"reward/policy_ref_kl":0.024703320115804672,"timing/step":3774.4446516280295,"trainer/epoch":0}
+{"step":23,"async/staleness_mean":1.0,"generate/avg_num_tokens":14015.69140625,"generate/avg_tokens_non_zero_rewards":12113.91111111111,"generate/avg_tokens_zero_rewards":14198.946466809422,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":28913,"generate/std_num_tokens":5617.070049753021,"loss/avg_final_rewards":0.087890625,"loss/avg_raw_advantages":-0.0041635241359472275,"loss/avg_raw_advantages_abs":0.0721747949719429,"policy/policy_entropy":0.20869401982054114,"policy/policy_kl":0.024472877295920625,"policy/policy_loss":7.48560976404633e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.004209239258671005,"policy/raw_grad_norm":0.0007152557373046875,"reward/avg_pass_at_8":0.234375,"reward/avg_raw_reward":0.087890625,"reward/policy_ref_kl":0.02427729032933712,"timing/step":2003.162217552017,"trainer/epoch":0}
+{"step":24,"async/staleness_mean":1.453125,"generate/avg_num_tokens":12446.9375,"generate/avg_tokens_non_zero_rewards":11864.898876404495,"generate/avg_tokens_zero_rewards":12569.39952718676,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26296,"generate/std_num_tokens":4987.050998351255,"loss/avg_final_rewards":0.173828125,"loss/avg_raw_advantages":-0.009328571148216724,"loss/avg_raw_advantages_abs":0.10279203206300735,"policy/policy_entropy":0.2139452830888331,"policy/policy_kl":0.028673187305685133,"policy/policy_loss":7.571979363518722e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00677915826872777,"policy/raw_grad_norm":0.0006856918334960938,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.173828125,"reward/policy_ref_kl":0.02846628427505493,"timing/step":2076.8665304880124,"trainer/epoch":0}
+{"step":25,"async/staleness_mean":2.6875,"generate/avg_num_tokens":4133.359375,"generate/avg_tokens_non_zero_rewards":11742.413793103447,"generate/avg_tokens_zero_rewards":3676.5010351966876,"generate/failed_trajectory_fraction":0.6875,"generate/max_num_tokens":26633,"generate/std_num_tokens":6848.312755519574,"loss/avg_final_rewards":0.056640625,"loss/avg_raw_advantages":-0.011311296373605728,"loss/avg_raw_advantages_abs":0.12002793699502945,"policy/policy_entropy":0.06487899896455929,"policy/policy_kl":0.00890194817839074,"policy/policy_loss":7.974907830998745e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.002421893369501049,"policy/raw_grad_norm":0.0008993148803710938,"reward/avg_pass_at_8":0.125,"reward/avg_raw_reward":0.056640625,"reward/policy_ref_kl":0.00881329644471407,"timing/step":917.5565133430064,"trainer/epoch":0}
+{"step":26,"async/staleness_mean":3.375,"generate/avg_num_tokens":3930.609375,"generate/avg_tokens_non_zero_rewards":10710.90322580645,"generate/avg_tokens_zero_rewards":3493.6257796257796,"generate/failed_trajectory_fraction":0.6875,"generate/max_num_tokens":26772,"generate/std_num_tokens":6533.840164308017,"loss/avg_final_rewards":0.060546875,"loss/avg_raw_advantages":-0.007055288180708885,"loss/avg_raw_advantages_abs":0.17655104398727417,"policy/policy_entropy":0.0710617910081055,"policy/policy_kl":0.010610319579427596,"policy/policy_loss":3.2946167749514643e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.0035983943544124486,"policy/raw_grad_norm":0.0009326934814453125,"reward/avg_pass_at_8":0.140625,"reward/avg_raw_reward":0.060546875,"reward/policy_ref_kl":0.010565480217337608,"timing/step":1894.8930446990416,"trainer/epoch":0}
+{"step":27,"async/staleness_mean":2.765625,"generate/avg_num_tokens":8663.666015625,"generate/avg_tokens_non_zero_rewards":10858.094594594595,"generate/avg_tokens_zero_rewards":8292.917808219177,"generate/failed_trajectory_fraction":0.3125,"generate/max_num_tokens":30360,"generate/std_num_tokens":7412.7607887683325,"loss/avg_final_rewards":0.14453125,"loss/avg_raw_advantages":-0.006476950366050005,"loss/avg_raw_advantages_abs":0.1568218171596527,"policy/policy_entropy":0.1615357584087178,"policy/policy_kl":0.025188544481352437,"policy/policy_loss":3.1341099955284335e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007956358026149246,"policy/raw_grad_norm":0.0006771087646484375,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.14453125,"reward/policy_ref_kl":0.02528686635196209,"timing/step":2178.5039152220124,"trainer/epoch":0}
+{"step":28,"async/staleness_mean":1.359375,"generate/avg_num_tokens":12314.18359375,"generate/avg_tokens_non_zero_rewards":11241.701298701299,"generate/avg_tokens_zero_rewards":12504.025287356322,"generate/failed_trajectory_fraction":0.03125,"generate/max_num_tokens":30251,"generate/std_num_tokens":5726.558147123548,"loss/avg_final_rewards":0.150390625,"loss/avg_raw_advantages":0.002246356103569269,"loss/avg_raw_advantages_abs":0.09129797667264938,"policy/policy_entropy":0.2339239837601781,"policy/policy_kl":0.03710899030556902,"policy/policy_loss":5.26072614803752e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005974647071525396,"policy/raw_grad_norm":0.0006799697875976562,"reward/avg_pass_at_8":0.265625,"reward/avg_raw_reward":0.150390625,"reward/policy_ref_kl":0.03703828901052475,"timing/step":2103.8544816499925,"trainer/epoch":0}
+{"step":29,"async/staleness_mean":2.984375,"generate/avg_num_tokens":7605.59765625,"generate/avg_tokens_non_zero_rewards":10105.636363636364,"generate/avg_tokens_zero_rewards":7304.71772428884,"generate/failed_trajectory_fraction":0.390625,"generate/max_num_tokens":25779,"generate/std_num_tokens":7097.482312070299,"loss/avg_final_rewards":0.107421875,"loss/avg_raw_advantages":-0.008276039734482765,"loss/avg_raw_advantages_abs":0.10945608466863632,"policy/policy_entropy":0.14744931901805103,"policy/policy_kl":0.02452511538285762,"policy/policy_loss":2.515417154569377e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005753857200943457,"policy/raw_grad_norm":0.0007276535034179688,"reward/avg_pass_at_8":0.203125,"reward/avg_raw_reward":0.107421875,"reward/policy_ref_kl":0.0244667436927557,"timing/step":1164.8339345050044,"trainer/epoch":0}
+{"step":30,"async/staleness_mean":3.34375,"generate/avg_num_tokens":4849.12890625,"generate/avg_tokens_non_zero_rewards":7665.785714285715,"generate/avg_tokens_zero_rewards":4597.427659574468,"generate/failed_trajectory_fraction":0.546875,"generate/max_num_tokens":30211,"generate/std_num_tokens":6599.964371869418,"loss/avg_final_rewards":0.08203125,"loss/avg_raw_advantages":-0.014133543707430363,"loss/avg_raw_advantages_abs":0.09120868891477585,"policy/policy_entropy":0.11049468000419438,"policy/policy_kl":0.02142431735410355,"policy/policy_loss":7.849502878798376e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.004834163813484338,"policy/raw_grad_norm":0.000812530517578125,"reward/avg_pass_at_8":0.14893617021276595,"reward/avg_raw_reward":0.08203125,"reward/policy_ref_kl":0.021464448422193527,"timing/step":3113.939232982986,"trainer/epoch":0}
+{"step":31,"async/staleness_mean":1.0,"generate/avg_num_tokens":12553.37890625,"generate/avg_tokens_non_zero_rewards":11423.037037037036,"generate/avg_tokens_zero_rewards":12855.549504950495,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30553,"generate/std_num_tokens":5926.709789313338,"loss/avg_final_rewards":0.2109375,"loss/avg_raw_advantages":-0.0023064645938575268,"loss/avg_raw_advantages_abs":0.15468695759773254,"policy/policy_entropy":0.2470123863313347,"policy/policy_kl":0.045240708568599075,"policy/policy_loss":3.7584804637447178e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.010124025011464255,"policy/raw_grad_norm":0.0005474090576171875,"reward/avg_pass_at_8":0.453125,"reward/avg_raw_reward":0.2109375,"reward/policy_ref_kl":0.04534436762332916,"timing/step":1859.0860955840326,"trainer/epoch":0}
+{"step":32,"async/staleness_mean":1.640625,"generate/avg_num_tokens":12385.154296875,"generate/avg_tokens_non_zero_rewards":9789.247191011236,"generate/avg_tokens_zero_rewards":12931.338061465722,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27142,"generate/std_num_tokens":5450.404686238499,"loss/avg_final_rewards":0.173828125,"loss/avg_raw_advantages":-0.007225672248750925,"loss/avg_raw_advantages_abs":0.11963548511266708,"policy/policy_entropy":0.2563481607940048,"policy/policy_kl":0.048126303299795836,"policy/policy_loss":2.5971306669703154e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007300604949705303,"policy/raw_grad_norm":0.0006608963012695312,"reward/avg_pass_at_8":0.390625,"reward/avg_raw_reward":0.173828125,"reward/policy_ref_kl":0.04764966666698456,"timing/step":1658.742349572014,"trainer/epoch":0}
+{"step":33,"async/staleness_mean":1.734375,"generate/avg_num_tokens":11339.63671875,"generate/avg_tokens_non_zero_rewards":9053.0,"generate/avg_tokens_zero_rewards":11880.917874396135,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30291,"generate/std_num_tokens":5046.122778777334,"loss/avg_final_rewards":0.19140625,"loss/avg_raw_advantages":-0.004310745280236006,"loss/avg_raw_advantages_abs":0.08660412579774857,"policy/policy_entropy":0.25972675322555006,"policy/policy_kl":0.052274918009061366,"policy/policy_loss":1.9894275666842987e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008022326192076434,"policy/raw_grad_norm":0.0006084442138671875,"reward/avg_pass_at_8":0.328125,"reward/avg_raw_reward":0.19140625,"reward/policy_ref_kl":0.05244266986846924,"timing/step":1460.841757357004,"trainer/epoch":0}
+{"step":34,"async/staleness_mean":2.515625,"generate/avg_num_tokens":6605.802734375,"generate/avg_tokens_non_zero_rewards":8866.559322033898,"generate/avg_tokens_zero_rewards":6311.355408388521,"generate/failed_trajectory_fraction":0.359375,"generate/max_num_tokens":25426,"generate/std_num_tokens":6288.047211382135,"loss/avg_final_rewards":0.115234375,"loss/avg_raw_advantages":-0.006769534200429916,"loss/avg_raw_advantages_abs":0.09783092886209488,"policy/policy_entropy":0.16492588038090616,"policy/policy_kl":0.03658945977804251,"policy/policy_loss":4.084705963691704e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.0058314965285717335,"policy/raw_grad_norm":0.0008029937744140625,"reward/avg_pass_at_8":0.171875,"reward/avg_raw_reward":0.115234375,"reward/policy_ref_kl":0.03652539104223251,"timing/step":1626.586485509004,"trainer/epoch":0}
+{"step":35,"async/staleness_mean":1.3125,"generate/avg_num_tokens":10772.728515625,"generate/avg_tokens_non_zero_rewards":10070.07142857143,"generate/avg_tokens_zero_rewards":10835.51914893617,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27402,"generate/std_num_tokens":5332.699882942093,"loss/avg_final_rewards":0.08203125,"loss/avg_raw_advantages":0.0020064988639205694,"loss/avg_raw_advantages_abs":0.08542323857545853,"policy/policy_entropy":0.26560914400033653,"policy/policy_kl":0.05814935587113723,"policy/policy_loss":-1.3922782393649413e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00522930055467441,"policy/raw_grad_norm":0.0004572868347167969,"reward/avg_pass_at_8":0.30612244897959184,"reward/avg_raw_reward":0.08203125,"reward/policy_ref_kl":0.057939305901527405,"timing/step":2943.430134943046,"trainer/epoch":0}
+{"step":36,"async/staleness_mean":1.0,"generate/avg_num_tokens":10979.017578125,"generate/avg_tokens_non_zero_rewards":9649.625,"generate/avg_tokens_zero_rewards":11142.276315789473,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":29905,"generate/std_num_tokens":5155.885330445843,"loss/avg_final_rewards":0.109375,"loss/avg_raw_advantages":-0.000782620336394757,"loss/avg_raw_advantages_abs":0.0885033831000328,"policy/policy_entropy":0.26378958486020565,"policy/policy_kl":0.05984377895947546,"policy/policy_loss":1.229606130692673e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005809887343275477,"policy/raw_grad_norm":0.0006837844848632812,"reward/avg_pass_at_8":0.21875,"reward/avg_raw_reward":0.109375,"reward/policy_ref_kl":0.05981138348579407,"timing/step":1281.4162046539714,"trainer/epoch":0}
+{"step":37,"async/staleness_mean":1.890625,"generate/avg_num_tokens":10529.58984375,"generate/avg_tokens_non_zero_rewards":8747.039682539682,"generate/avg_tokens_zero_rewards":11111.458549222798,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26880,"generate/std_num_tokens":4967.80999399729,"loss/avg_final_rewards":0.24609375,"loss/avg_raw_advantages":-0.0020701943431049585,"loss/avg_raw_advantages_abs":0.09944380074739456,"policy/policy_entropy":0.26699011330492795,"policy/policy_kl":0.061075665114913136,"policy/policy_loss":2.2677656765779375e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009871083094822097,"policy/raw_grad_norm":0.0005292892456054688,"reward/avg_pass_at_8":0.40625,"reward/avg_raw_reward":0.24609375,"reward/policy_ref_kl":0.060871198773384094,"timing/step":1624.791639958974,"trainer/epoch":0}
+{"step":38,"async/staleness_mean":1.640625,"generate/avg_num_tokens":11207.474609375,"generate/avg_tokens_non_zero_rewards":9598.333333333334,"generate/avg_tokens_zero_rewards":11509.888631090487,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26103,"generate/std_num_tokens":4723.91228214023,"loss/avg_final_rewards":0.158203125,"loss/avg_raw_advantages":-0.0021967708598822355,"loss/avg_raw_advantages_abs":0.10900045931339264,"policy/policy_entropy":0.2735761175863445,"policy/policy_kl":0.062205269699916244,"policy/policy_loss":2.1436307164890422e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007634607282852812,"policy/raw_grad_norm":0.0006685256958007812,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.158203125,"reward/policy_ref_kl":0.061775900423526764,"timing/step":1554.5684656830272,"trainer/epoch":0}
+{"step":39,"async/staleness_mean":2.25,"generate/avg_num_tokens":8405.46484375,"generate/avg_tokens_non_zero_rewards":9203.6,"generate/avg_tokens_zero_rewards":8299.517699115044,"generate/failed_trajectory_fraction":0.203125,"generate/max_num_tokens":29782,"generate/std_num_tokens":6065.421396210471,"loss/avg_final_rewards":0.1171875,"loss/avg_raw_advantages":-0.007282145321369171,"loss/avg_raw_advantages_abs":0.10211862623691559,"policy/policy_entropy":0.21169885131530464,"policy/policy_kl":0.05152540860581212,"policy/policy_loss":3.563284842300618e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005000196675609914,"policy/raw_grad_norm":0.0008573532104492188,"reward/avg_pass_at_8":0.21875,"reward/avg_raw_reward":0.1171875,"reward/policy_ref_kl":0.05160372704267502,"timing/step":1517.0903278860496,"trainer/epoch":0}
+{"step":40,"async/staleness_mean":1.71875,"generate/avg_num_tokens":10264.150390625,"generate/avg_tokens_non_zero_rewards":8853.0,"generate/avg_tokens_zero_rewards":10545.058548009367,"generate/failed_trajectory_fraction":0.03125,"generate/max_num_tokens":27401,"generate/std_num_tokens":5438.816656218592,"loss/avg_final_rewards":0.166015625,"loss/avg_raw_advantages":-0.009717313572764397,"loss/avg_raw_advantages_abs":0.10701550543308258,"policy/policy_entropy":0.2645056543406099,"policy/policy_kl":0.06515088659944013,"policy/policy_loss":4.3287500375299715e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007282450075763336,"policy/raw_grad_norm":0.00079345703125,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.166015625,"reward/policy_ref_kl":0.06514370441436768,"timing/step":1715.9820904320222,"trainer/epoch":0}
+{"step":41,"async/staleness_mean":1.53125,"generate/avg_num_tokens":9977.291015625,"generate/avg_tokens_non_zero_rewards":8668.717391304348,"generate/avg_tokens_zero_rewards":10106.463519313305,"generate/failed_trajectory_fraction":0.0625,"generate/max_num_tokens":27727,"generate/std_num_tokens":5589.559986182994,"loss/avg_final_rewards":0.08984375,"loss/avg_raw_advantages":-0.00047264707973226905,"loss/avg_raw_advantages_abs":0.08974139392375946,"policy/policy_entropy":0.26719074440188706,"policy/policy_kl":0.06607147789327428,"policy/policy_loss":4.72841698240245e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.004578336624945223,"policy/raw_grad_norm":0.000789642333984375,"reward/avg_pass_at_8":0.32,"reward/avg_raw_reward":0.08984375,"reward/policy_ref_kl":0.06571701169013977,"timing/step":2935.441768702003,"trainer/epoch":0}
+{"step":42,"async/staleness_mean":1.0,"generate/avg_num_tokens":10536.76171875,"generate/avg_tokens_non_zero_rewards":8503.575,"generate/avg_tokens_zero_rewards":10913.277777777777,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":28091,"generate/std_num_tokens":5414.634889463074,"loss/avg_final_rewards":0.15625,"loss/avg_raw_advantages":-0.005558960139751434,"loss/avg_raw_advantages_abs":0.11117872595787048,"policy/policy_entropy":0.29194846423342824,"policy/policy_kl":0.07430687558371574,"policy/policy_loss":2.8779867022876715e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008355631571248523,"policy/raw_grad_norm":0.0007457733154296875,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.15625,"reward/policy_ref_kl":0.07432179152965546,"timing/step":1176.8887087280164,"trainer/epoch":0}
+{"step":43,"async/staleness_mean":1.921875,"generate/avg_num_tokens":10297.57421875,"generate/avg_tokens_non_zero_rewards":8563.033613445377,"generate/avg_tokens_zero_rewards":10822.791348600509,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26511,"generate/std_num_tokens":4946.911663078701,"loss/avg_final_rewards":0.232421875,"loss/avg_raw_advantages":-0.004421906545758247,"loss/avg_raw_advantages_abs":0.14453831315040588,"policy/policy_entropy":0.29095891979523003,"policy/policy_kl":0.07546567072859034,"policy/policy_loss":9.062713566265757e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.010480910853402747,"policy/raw_grad_norm":0.0005674362182617188,"reward/avg_pass_at_8":0.40625,"reward/avg_raw_reward":0.232421875,"reward/policy_ref_kl":0.07562603801488876,"timing/step":1340.407153931039,"trainer/epoch":0}
+{"step":44,"async/staleness_mean":2.0,"generate/avg_num_tokens":10058.21484375,"generate/avg_tokens_non_zero_rewards":8509.36923076923,"generate/avg_tokens_zero_rewards":10585.30890052356,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26969,"generate/std_num_tokens":4889.106827932472,"loss/avg_final_rewards":0.25390625,"loss/avg_raw_advantages":-0.0014505119761452079,"loss/avg_raw_advantages_abs":0.10298856347799301,"policy/policy_entropy":0.2833636768627912,"policy/policy_kl":0.07643870066385716,"policy/policy_loss":9.137919185775445e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009378637018016889,"policy/raw_grad_norm":0.0006361007690429688,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.25390625,"reward/policy_ref_kl":0.07653485238552094,"timing/step":1289.3652989440016,"trainer/epoch":0}
+{"step":45,"async/staleness_mean":1.828125,"generate/avg_num_tokens":10600.720703125,"generate/avg_tokens_non_zero_rewards":8160.1612903225805,"generate/avg_tokens_zero_rewards":11142.420047732698,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26308,"generate/std_num_tokens":5573.588983969632,"loss/avg_final_rewards":0.181640625,"loss/avg_raw_advantages":0.002410867949947715,"loss/avg_raw_advantages_abs":0.11823154985904694,"policy/policy_entropy":0.28867044299840927,"policy/policy_kl":0.07763769297162071,"policy/policy_loss":-1.4232071166020432e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00873736634002853,"policy/raw_grad_norm":0.000507354736328125,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.181640625,"reward/policy_ref_kl":0.07759134471416473,"timing/step":1540.5377486840007,"trainer/epoch":0}
+{"step":46,"async/staleness_mean":1.78125,"generate/avg_num_tokens":9900.9140625,"generate/avg_tokens_non_zero_rewards":8777.052631578947,"generate/avg_tokens_zero_rewards":10096.816513761469,"generate/failed_trajectory_fraction":0.015625,"generate/max_num_tokens":28203,"generate/std_num_tokens":4972.940664042101,"loss/avg_final_rewards":0.1484375,"loss/avg_raw_advantages":-0.009025480598211288,"loss/avg_raw_advantages_abs":0.09734418988227844,"policy/policy_entropy":0.298495233990252,"policy/policy_kl":0.08124065725132823,"policy/policy_loss":2.027448758212813e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005788561053122976,"policy/raw_grad_norm":0.0006284713745117188,"reward/avg_pass_at_8":0.328125,"reward/avg_raw_reward":0.1484375,"reward/policy_ref_kl":0.08133600652217865,"timing/step":1573.1666124730255,"trainer/epoch":0}
+{"step":47,"async/staleness_mean":1.8125,"generate/avg_num_tokens":11181.4921875,"generate/avg_tokens_non_zero_rewards":10087.78947368421,"generate/avg_tokens_zero_rewards":11318.505494505494,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30154,"generate/std_num_tokens":5712.809224051483,"loss/avg_final_rewards":0.111328125,"loss/avg_raw_advantages":-0.0036313156597316265,"loss/avg_raw_advantages_abs":0.07884193956851959,"policy/policy_entropy":0.2901087701320648,"policy/policy_kl":0.07752084656385705,"policy/policy_loss":1.3416152704337492e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006538600405292527,"policy/raw_grad_norm":0.0005884170532226562,"reward/avg_pass_at_8":0.265625,"reward/avg_raw_reward":0.111328125,"reward/policy_ref_kl":0.07736596465110779,"timing/step":1551.934252355015,"trainer/epoch":0}
+{"step":48,"async/staleness_mean":1.421875,"generate/avg_num_tokens":9596.197265625,"generate/avg_tokens_non_zero_rewards":7493.898876404494,"generate/avg_tokens_zero_rewards":10038.524822695035,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27621,"generate/std_num_tokens":4987.533391389666,"loss/avg_final_rewards":0.173828125,"loss/avg_raw_advantages":-0.004873102530837059,"loss/avg_raw_advantages_abs":0.10169121623039246,"policy/policy_entropy":0.3064133394509554,"policy/policy_kl":0.08607757720164955,"policy/policy_loss":1.3583721454324404e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.010139810141481576,"policy/raw_grad_norm":0.0005970001220703125,"reward/avg_pass_at_8":0.27450980392156865,"reward/avg_raw_reward":0.173828125,"reward/policy_ref_kl":0.08597256243228912,"timing/step":2194.1954475599923,"trainer/epoch":0}
+{"step":49,"async/staleness_mean":1.0,"generate/avg_num_tokens":10685.990234375,"generate/avg_tokens_non_zero_rewards":8742.588235294117,"generate/avg_tokens_zero_rewards":10983.628378378378,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":28891,"generate/std_num_tokens":5382.0666056051605,"loss/avg_final_rewards":0.1328125,"loss/avg_raw_advantages":-0.003280358389019966,"loss/avg_raw_advantages_abs":0.09629471600055695,"policy/policy_entropy":0.3008341323584318,"policy/policy_kl":0.0807173497742042,"policy/policy_loss":1.5879632577764369e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007545516091340687,"policy/raw_grad_norm":0.0005970001220703125,"reward/avg_pass_at_8":0.28125,"reward/avg_raw_reward":0.1328125,"reward/policy_ref_kl":0.08056585490703583,"timing/step":1745.5779216710362,"trainer/epoch":0}
+{"step":50,"async/staleness_mean":1.640625,"generate/avg_num_tokens":10817.05078125,"generate/avg_tokens_non_zero_rewards":8993.477477477478,"generate/avg_tokens_zero_rewards":11321.83042394015,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30593,"generate/std_num_tokens":5582.4411671006455,"loss/avg_final_rewards":0.216796875,"loss/avg_raw_advantages":0.003819285659119487,"loss/avg_raw_advantages_abs":0.1059006080031395,"policy/policy_entropy":0.29654152737930417,"policy/policy_kl":0.08111756335711107,"policy/policy_loss":-1.0974637518756936e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.010399492329270288,"policy/raw_grad_norm":0.0004949569702148438,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.216796875,"reward/policy_ref_kl":0.08103735744953156,"timing/step":1492.108971470967,"trainer/epoch":0}
+{"step":51,"async/staleness_mean":1.78125,"generate/avg_num_tokens":9212.404296875,"generate/avg_tokens_non_zero_rewards":7869.661971830986,"generate/avg_tokens_zero_rewards":9428.58276643991,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":29746,"generate/std_num_tokens":4732.702635178805,"loss/avg_final_rewards":0.138671875,"loss/avg_raw_advantages":-0.0010487546678632498,"loss/avg_raw_advantages_abs":0.10335904359817505,"policy/policy_entropy":0.3097125142812729,"policy/policy_kl":0.08953588572330773,"policy/policy_loss":-5.385828671933268e-09,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00730696719892876,"policy/raw_grad_norm":0.0005626678466796875,"reward/avg_pass_at_8":0.28125,"reward/avg_raw_reward":0.138671875,"reward/policy_ref_kl":0.08960030972957611,"timing/step":1142.907168699021,"trainer/epoch":0}
+{"step":52,"async/staleness_mean":1.9375,"generate/avg_num_tokens":10636.751953125,"generate/avg_tokens_non_zero_rewards":8785.070175438597,"generate/avg_tokens_zero_rewards":10868.72087912088,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27896,"generate/std_num_tokens":5002.867257472921,"loss/avg_final_rewards":0.111328125,"loss/avg_raw_advantages":-0.008851923979818821,"loss/avg_raw_advantages_abs":0.08511700481176376,"policy/policy_entropy":0.3066310998983681,"policy/policy_kl":0.08284365886356682,"policy/policy_loss":2.6972222002541457e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006021968355526042,"policy/raw_grad_norm":0.0007982254028320312,"reward/avg_pass_at_8":0.21875,"reward/avg_raw_reward":0.111328125,"reward/policy_ref_kl":0.08285485208034515,"timing/step":1686.3284518159926,"trainer/epoch":0}
+{"step":53,"async/staleness_mean":1.5,"generate/avg_num_tokens":9240.810546875,"generate/avg_tokens_non_zero_rewards":8683.781609195403,"generate/avg_tokens_zero_rewards":9354.837647058823,"generate/failed_trajectory_fraction":0.046875,"generate/max_num_tokens":26390,"generate/std_num_tokens":5028.114342869192,"loss/avg_final_rewards":0.169921875,"loss/avg_raw_advantages":0.0007180176908150315,"loss/avg_raw_advantages_abs":0.08501230180263519,"policy/policy_entropy":0.3085846765898168,"policy/policy_kl":0.08571053645573556,"policy/policy_loss":-2.7430048277210517e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008424479451605293,"policy/raw_grad_norm":0.00045299530029296875,"reward/avg_pass_at_8":0.3018867924528302,"reward/avg_raw_reward":0.169921875,"reward/policy_ref_kl":0.08584316074848175,"timing/step":2707.7360814409913,"trainer/epoch":0}
+{"step":54,"async/staleness_mean":1.0,"generate/avg_num_tokens":10869.625,"generate/avg_tokens_non_zero_rewards":7907.75,"generate/avg_tokens_zero_rewards":11385.915137614678,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30345,"generate/std_num_tokens":5610.1162222670355,"loss/avg_final_rewards":0.1484375,"loss/avg_raw_advantages":-0.0004573550831992179,"loss/avg_raw_advantages_abs":0.10319145023822784,"policy/policy_entropy":0.31978797167539597,"policy/policy_kl":0.08748819341417402,"policy/policy_loss":3.086834325927157e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007280157577042701,"policy/raw_grad_norm":0.00063323974609375,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.1484375,"reward/policy_ref_kl":0.08748757839202881,"timing/step":1417.1502681659767,"trainer/epoch":0}
+{"step":55,"async/staleness_mean":1.765625,"generate/avg_num_tokens":9611.40234375,"generate/avg_tokens_non_zero_rewards":7751.168674698795,"generate/avg_tokens_zero_rewards":9971.307692307691,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25938,"generate/std_num_tokens":5014.403397790784,"loss/avg_final_rewards":0.162109375,"loss/avg_raw_advantages":-0.003854760667309165,"loss/avg_raw_advantages_abs":0.09948883950710297,"policy/policy_entropy":0.31978206569328904,"policy/policy_kl":0.09096269321162254,"policy/policy_loss":1.069530568997834e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007452300071236095,"policy/raw_grad_norm":0.0005474090576171875,"reward/avg_pass_at_8":0.328125,"reward/avg_raw_reward":0.162109375,"reward/policy_ref_kl":0.09101472049951553,"timing/step":1333.1662747240043,"trainer/epoch":0}
+{"step":56,"async/staleness_mean":1.9375,"generate/avg_num_tokens":9777.513671875,"generate/avg_tokens_non_zero_rewards":8637.564102564103,"generate/avg_tokens_zero_rewards":9982.389400921658,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27295,"generate/std_num_tokens":4822.379741466533,"loss/avg_final_rewards":0.15234375,"loss/avg_raw_advantages":-0.0023286757059395313,"loss/avg_raw_advantages_abs":0.11182728409767151,"policy/policy_entropy":0.3255767119117081,"policy/policy_kl":0.08985532412771136,"policy/policy_loss":1.1031983149223379e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007804233415299677,"policy/raw_grad_norm":0.0005512237548828125,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.15234375,"reward/policy_ref_kl":0.0899093821644783,"timing/step":1450.312160749978,"trainer/epoch":0}
+{"step":57,"async/staleness_mean":1.84375,"generate/avg_num_tokens":10273.80859375,"generate/avg_tokens_non_zero_rewards":8863.728971962617,"generate/avg_tokens_zero_rewards":10646.348148148149,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27926,"generate/std_num_tokens":5138.054283747754,"loss/avg_final_rewards":0.208984375,"loss/avg_raw_advantages":0.002836314495652914,"loss/avg_raw_advantages_abs":0.11798383295536041,"policy/policy_entropy":0.3284221440553665,"policy/policy_kl":0.09197159064933658,"policy/policy_loss":-7.414994129817387e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008859603390192206,"policy/raw_grad_norm":0.000518798828125,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.208984375,"reward/policy_ref_kl":0.09176859259605408,"timing/step":1485.4764534829883,"trainer/epoch":0}
+{"step":58,"async/staleness_mean":1.765625,"generate/avg_num_tokens":10117.720703125,"generate/avg_tokens_non_zero_rewards":7939.894117647059,"generate/avg_tokens_zero_rewards":10551.245901639344,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":29805,"generate/std_num_tokens":5339.251392082286,"loss/avg_final_rewards":0.166015625,"loss/avg_raw_advantages":-0.0033337173517793417,"loss/avg_raw_advantages_abs":0.09456609189510345,"policy/policy_entropy":0.3271936837118119,"policy/policy_kl":0.09136124106589705,"policy/policy_loss":1.2400030691139818e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006373711056767206,"policy/raw_grad_norm":0.0005178451538085938,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.166015625,"reward/policy_ref_kl":0.09111484885215759,"timing/step":1331.5946923530428,"trainer/epoch":0}
+{"step":59,"async/staleness_mean":1.796875,"generate/avg_num_tokens":10487.126953125,"generate/avg_tokens_non_zero_rewards":9100.972222222223,"generate/avg_tokens_zero_rewards":10713.952272727272,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":28703,"generate/std_num_tokens":5093.622063337373,"loss/avg_final_rewards":0.140625,"loss/avg_raw_advantages":-0.004352542106062174,"loss/avg_raw_advantages_abs":0.11413611471652985,"policy/policy_entropy":0.3185904249548912,"policy/policy_kl":0.08968210138846189,"policy/policy_loss":2.0084965655087217e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007056174211811594,"policy/raw_grad_norm":0.0006666183471679688,"reward/avg_pass_at_8":0.28125,"reward/avg_raw_reward":0.140625,"reward/policy_ref_kl":0.08973187208175659,"timing/step":1525.6629140709992,"trainer/epoch":0}
+{"step":60,"async/staleness_mean":1.734375,"generate/avg_num_tokens":10568.05078125,"generate/avg_tokens_non_zero_rewards":8820.26168224299,"generate/avg_tokens_zero_rewards":11029.812345679013,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30370,"generate/std_num_tokens":5390.531208727486,"loss/avg_final_rewards":0.208984375,"loss/avg_raw_advantages":-0.013820058666169643,"loss/avg_raw_advantages_abs":0.15290656685829163,"policy/policy_entropy":0.3355519655160606,"policy/policy_kl":0.09337997727561742,"policy/policy_loss":2.983205753537277e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.011954482946748612,"policy/raw_grad_norm":0.0006046295166015625,"reward/avg_pass_at_8":0.421875,"reward/avg_raw_reward":0.208984375,"reward/policy_ref_kl":0.09311745315790176,"timing/step":1703.9064403590164,"trainer/epoch":0}
+{"step":61,"async/staleness_mean":1.34375,"generate/avg_num_tokens":10107.814453125,"generate/avg_tokens_non_zero_rewards":9226.115384615385,"generate/avg_tokens_zero_rewards":10207.484782608695,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27619,"generate/std_num_tokens":5402.306737738911,"loss/avg_final_rewards":0.1015625,"loss/avg_raw_advantages":0.0023994946386665106,"loss/avg_raw_advantages_abs":0.08774221688508987,"policy/policy_entropy":0.33941745944321156,"policy/policy_kl":0.09455709846224636,"policy/policy_loss":-3.020650041207773e-08,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006432388067878492,"policy/raw_grad_norm":0.0005197525024414062,"reward/avg_pass_at_8":0.2916666666666667,"reward/avg_raw_reward":0.1015625,"reward/policy_ref_kl":0.0943375676870346,"timing/step":2638.451030005992,"trainer/epoch":0}
+{"step":62,"async/staleness_mean":0.71875,"generate/avg_num_tokens":10593.521484375,"generate/avg_tokens_non_zero_rewards":8387.910256410256,"generate/avg_tokens_zero_rewards":10989.921658986175,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30539,"generate/std_num_tokens":5503.567906254739,"loss/avg_final_rewards":0.15234375,"loss/avg_raw_advantages":-0.003986469469964504,"loss/avg_raw_advantages_abs":0.08826606720685959,"policy/policy_entropy":0.34060708060860634,"policy/policy_kl":0.0924252487020567,"policy/policy_loss":1.417391068514462e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008016829119696922,"policy/raw_grad_norm":0.0005979537963867188,"reward/avg_pass_at_8":0.2777777777777778,"reward/avg_raw_reward":0.15234375,"reward/policy_ref_kl":0.09239897131919861,"timing/step":2985.9529779309523,"trainer/epoch":0}
+{"step":63,"async/staleness_mean":1.0,"generate/avg_num_tokens":11527.576171875,"generate/avg_tokens_non_zero_rewards":9544.456790123457,"generate/avg_tokens_zero_rewards":11900.273781902551,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27873,"generate/std_num_tokens":5982.690258778161,"loss/avg_final_rewards":0.158203125,"loss/avg_raw_advantages":-0.008965528570115566,"loss/avg_raw_advantages_abs":0.12020907551050186,"policy/policy_entropy":0.3500221772119403,"policy/policy_kl":0.09282010642345995,"policy/policy_loss":2.637731736143678e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00969673465260712,"policy/raw_grad_norm":0.0006561279296875,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.158203125,"reward/policy_ref_kl":0.09269394725561142,"timing/step":1277.2689383979887,"trainer/epoch":0}
+{"step":64,"async/staleness_mean":1.9375,"generate/avg_num_tokens":10973.4921875,"generate/avg_tokens_non_zero_rewards":10628.828571428572,"generate/avg_tokens_zero_rewards":11103.20430107527,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30246,"generate/std_num_tokens":5424.169229298065,"loss/avg_final_rewards":0.2734375,"loss/avg_raw_advantages":0.002175062196329236,"loss/avg_raw_advantages_abs":0.20116810500621796,"policy/policy_entropy":0.34684486081823707,"policy/policy_kl":0.09444799763150513,"policy/policy_loss":7.679060232135271e-08,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.01593458792012825,"policy/raw_grad_norm":0.0004687309265136719,"reward/avg_pass_at_8":0.5,"reward/avg_raw_reward":0.2734375,"reward/policy_ref_kl":0.0942552387714386,"timing/step":1403.5921690840041,"trainer/epoch":0}
+{"step":65,"async/staleness_mean":1.953125,"generate/avg_num_tokens":9798.30078125,"generate/avg_tokens_non_zero_rewards":9523.988636363636,"generate/avg_tokens_zero_rewards":9855.233490566037,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26037,"generate/std_num_tokens":4810.207675577728,"loss/avg_final_rewards":0.171875,"loss/avg_raw_advantages":-0.00014144131273496896,"loss/avg_raw_advantages_abs":0.1151258647441864,"policy/policy_entropy":0.3597131953574717,"policy/policy_kl":0.09977425576653332,"policy/policy_loss":5.356295567082725e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008647990531244432,"policy/raw_grad_norm":0.000553131103515625,"reward/avg_pass_at_8":0.328125,"reward/avg_raw_reward":0.171875,"reward/policy_ref_kl":0.09958639740943909,"timing/step":1209.0861944250064,"trainer/epoch":0}
+{"step":66,"async/staleness_mean":1.90625,"generate/avg_num_tokens":10493.5234375,"generate/avg_tokens_non_zero_rewards":8840.578947368422,"generate/avg_tokens_zero_rewards":10781.651376146789,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":29457,"generate/std_num_tokens":4825.382862424694,"loss/avg_final_rewards":0.1484375,"loss/avg_raw_advantages":-0.007219565100967884,"loss/avg_raw_advantages_abs":0.14186859130859375,"policy/policy_entropy":0.3472798904404044,"policy/policy_kl":0.09657934552524239,"policy/policy_loss":2.312569620244176e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009847354898738558,"policy/raw_grad_norm":0.0005817413330078125,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.1484375,"reward/policy_ref_kl":0.0962652713060379,"timing/step":1507.7622687380062,"trainer/epoch":0}
+{"step":67,"async/staleness_mean":1.671875,"generate/avg_num_tokens":10204.669921875,"generate/avg_tokens_non_zero_rewards":8814.088235294117,"generate/avg_tokens_zero_rewards":10417.641891891892,"generate/failed_trajectory_fraction":0.017578125,"generate/max_num_tokens":27104,"generate/std_num_tokens":5024.6995714795285,"loss/avg_final_rewards":0.1328125,"loss/avg_raw_advantages":0.002797940280288458,"loss/avg_raw_advantages_abs":0.0874834731221199,"policy/policy_entropy":0.3441550927236676,"policy/policy_kl":0.09555600339081138,"policy/policy_loss":-1.4268640953218892e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006901480337546673,"policy/raw_grad_norm":0.0006389617919921875,"reward/avg_pass_at_8":0.25,"reward/avg_raw_reward":0.1328125,"reward/policy_ref_kl":0.09542868286371231,"timing/step":1753.9922892030445,"trainer/epoch":0}
+{"step":68,"async/staleness_mean":1.28125,"generate/avg_num_tokens":9952.908203125,"generate/avg_tokens_non_zero_rewards":10115.307692307691,"generate/avg_tokens_zero_rewards":9923.721198156682,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27273,"generate/std_num_tokens":4757.378276713468,"loss/avg_final_rewards":0.15234375,"loss/avg_raw_advantages":-0.0028747457545250654,"loss/avg_raw_advantages_abs":0.12735013663768768,"policy/policy_entropy":0.36331964284181595,"policy/policy_kl":0.10026614053640515,"policy/policy_loss":5.572444106149987e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008835620532408939,"policy/raw_grad_norm":0.0005092620849609375,"reward/avg_pass_at_8":0.3958333333333333,"reward/avg_raw_reward":0.15234375,"reward/policy_ref_kl":0.10013977438211441,"timing/step":3008.0987080579507,"trainer/epoch":0}
+{"step":69,"async/staleness_mean":1.0,"generate/avg_num_tokens":10636.716796875,"generate/avg_tokens_non_zero_rewards":9431.893805309735,"generate/avg_tokens_zero_rewards":10977.932330827067,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27546,"generate/std_num_tokens":5162.446486544593,"loss/avg_final_rewards":0.220703125,"loss/avg_raw_advantages":-0.0080715361982584,"loss/avg_raw_advantages_abs":0.14897999167442322,"policy/policy_entropy":0.36579873878508806,"policy/policy_kl":0.09825965412892401,"policy/policy_loss":4.12654564740933e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.01208015432166576,"policy/raw_grad_norm":0.0006504058837890625,"reward/avg_pass_at_8":0.375,"reward/avg_raw_reward":0.220703125,"reward/policy_ref_kl":0.09793112426996231,"timing/step":1484.0231077329954,"trainer/epoch":0}
+{"step":70,"async/staleness_mean":1.796875,"generate/avg_num_tokens":10542.96484375,"generate/avg_tokens_non_zero_rewards":9105.492307692308,"generate/avg_tokens_zero_rewards":10751.993288590604,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26902,"generate/std_num_tokens":4776.69326639926,"loss/avg_final_rewards":0.126953125,"loss/avg_raw_advantages":-0.000555152480956167,"loss/avg_raw_advantages_abs":0.08110947161912918,"policy/policy_entropy":0.37231709295883775,"policy/policy_kl":0.1008207107661292,"policy/policy_loss":3.4711339935711294e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005745726210079738,"policy/raw_grad_norm":0.0006341934204101562,"reward/avg_pass_at_8":0.25,"reward/avg_raw_reward":0.126953125,"reward/policy_ref_kl":0.10062971711158752,"timing/step":1629.6555689849774,"trainer/epoch":0}
+{"step":71,"async/staleness_mean":1.6875,"generate/avg_num_tokens":10125.859375,"generate/avg_tokens_non_zero_rewards":8726.63,"generate/avg_tokens_zero_rewards":10465.478155339806,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27586,"generate/std_num_tokens":4559.04763129794,"loss/avg_final_rewards":0.1953125,"loss/avg_raw_advantages":0.0031303002033382654,"loss/avg_raw_advantages_abs":0.1446843296289444,"policy/policy_entropy":0.3700702306814492,"policy/policy_kl":0.10148334677796811,"policy/policy_loss":1.4780505352973705e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.011877982949044963,"policy/raw_grad_norm":0.0004940032958984375,"reward/avg_pass_at_8":0.421875,"reward/avg_raw_reward":0.1953125,"reward/policy_ref_kl":0.10134249925613403,"timing/step":1743.012564742996,"trainer/epoch":0}
+{"step":72,"async/staleness_mean":2.25,"generate/avg_num_tokens":7939.7421875,"generate/avg_tokens_non_zero_rewards":8348.45,"generate/avg_tokens_zero_rewards":7864.055555555556,"generate/failed_trajectory_fraction":0.234375,"generate/max_num_tokens":26377,"generate/std_num_tokens":6389.370781564799,"loss/avg_final_rewards":0.15625,"loss/avg_raw_advantages":-0.010004510171711445,"loss/avg_raw_advantages_abs":0.1339646577835083,"policy/policy_entropy":0.288550419267267,"policy/policy_kl":0.0774159679422155,"policy/policy_loss":2.331978716796357e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009204388855323486,"policy/raw_grad_norm":0.0006589889526367188,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.15625,"reward/policy_ref_kl":0.07740311324596405,"timing/step":1510.6720685529872,"trainer/epoch":0}
+{"step":73,"async/staleness_mean":1.734375,"generate/avg_num_tokens":10401.306640625,"generate/avg_tokens_non_zero_rewards":8600.776315789473,"generate/avg_tokens_zero_rewards":10715.160550458715,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":28289,"generate/std_num_tokens":4609.855109499745,"loss/avg_final_rewards":0.1484375,"loss/avg_raw_advantages":-0.010888329707086086,"loss/avg_raw_advantages_abs":0.0975562259554863,"policy/policy_entropy":0.3721249010413885,"policy/policy_kl":0.10344237240497023,"policy/policy_loss":3.4217064559527444e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007225164272313123,"policy/raw_grad_norm":0.000637054443359375,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.1484375,"reward/policy_ref_kl":0.10350901633501053,"timing/step":1667.215378700057,"trainer/epoch":0}
+{"step":74,"async/staleness_mean":1.6875,"generate/avg_num_tokens":10855.0703125,"generate/avg_tokens_non_zero_rewards":9874.043956043955,"generate/avg_tokens_zero_rewards":11067.121140142517,"generate/failed_trajectory_fraction":0.015625,"generate/max_num_tokens":28029,"generate/std_num_tokens":5162.87936285254,"loss/avg_final_rewards":0.177734375,"loss/avg_raw_advantages":-0.0060962773859500885,"loss/avg_raw_advantages_abs":0.14381326735019684,"policy/policy_entropy":0.3851857129484415,"policy/policy_kl":0.10112944734282792,"policy/policy_loss":1.934143245563291e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.010585801082015678,"policy/raw_grad_norm":0.0006465911865234375,"reward/avg_pass_at_8":0.40625,"reward/avg_raw_reward":0.177734375,"reward/policy_ref_kl":0.10120263695716858,"timing/step":1876.7345566349686,"trainer/epoch":0}
+{"step":75,"async/staleness_mean":2.015625,"generate/avg_num_tokens":9523.41796875,"generate/avg_tokens_non_zero_rewards":10488.574468085106,"generate/avg_tokens_zero_rewards":9425.864516129031,"generate/failed_trajectory_fraction":0.125,"generate/max_num_tokens":26207,"generate/std_num_tokens":6027.9584108258305,"loss/avg_final_rewards":0.091796875,"loss/avg_raw_advantages":-0.005430603865534067,"loss/avg_raw_advantages_abs":0.1059478148818016,"policy/policy_entropy":0.34921422926709056,"policy/policy_kl":0.09285718202590942,"policy/policy_loss":2.9216338575110967e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006882215475343401,"policy/raw_grad_norm":0.001132965087890625,"reward/avg_pass_at_8":0.203125,"reward/avg_raw_reward":0.091796875,"reward/policy_ref_kl":0.09273342788219452,"timing/step":1711.0288707740256,"trainer/epoch":0}
+{"step":76,"async/staleness_mean":2.15625,"generate/avg_num_tokens":9774.830078125,"generate/avg_tokens_non_zero_rewards":8967.0,"generate/avg_tokens_zero_rewards":9911.312785388129,"generate/failed_trajectory_fraction":0.140625,"generate/max_num_tokens":28625,"generate/std_num_tokens":6425.753194576565,"loss/avg_final_rewards":0.14453125,"loss/avg_raw_advantages":-0.0015279221115633845,"loss/avg_raw_advantages_abs":0.09564267843961716,"policy/policy_entropy":0.3453949235845357,"policy/policy_kl":0.09004482871387154,"policy/policy_loss":1.2386992764845672e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006416692681796121,"policy/raw_grad_norm":0.0007715225219726562,"reward/avg_pass_at_8":0.265625,"reward/avg_raw_reward":0.14453125,"reward/policy_ref_kl":0.08992964029312134,"timing/step":1737.6250440620352,"trainer/epoch":0}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-tt-x3-kl0p001/run.json b/viewer/build/inputs/marin/runs/marin-q3c-tt-x3-kl0p001/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..45bb94857a3a947b92670197850d431349ec3dfa
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-tt-x3-kl0p001/run.json
@@ -0,0 +1,29 @@
+{
+ "id": "marin-q3c-tt-x3-kl0p001",
+ "title": "TaskTrove RL, KL 0.001 (Qwen3-Coder-30B-A3B)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/laion/tt-x3_kl-kl0p001-76-30B/tree/main/training_logs",
+ "license": "apache-2.0",
+ "model": "laion/tt-x3_kl-kl0p001-76-30B",
+ "base_model": "Qwen/Qwen3-Coder-30B-A3B-Instruct",
+ "method": "GRPO (SkyRL + Terminus-2, pass-ratio shaped verifier reward)",
+ "dataset": "DCAgent/exp_rpt_multifile",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-09-04T16:23:02Z",
+ "attempts": 0,
+ "note": "Marin TaskTrove RL hyperparameter ablation (issue #7785) on Qwen3-Coder-30B-A3B-Instruct with DCAgent/exp_rpt_multifile tasks and the Terminus-2 harness; arm: X3 KL arm: KL coefficient 0.001 with a reference model. Our copy has every logged step of the final lineage (15 log segments).",
+ "metrics_map": {
+  "reward": "reward/avg_raw_reward",
+  "loss": "policy/policy_loss",
+  "entropy": "policy/policy_entropy",
+  "lr": "policy/policy_lr",
+  "grad_norm": "policy/raw_grad_norm",
+  "response_length": "generate/avg_num_tokens",
+  "kl": "policy/policy_kl"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-tt-x5-gradnorm0p45/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-q3c-tt-x5-gradnorm0p45/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..bb321f2da26c4180e22bc33ce3ad12d3b82b02cb
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-tt-x5-gradnorm0p45/metrics.jsonl
@@ -0,0 +1,68 @@
+{"step":1,"async/staleness_mean":0.0,"generate/avg_num_tokens":11791.3984375,"generate/avg_tokens_non_zero_rewards":10858.223684210527,"generate/avg_tokens_zero_rewards":11954.061926605504,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":23222,"generate/std_num_tokens":3710.802324569285,"loss/avg_final_rewards":0.1484375,"loss/avg_raw_advantages":0.0018616283778101206,"loss/avg_raw_advantages_abs":0.0788487046957016,"policy/policy_entropy":0.12270080274902284,"policy/policy_loss":-1.3846631503611206e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.0039631352465221426,"policy/raw_grad_norm":0.00193023681640625,"reward/avg_pass_at_8":0.265625,"reward/avg_raw_reward":0.1484375,"timing/step":5539.47597769089,"trainer/epoch":0}
+{"step":2,"async/staleness_mean":1.0,"generate/avg_num_tokens":12140.3828125,"generate/avg_tokens_non_zero_rewards":11862.845070422536,"generate/avg_tokens_zero_rewards":12185.065759637188,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26957,"generate/std_num_tokens":3823.8181637662033,"loss/avg_final_rewards":0.138671875,"loss/avg_raw_advantages":-0.0014097518287599087,"loss/avg_raw_advantages_abs":0.11524277925491333,"policy/policy_entropy":0.1276655530091375,"policy/policy_loss":6.059068411445878e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.0052097445632171,"policy/raw_grad_norm":0.00159454345703125,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.138671875,"timing/step":2612.8492291190196,"trainer/epoch":0}
+{"step":3,"async/staleness_mean":1.734375,"generate/avg_num_tokens":12078.0390625,"generate/avg_tokens_non_zero_rewards":11067.16923076923,"generate/avg_tokens_zero_rewards":12225.03355704698,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24160,"generate/std_num_tokens":3585.8093210257807,"loss/avg_final_rewards":0.126953125,"loss/avg_raw_advantages":-0.00024399122048635036,"loss/avg_raw_advantages_abs":0.10163431614637375,"policy/policy_entropy":0.13537711673416197,"policy/policy_loss":1.66076262075876e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.004986432578334643,"policy/raw_grad_norm":0.002044677734375,"reward/avg_pass_at_8":0.25,"reward/avg_raw_reward":0.126953125,"timing/step":2766.697756807087,"trainer/epoch":0}
+{"step":4,"async/staleness_mean":1.859375,"generate/avg_num_tokens":11823.015625,"generate/avg_tokens_non_zero_rewards":11380.34693877551,"generate/avg_tokens_zero_rewards":11927.80193236715,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24404,"generate/std_num_tokens":3535.6687646097603,"loss/avg_final_rewards":0.19140625,"loss/avg_raw_advantages":0.00661264406517148,"loss/avg_raw_advantages_abs":0.14293375611305237,"policy/policy_entropy":0.14035974472062662,"policy/policy_loss":-7.031288298264826e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007570894845230214,"policy/raw_grad_norm":0.0012493133544921875,"reward/avg_pass_at_8":0.4375,"reward/avg_raw_reward":0.19140625,"timing/step":2686.3743848078884,"trainer/epoch":0}
+{"step":5,"async/staleness_mean":2.046875,"generate/avg_num_tokens":12326.57421875,"generate/avg_tokens_non_zero_rewards":11862.416666666666,"generate/avg_tokens_zero_rewards":12388.188053097345,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25414,"generate/std_num_tokens":3628.3863334982093,"loss/avg_final_rewards":0.1171875,"loss/avg_raw_advantages":-0.0026458406355232,"loss/avg_raw_advantages_abs":0.07605545967817307,"policy/policy_entropy":0.14718504570191726,"policy/policy_loss":1.0213674599413025e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.003797877667238936,"policy/raw_grad_norm":0.001953125,"reward/avg_pass_at_8":0.21875,"reward/avg_raw_reward":0.1171875,"timing/step":3229.0331079550087,"trainer/epoch":0}
+{"step":6,"async/staleness_mean":2.015625,"generate/avg_num_tokens":12621.51171875,"generate/avg_tokens_non_zero_rewards":12952.682539682539,"generate/avg_tokens_zero_rewards":12575.044543429844,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24664,"generate/std_num_tokens":3639.944873683724,"loss/avg_final_rewards":0.123046875,"loss/avg_raw_advantages":0.003352612489834428,"loss/avg_raw_advantages_abs":0.094528928399086,"policy/policy_entropy":0.1504530839738436,"policy/policy_loss":-6.657595577053144e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.004997343969989743,"policy/raw_grad_norm":0.0013885498046875,"reward/avg_pass_at_8":0.28125,"reward/avg_raw_reward":0.123046875,"timing/step":3105.6845996279735,"trainer/epoch":0}
+{"step":7,"async/staleness_mean":1.84375,"generate/avg_num_tokens":12322.51953125,"generate/avg_tokens_non_zero_rewards":11112.201612903225,"generate/avg_tokens_zero_rewards":12709.322164948453,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25078,"generate/std_num_tokens":4023.680210107692,"loss/avg_final_rewards":0.2421875,"loss/avg_raw_advantages":-0.002092145849019289,"loss/avg_raw_advantages_abs":0.13969583809375763,"policy/policy_entropy":0.1563977369805798,"policy/policy_loss":7.391564977865528e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007780624531733338,"policy/raw_grad_norm":0.001434326171875,"reward/avg_pass_at_8":0.421875,"reward/avg_raw_reward":0.2421875,"timing/step":2946.508635859005,"trainer/epoch":0}
+{"step":8,"async/staleness_mean":1.90625,"generate/avg_num_tokens":11752.962890625,"generate/avg_tokens_non_zero_rewards":10402.192857142858,"generate/avg_tokens_zero_rewards":12261.317204301075,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":23837,"generate/std_num_tokens":3630.953788019378,"loss/avg_final_rewards":0.2734375,"loss/avg_raw_advantages":-0.005398645531386137,"loss/avg_raw_advantages_abs":0.15247876942157745,"policy/policy_entropy":0.1665698119904846,"policy/policy_loss":1.4565656627496537e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009989192425564397,"policy/raw_grad_norm":0.00139617919921875,"reward/avg_pass_at_8":0.453125,"reward/avg_raw_reward":0.2734375,"timing/step":3158.2748083001934,"trainer/epoch":0}
+{"step":9,"async/staleness_mean":1.9375,"generate/avg_num_tokens":11817.62890625,"generate/avg_tokens_non_zero_rewards":9741.08888888889,"generate/avg_tokens_zero_rewards":12260.492890995261,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":23100,"generate/std_num_tokens":3738.939095720627,"loss/avg_final_rewards":0.17578125,"loss/avg_raw_advantages":-0.0038736003916710615,"loss/avg_raw_advantages_abs":0.086604043841362,"policy/policy_entropy":0.16816551377996802,"policy/policy_loss":2.9437300455015247e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005893173031381593,"policy/raw_grad_norm":0.0016326904296875,"reward/avg_pass_at_8":0.28125,"reward/avg_raw_reward":0.17578125,"timing/step":3357.954769005999,"trainer/epoch":0}
+{"step":10,"async/staleness_mean":0.828125,"generate/avg_num_tokens":12138.19140625,"generate/avg_tokens_non_zero_rewards":10555.372093023256,"generate/avg_tokens_zero_rewards":12457.727699530516,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24681,"generate/std_num_tokens":3891.8769951521977,"loss/avg_final_rewards":0.16796875,"loss/avg_raw_advantages":-0.002505233511328697,"loss/avg_raw_advantages_abs":0.11009347438812256,"policy/policy_entropy":0.175362812820822,"policy/policy_loss":1.8996596251596998e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007943858899125189,"policy/raw_grad_norm":0.0012531280517578125,"reward/avg_pass_at_8":0.34,"reward/avg_raw_reward":0.16796875,"timing/step":8233.293633271009,"trainer/epoch":0}
+{"step":11,"async/staleness_mean":1.0,"generate/avg_num_tokens":12493.68359375,"generate/avg_tokens_non_zero_rewards":10565.48051948052,"generate/avg_tokens_zero_rewards":12834.997701149425,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26500,"generate/std_num_tokens":4070.1660829572834,"loss/avg_final_rewards":0.150390625,"loss/avg_raw_advantages":-0.0007450665580108762,"loss/avg_raw_advantages_abs":0.1090240329504013,"policy/policy_entropy":0.1830622258130461,"policy/policy_loss":-7.142266547077725e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007385002267710661,"policy/raw_grad_norm":0.001190185546875,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.150390625,"timing/step":3904.2820108069573,"trainer/epoch":0}
+{"step":12,"async/staleness_mean":1.625,"generate/avg_num_tokens":11847.392578125,"generate/avg_tokens_non_zero_rewards":9899.443037974683,"generate/avg_tokens_zero_rewards":12202.792147806005,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26786,"generate/std_num_tokens":4081.134515041962,"loss/avg_final_rewards":0.154296875,"loss/avg_raw_advantages":-0.00043515273137018085,"loss/avg_raw_advantages_abs":0.09914527833461761,"policy/policy_entropy":0.18060476693790406,"policy/policy_loss":3.07914053365721e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006132250740847667,"policy/raw_grad_norm":0.001361846923828125,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.154296875,"timing/step":4274.771966025,"trainer/epoch":0}
+{"step":13,"async/staleness_mean":0.96875,"generate/avg_num_tokens":11537.6328125,"generate/avg_tokens_non_zero_rewards":10357.143835616438,"generate/avg_tokens_zero_rewards":12008.53825136612,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26204,"generate/std_num_tokens":3918.1012997191433,"loss/avg_final_rewards":0.28515625,"loss/avg_raw_advantages":0.0015004277229309082,"loss/avg_raw_advantages_abs":0.1437944918870926,"policy/policy_entropy":0.18902051635086536,"policy/policy_loss":-5.92013716271822e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008760957843151118,"policy/raw_grad_norm":0.0012569427490234375,"reward/avg_pass_at_8":0.42857142857142855,"reward/avg_raw_reward":0.28515625,"timing/step":8295.136788924923,"trainer/epoch":0}
+{"step":14,"async/staleness_mean":1.0,"generate/avg_num_tokens":11937.884765625,"generate/avg_tokens_non_zero_rewards":11125.27380952381,"generate/avg_tokens_zero_rewards":12097.369158878504,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24149,"generate/std_num_tokens":3882.3090418572638,"loss/avg_final_rewards":0.1640625,"loss/avg_raw_advantages":0.0012504333863034844,"loss/avg_raw_advantages_abs":0.1251000463962555,"policy/policy_entropy":0.19222709105815738,"policy/policy_loss":7.823198941991905e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007415477591166564,"policy/raw_grad_norm":0.001102447509765625,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.1640625,"timing/step":4205.859765880043,"trainer/epoch":0}
+{"step":15,"async/staleness_mean":1.703125,"generate/avg_num_tokens":10819.3515625,"generate/avg_tokens_non_zero_rewards":9531.09677419355,"generate/avg_tokens_zero_rewards":11105.28878281623,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25148,"generate/std_num_tokens":3713.4985022756923,"loss/avg_final_rewards":0.181640625,"loss/avg_raw_advantages":-0.001738061779178679,"loss/avg_raw_advantages_abs":0.10060781985521317,"policy/policy_entropy":0.19566651748027653,"policy/policy_loss":1.7838118608892728e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006150492391498119,"policy/raw_grad_norm":0.001346588134765625,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.181640625,"timing/step":4588.221793039003,"trainer/epoch":0}
+{"step":16,"async/staleness_mean":1.640625,"generate/avg_num_tokens":11313.685546875,"generate/avg_tokens_non_zero_rewards":9162.0,"generate/avg_tokens_zero_rewards":11760.26179245283,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24972,"generate/std_num_tokens":4199.191746162719,"loss/avg_final_rewards":0.171875,"loss/avg_raw_advantages":6.0792273870902136e-05,"loss/avg_raw_advantages_abs":0.08020862936973572,"policy/policy_entropy":0.19867552362848073,"policy/policy_loss":1.1189188064975042e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005750729101237084,"policy/raw_grad_norm":0.00128936767578125,"reward/avg_pass_at_8":0.28125,"reward/avg_raw_reward":0.171875,"timing/step":4810.580587374046,"trainer/epoch":0}
+{"step":17,"async/staleness_mean":1.5625,"generate/avg_num_tokens":10844.0546875,"generate/avg_tokens_non_zero_rewards":10470.67415730337,"generate/avg_tokens_zero_rewards":10922.614657210403,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26203,"generate/std_num_tokens":3881.7259879397434,"loss/avg_final_rewards":0.173828125,"loss/avg_raw_advantages":-0.0055550821125507355,"loss/avg_raw_advantages_abs":0.09101925045251846,"policy/policy_entropy":0.20081515645142645,"policy/policy_loss":6.020457654187794e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.004961596513567201,"policy/raw_grad_norm":0.00159454345703125,"reward/avg_pass_at_8":0.28125,"reward/avg_raw_reward":0.173828125,"timing/step":3503.288930212846,"trainer/epoch":0}
+{"step":18,"async/staleness_mean":1.703125,"generate/avg_num_tokens":11015.08203125,"generate/avg_tokens_non_zero_rewards":11637.46052631579,"generate/avg_tokens_zero_rewards":10906.594036697248,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26538,"generate/std_num_tokens":3953.248603935866,"loss/avg_final_rewards":0.1484375,"loss/avg_raw_advantages":0.003047340316697955,"loss/avg_raw_advantages_abs":0.07736817747354507,"policy/policy_entropy":0.2135052295634523,"policy/policy_loss":-1.043862162930509e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.0047767863920853415,"policy/raw_grad_norm":0.0013294219970703125,"reward/avg_pass_at_8":0.265625,"reward/avg_raw_reward":0.1484375,"timing/step":3697.590688298922,"trainer/epoch":0}
+{"step":19,"async/staleness_mean":1.09375,"generate/avg_num_tokens":9763.001953125,"generate/avg_tokens_non_zero_rewards":9869.875,"generate/avg_tokens_zero_rewards":9743.210648148148,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25622,"generate/std_num_tokens":3749.3249639825913,"loss/avg_final_rewards":0.15625,"loss/avg_raw_advantages":0.004701052326709032,"loss/avg_raw_advantages_abs":0.14787836372852325,"policy/policy_entropy":0.21245330886449665,"policy/policy_loss":-7.139672781875106e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008342701584297174,"policy/raw_grad_norm":0.00106048583984375,"reward/avg_pass_at_8":0.3958333333333333,"reward/avg_raw_reward":0.15625,"timing/step":6247.273198880022,"trainer/epoch":0}
+{"step":20,"async/staleness_mean":0.984375,"generate/avg_num_tokens":10311.333984375,"generate/avg_tokens_non_zero_rewards":8615.714285714286,"generate/avg_tokens_zero_rewards":10490.784017278618,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27576,"generate/std_num_tokens":4202.477838627773,"loss/avg_final_rewards":0.095703125,"loss/avg_raw_advantages":-0.004628123715519905,"loss/avg_raw_advantages_abs":0.07581286877393723,"policy/policy_entropy":0.2198514414485544,"policy/policy_loss":2.5055335868273687e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00390106179202121,"policy/raw_grad_norm":0.002239227294921875,"reward/avg_pass_at_8":0.203125,"reward/avg_raw_reward":0.095703125,"timing/step":3683.694798693061,"trainer/epoch":0}
+{"step":21,"async/staleness_mean":1.625,"generate/avg_num_tokens":9981.158203125,"generate/avg_tokens_non_zero_rewards":8986.023529411765,"generate/avg_tokens_zero_rewards":10179.252927400468,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26296,"generate/std_num_tokens":4006.4444556418907,"loss/avg_final_rewards":0.166015625,"loss/avg_raw_advantages":-0.0009517140570096672,"loss/avg_raw_advantages_abs":0.09436691552400589,"policy/policy_entropy":0.22331321274396032,"policy/policy_loss":1.492436542349651e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006505488994662301,"policy/raw_grad_norm":0.0011425018310546875,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.166015625,"timing/step":2688.6806287160143,"trainer/epoch":0}
+{"step":22,"async/staleness_mean":1.875,"generate/avg_num_tokens":9693.916015625,"generate/avg_tokens_non_zero_rewards":9522.76923076923,"generate/avg_tokens_zero_rewards":9718.803131991051,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26021,"generate/std_num_tokens":3676.9179846705174,"loss/avg_final_rewards":0.126953125,"loss/avg_raw_advantages":-0.0027303651440888643,"loss/avg_raw_advantages_abs":0.06795687973499298,"policy/policy_entropy":0.22961094707716256,"policy/policy_loss":1.7855831586643944e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005025325771384814,"policy/raw_grad_norm":0.0013065338134765625,"reward/avg_pass_at_8":0.21875,"reward/avg_raw_reward":0.126953125,"timing/step":2892.5090383028146,"trainer/epoch":0}
+{"step":23,"async/staleness_mean":1.875,"generate/avg_num_tokens":9015.10546875,"generate/avg_tokens_non_zero_rewards":8034.220338983051,"generate/avg_tokens_zero_rewards":9308.873096446701,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30242,"generate/std_num_tokens":4029.328156793182,"loss/avg_final_rewards":0.23046875,"loss/avg_raw_advantages":-0.0029741472098976374,"loss/avg_raw_advantages_abs":0.13171382248401642,"policy/policy_entropy":0.23563165520317852,"policy/policy_loss":2.2168108451126045e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008840009284540429,"policy/raw_grad_norm":0.0009489059448242188,"reward/avg_pass_at_8":0.390625,"reward/avg_raw_reward":0.23046875,"timing/step":2417.879588205833,"trainer/epoch":0}
+{"step":24,"async/staleness_mean":1.765625,"generate/avg_num_tokens":9006.51953125,"generate/avg_tokens_non_zero_rewards":7572.977011494253,"generate/avg_tokens_zero_rewards":9299.974117647058,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25581,"generate/std_num_tokens":3849.12844279712,"loss/avg_final_rewards":0.169921875,"loss/avg_raw_advantages":-0.0067780502140522,"loss/avg_raw_advantages_abs":0.13192960619926453,"policy/policy_entropy":0.23873403831385076,"policy/policy_loss":1.587046671858161e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008033234577851545,"policy/raw_grad_norm":0.003902435302734375,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.169921875,"timing/step":2591.1554496511817,"trainer/epoch":0}
+{"step":25,"async/staleness_mean":1.484375,"generate/avg_num_tokens":9003.896484375,"generate/avg_tokens_non_zero_rewards":7411.025974025974,"generate/avg_tokens_zero_rewards":9285.852873563219,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":29941,"generate/std_num_tokens":4072.509812256459,"loss/avg_final_rewards":0.150390625,"loss/avg_raw_advantages":-0.004779601935297251,"loss/avg_raw_advantages_abs":0.1207507848739624,"policy/policy_entropy":0.2452373158885166,"policy/policy_loss":6.715754450326017e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008138476143358275,"policy/raw_grad_norm":0.00102996826171875,"reward/avg_pass_at_8":0.30357142857142855,"reward/avg_raw_reward":0.150390625,"timing/step":4561.494081897195,"trainer/epoch":0}
+{"step":26,"async/staleness_mean":1.0,"generate/avg_num_tokens":8622.01171875,"generate/avg_tokens_non_zero_rewards":7850.939759036145,"generate/avg_tokens_zero_rewards":8771.193473193473,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25129,"generate/std_num_tokens":3760.8618760390445,"loss/avg_final_rewards":0.162109375,"loss/avg_raw_advantages":0.0017682735342532396,"loss/avg_raw_advantages_abs":0.1285792887210846,"policy/policy_entropy":0.2520464884582907,"policy/policy_loss":2.3826420658679126e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007328983873776451,"policy/raw_grad_norm":0.000949859619140625,"reward/avg_pass_at_8":0.375,"reward/avg_raw_reward":0.162109375,"timing/step":2017.5475478242151,"trainer/epoch":0}
+{"step":27,"async/staleness_mean":1.765625,"generate/avg_num_tokens":9189.955078125,"generate/avg_tokens_non_zero_rewards":8092.058823529412,"generate/avg_tokens_zero_rewards":9358.101351351352,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24839,"generate/std_num_tokens":4323.662929605105,"loss/avg_final_rewards":0.1328125,"loss/avg_raw_advantages":0.004346746951341629,"loss/avg_raw_advantages_abs":0.1056930422782898,"policy/policy_entropy":0.2566796252503991,"policy/policy_loss":-1.22847141881266e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00545892059471953,"policy/raw_grad_norm":0.001018524169921875,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.1328125,"timing/step":2277.8071907367557,"trainer/epoch":0}
+{"step":28,"async/staleness_mean":2.125,"generate/avg_num_tokens":8719.71484375,"generate/avg_tokens_non_zero_rewards":7651.050359712231,"generate/avg_tokens_zero_rewards":9117.957104557641,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25411,"generate/std_num_tokens":4251.726803230767,"loss/avg_final_rewards":0.271484375,"loss/avg_raw_advantages":0.010601941496133804,"loss/avg_raw_advantages_abs":0.10304071754217148,"policy/policy_entropy":0.248472306644544,"policy/policy_loss":-1.442182700372996e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009371816738166672,"policy/raw_grad_norm":0.0008325576782226562,"reward/avg_pass_at_8":0.421875,"reward/avg_raw_reward":0.271484375,"timing/step":2055.8702136264183,"trainer/epoch":0}
+{"step":29,"async/staleness_mean":2.3125,"generate/avg_num_tokens":8530.779296875,"generate/avg_tokens_non_zero_rewards":7675.91011235955,"generate/avg_tokens_zero_rewards":8710.645390070922,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26162,"generate/std_num_tokens":3814.1119998991253,"loss/avg_final_rewards":0.173828125,"loss/avg_raw_advantages":0.006155760493129492,"loss/avg_raw_advantages_abs":0.11663798987865448,"policy/policy_entropy":0.2504065647954121,"policy/policy_loss":-9.027127170213589e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008392806101255701,"policy/raw_grad_norm":0.0007762908935546875,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.173828125,"timing/step":2059.2828750237823,"trainer/epoch":0}
+{"step":30,"async/staleness_mean":2.1875,"generate/avg_num_tokens":8033.111328125,"generate/avg_tokens_non_zero_rewards":6752.803571428572,"generate/avg_tokens_zero_rewards":8391.5975,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27098,"generate/std_num_tokens":3348.273771852882,"loss/avg_final_rewards":0.21875,"loss/avg_raw_advantages":-0.008964852429926395,"loss/avg_raw_advantages_abs":0.13920991122722626,"policy/policy_entropy":0.25663610687479377,"policy/policy_loss":1.1815737046561026e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009418263862244203,"policy/raw_grad_norm":0.0008630752563476562,"reward/avg_pass_at_8":0.421875,"reward/avg_raw_reward":0.21875,"timing/step":1692.8483859929256,"trainer/epoch":0}
+{"step":31,"async/staleness_mean":2.296875,"generate/avg_num_tokens":8216.111328125,"generate/avg_tokens_non_zero_rewards":7300.9358974358975,"generate/avg_tokens_zero_rewards":8380.589861751152,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25948,"generate/std_num_tokens":3551.055464426622,"loss/avg_final_rewards":0.15234375,"loss/avg_raw_advantages":0.001577701885253191,"loss/avg_raw_advantages_abs":0.0884578675031662,"policy/policy_entropy":0.2625905995955691,"policy/policy_loss":9.056617145120072e-08,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005948080246525933,"policy/raw_grad_norm":0.0010395050048828125,"reward/avg_pass_at_8":0.265625,"reward/avg_raw_reward":0.15234375,"timing/step":1969.9152718950063,"trainer/epoch":0}
+{"step":32,"async/staleness_mean":2.375,"generate/avg_num_tokens":8439.556640625,"generate/avg_tokens_non_zero_rewards":6737.115384615385,"generate/avg_tokens_zero_rewards":8745.52534562212,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":23928,"generate/std_num_tokens":3889.620730917809,"loss/avg_final_rewards":0.15234375,"loss/avg_raw_advantages":-0.006564537063241005,"loss/avg_raw_advantages_abs":0.08425632864236832,"policy/policy_entropy":0.26623984973412007,"policy/policy_loss":1.042172939946795e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006512630303404876,"policy/raw_grad_norm":0.0010509490966796875,"reward/avg_pass_at_8":0.265625,"reward/avg_raw_reward":0.15234375,"timing/step":2227.8955586119555,"trainer/epoch":0}
+{"step":33,"async/staleness_mean":2.375,"generate/avg_num_tokens":8452.41015625,"generate/avg_tokens_non_zero_rewards":7604.746987951808,"generate/avg_tokens_zero_rewards":8616.410256410256,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24504,"generate/std_num_tokens":3941.260987007756,"loss/avg_final_rewards":0.162109375,"loss/avg_raw_advantages":0.0006342987762764096,"loss/avg_raw_advantages_abs":0.1227927878499031,"policy/policy_entropy":0.25510654237587005,"policy/policy_loss":-1.1258239673850312e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008736123881590174,"policy/raw_grad_norm":0.0008411407470703125,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.162109375,"timing/step":1880.4757572351955,"trainer/epoch":0}
+{"step":34,"async/staleness_mean":1.96875,"generate/avg_num_tokens":8150.865234375,"generate/avg_tokens_non_zero_rewards":7106.529411764706,"generate/avg_tokens_zero_rewards":8310.808558558558,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24051,"generate/std_num_tokens":3794.4292549091097,"loss/avg_final_rewards":0.1328125,"loss/avg_raw_advantages":0.0008692203555256128,"loss/avg_raw_advantages_abs":0.11227869242429733,"policy/policy_entropy":0.26446314831264317,"policy/policy_loss":3.019232650558479e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.0066033733482981916,"policy/raw_grad_norm":0.0009622573852539062,"reward/avg_pass_at_8":0.3157894736842105,"reward/avg_raw_reward":0.1328125,"timing/step":3583.6257864767686,"trainer/epoch":0}
+{"step":35,"async/staleness_mean":0.96875,"generate/avg_num_tokens":8175.40234375,"generate/avg_tokens_non_zero_rewards":6532.51,"generate/avg_tokens_zero_rewards":8574.162621359223,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25152,"generate/std_num_tokens":4166.211938000545,"loss/avg_final_rewards":0.1953125,"loss/avg_raw_advantages":-0.001226629363372922,"loss/avg_raw_advantages_abs":0.1164650246500969,"policy/policy_entropy":0.2674451186321676,"policy/policy_loss":1.8878955643231166e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008993270268547349,"policy/raw_grad_norm":0.0007581710815429688,"reward/avg_pass_at_8":0.375,"reward/avg_raw_reward":0.1953125,"timing/step":2448.022929954808,"trainer/epoch":0}
+{"step":36,"async/staleness_mean":1.765625,"generate/avg_num_tokens":8569.685546875,"generate/avg_tokens_non_zero_rewards":7602.6760563380285,"generate/avg_tokens_zero_rewards":8725.371882086169,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25172,"generate/std_num_tokens":3781.879460100309,"loss/avg_final_rewards":0.138671875,"loss/avg_raw_advantages":-0.0037242623511701822,"loss/avg_raw_advantages_abs":0.08868999034166336,"policy/policy_entropy":0.26500918704550713,"policy/policy_loss":1.3630032675848724e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006329319606265926,"policy/raw_grad_norm":0.00099945068359375,"reward/avg_pass_at_8":0.265625,"reward/avg_raw_reward":0.138671875,"timing/step":2023.737669208087,"trainer/epoch":0}
+{"step":37,"async/staleness_mean":1.390625,"generate/avg_num_tokens":8359.568359375,"generate/avg_tokens_non_zero_rewards":7296.132075471698,"generate/avg_tokens_zero_rewards":8637.214285714286,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25107,"generate/std_num_tokens":3658.1980978962847,"loss/avg_final_rewards":0.20703125,"loss/avg_raw_advantages":-0.00382994394749403,"loss/avg_raw_advantages_abs":0.11880567669868469,"policy/policy_entropy":0.2647894473047927,"policy/policy_loss":8.986008026568015e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00881478434894234,"policy/raw_grad_norm":0.0008716583251953125,"reward/avg_pass_at_8":0.375,"reward/avg_raw_reward":0.20703125,"timing/step":4794.51497527305,"trainer/epoch":0}
+{"step":38,"async/staleness_mean":1.0,"generate/avg_num_tokens":8729.275390625,"generate/avg_tokens_non_zero_rewards":7117.242424242424,"generate/avg_tokens_zero_rewards":8967.82735426009,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24924,"generate/std_num_tokens":4008.999531369314,"loss/avg_final_rewards":0.12890625,"loss/avg_raw_advantages":-0.0035560934338718653,"loss/avg_raw_advantages_abs":0.09100429713726044,"policy/policy_entropy":0.2688232328509912,"policy/policy_loss":9.768856159553252e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006665974592579005,"policy/raw_grad_norm":0.0009002685546875,"reward/avg_pass_at_8":0.28125,"reward/avg_raw_reward":0.12890625,"timing/step":2481.1378593281843,"trainer/epoch":0}
+{"step":39,"async/staleness_mean":1.84375,"generate/avg_num_tokens":8429.80859375,"generate/avg_tokens_non_zero_rewards":7771.643835616438,"generate/avg_tokens_zero_rewards":8539.25284738041,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24909,"generate/std_num_tokens":3936.226032308885,"loss/avg_final_rewards":0.142578125,"loss/avg_raw_advantages":-0.0018265643157064915,"loss/avg_raw_advantages_abs":0.11231062561273575,"policy/policy_entropy":0.2751005010213703,"policy/policy_loss":1.818506660811181e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006773055443773046,"policy/raw_grad_norm":0.0010776519775390625,"reward/avg_pass_at_8":0.28125,"reward/avg_raw_reward":0.142578125,"timing/step":2332.7048763069324,"trainer/epoch":0}
+{"step":40,"async/staleness_mean":2.140625,"generate/avg_num_tokens":8772.287109375,"generate/avg_tokens_non_zero_rewards":7428.3125,"generate/avg_tokens_zero_rewards":9082.435096153846,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25015,"generate/std_num_tokens":4171.385065050646,"loss/avg_final_rewards":0.1875,"loss/avg_raw_advantages":0.0044614048674702644,"loss/avg_raw_advantages_abs":0.11403487622737885,"policy/policy_entropy":0.27879614918492734,"policy/policy_loss":-3.570694087073889e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007280434857420914,"policy/raw_grad_norm":0.0009517669677734375,"reward/avg_pass_at_8":0.375,"reward/avg_raw_reward":0.1875,"timing/step":2158.4758325950243,"trainer/epoch":0}
+{"step":41,"async/staleness_mean":2.21875,"generate/avg_num_tokens":8716.140625,"generate/avg_tokens_non_zero_rewards":6865.609756097561,"generate/avg_tokens_zero_rewards":9301.269922879177,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":24313,"generate/std_num_tokens":3921.0140130304126,"loss/avg_final_rewards":0.240234375,"loss/avg_raw_advantages":-0.005121576599776745,"loss/avg_raw_advantages_abs":0.10941809415817261,"policy/policy_entropy":0.2802881811512634,"policy/policy_loss":1.3286443572013695e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009372069907840341,"policy/raw_grad_norm":0.0009822845458984375,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.240234375,"timing/step":2380.049254124984,"trainer/epoch":0}
+{"step":42,"async/staleness_mean":2.328125,"generate/avg_num_tokens":8675.287109375,"generate/avg_tokens_non_zero_rewards":7392.808,"generate/avg_tokens_zero_rewards":9089.524547803618,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":23602,"generate/std_num_tokens":3907.880252510155,"loss/avg_final_rewards":0.244140625,"loss/avg_raw_advantages":0.00016087625408545136,"loss/avg_raw_advantages_abs":0.11920905113220215,"policy/policy_entropy":0.2811605960596353,"policy/policy_loss":7.394799261817298e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008903771042241715,"policy/raw_grad_norm":0.0009660720825195312,"reward/avg_pass_at_8":0.390625,"reward/avg_raw_reward":0.244140625,"timing/step":2235.372112269979,"trainer/epoch":0}
+{"step":43,"async/staleness_mean":1.578125,"generate/avg_num_tokens":8146.0,"generate/avg_tokens_non_zero_rewards":6813.911764705882,"generate/avg_tokens_zero_rewards":8477.397560975609,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26114,"generate/std_num_tokens":4020.4304996285846,"loss/avg_final_rewards":0.19921875,"loss/avg_raw_advantages":-0.007802317850291729,"loss/avg_raw_advantages_abs":0.1580718606710434,"policy/policy_entropy":0.2890364667400718,"policy/policy_loss":1.2024663895715548e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.011198079480891465,"policy/raw_grad_norm":0.0008573532104492188,"reward/avg_pass_at_8":0.38461538461538464,"reward/avg_raw_reward":0.19921875,"timing/step":5446.255247236928,"trainer/epoch":0}
+{"step":44,"async/staleness_mean":1.0,"generate/avg_num_tokens":9437.998046875,"generate/avg_tokens_non_zero_rewards":8071.714285714285,"generate/avg_tokens_zero_rewards":9654.3778280543,"generate/failed_trajectory_fraction":0.001953125,"generate/max_num_tokens":27001,"generate/std_num_tokens":4802.998744883821,"loss/avg_final_rewards":0.13671875,"loss/avg_raw_advantages":-0.0052741169929504395,"loss/avg_raw_advantages_abs":0.1189226359128952,"policy/policy_entropy":0.2879157244460657,"policy/policy_loss":1.529355378337982e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007491457441574312,"policy/raw_grad_norm":0.0013790130615234375,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.13671875,"timing/step":2913.559509156039,"trainer/epoch":0}
+{"step":45,"async/staleness_mean":1.75,"generate/avg_num_tokens":9041.490234375,"generate/avg_tokens_non_zero_rewards":6774.735294117647,"generate/avg_tokens_zero_rewards":9605.414634146342,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26182,"generate/std_num_tokens":4520.857839544768,"loss/avg_final_rewards":0.19921875,"loss/avg_raw_advantages":-0.0035168039612472057,"loss/avg_raw_advantages_abs":0.09181530028581619,"policy/policy_entropy":0.2909987417515367,"policy/policy_loss":6.327150376961299e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007422954747198673,"policy/raw_grad_norm":0.0009603500366210938,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.19921875,"timing/step":3084.2673707830254,"trainer/epoch":0}
+{"step":46,"async/staleness_mean":0.875,"generate/avg_num_tokens":8259.595703125,"generate/avg_tokens_non_zero_rewards":7605.38679245283,"generate/avg_tokens_zero_rewards":8430.399014778324,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26492,"generate/std_num_tokens":4263.425029601015,"loss/avg_final_rewards":0.20703125,"loss/avg_raw_advantages":-0.013118461705744267,"loss/avg_raw_advantages_abs":0.09052544832229614,"policy/policy_entropy":0.3056734409183264,"policy/policy_loss":1.9694319668417393e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00974274522423002,"policy/raw_grad_norm":0.0011081695556640625,"reward/avg_pass_at_8":0.29411764705882354,"reward/avg_raw_reward":0.20703125,"timing/step":7070.034014225006,"trainer/epoch":0}
+{"step":47,"async/staleness_mean":1.0,"generate/avg_num_tokens":10387.423828125,"generate/avg_tokens_non_zero_rewards":9463.77108433735,"generate/avg_tokens_zero_rewards":10566.125874125873,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26375,"generate/std_num_tokens":5227.461121371239,"loss/avg_final_rewards":0.162109375,"loss/avg_raw_advantages":-0.00417260592803359,"loss/avg_raw_advantages_abs":0.04630599170923233,"policy/policy_entropy":0.30557956150732934,"policy/policy_loss":2.33683931583073e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.003882210367009975,"policy/raw_grad_norm":0.001712799072265625,"reward/avg_pass_at_8":0.21875,"reward/avg_raw_reward":0.162109375,"timing/step":2772.290991407819,"trainer/epoch":0}
+{"step":48,"async/staleness_mean":1.875,"generate/avg_num_tokens":9421.37890625,"generate/avg_tokens_non_zero_rewards":7876.908163265306,"generate/avg_tokens_zero_rewards":9786.978260869566,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26099,"generate/std_num_tokens":4368.647168964187,"loss/avg_final_rewards":0.19140625,"loss/avg_raw_advantages":-0.0039308215491473675,"loss/avg_raw_advantages_abs":0.11343784630298615,"policy/policy_entropy":0.3074710522778332,"policy/policy_loss":1.2229538608465873e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.01040839788493031,"policy/raw_grad_norm":0.0009698867797851562,"reward/avg_pass_at_8":0.375,"reward/avg_raw_reward":0.19140625,"timing/step":3181.0612665340304,"trainer/epoch":0}
+{"step":49,"async/staleness_mean":1.890625,"generate/avg_num_tokens":9219.716796875,"generate/avg_tokens_non_zero_rewards":7454.241379310345,"generate/avg_tokens_zero_rewards":9581.12,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26033,"generate/std_num_tokens":4783.0605199363845,"loss/avg_final_rewards":0.169921875,"loss/avg_raw_advantages":0.002498070942237973,"loss/avg_raw_advantages_abs":0.11906687170267105,"policy/policy_entropy":0.3036602227948606,"policy/policy_loss":-5.342363067484257e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00947845229984523,"policy/raw_grad_norm":0.0009307861328125,"reward/avg_pass_at_8":0.359375,"reward/avg_raw_reward":0.169921875,"timing/step":3107.249698700849,"trainer/epoch":0}
+{"step":50,"async/staleness_mean":2.09375,"generate/avg_num_tokens":9547.40625,"generate/avg_tokens_non_zero_rewards":8267.58,"generate/avg_tokens_zero_rewards":9685.915584415585,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26049,"generate/std_num_tokens":5002.093986814891,"loss/avg_final_rewards":0.09765625,"loss/avg_raw_advantages":0.002024407498538494,"loss/avg_raw_advantages_abs":0.0485578291118145,"policy/policy_entropy":0.31965480255894363,"policy/policy_loss":-8.268469571248716e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.003482727381197037,"policy/raw_grad_norm":0.0012912750244140625,"reward/avg_pass_at_8":0.1875,"reward/avg_raw_reward":0.09765625,"timing/step":3427.9984126063064,"trainer/epoch":0}
+{"step":51,"async/staleness_mean":2.0,"generate/avg_num_tokens":9990.958984375,"generate/avg_tokens_non_zero_rewards":7699.271428571428,"generate/avg_tokens_zero_rewards":10353.89592760181,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26250,"generate/std_num_tokens":4775.0150793566445,"loss/avg_final_rewards":0.13671875,"loss/avg_raw_advantages":-0.0047527397982776165,"loss/avg_raw_advantages_abs":0.1103021427989006,"policy/policy_entropy":0.32656489266082644,"policy/policy_loss":5.014291417637651e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.00707310474535916,"policy/raw_grad_norm":0.0012569427490234375,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.13671875,"timing/step":3744.2121266839094,"trainer/epoch":0}
+{"step":52,"async/staleness_mean":1.015625,"generate/avg_num_tokens":10499.109375,"generate/avg_tokens_non_zero_rewards":7592.34,"generate/avg_tokens_zero_rewards":11204.635922330097,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26608,"generate/std_num_tokens":5624.68945529492,"loss/avg_final_rewards":0.1953125,"loss/avg_raw_advantages":-0.0010208401363343,"loss/avg_raw_advantages_abs":0.09705197811126709,"policy/policy_entropy":0.3335581294959411,"policy/policy_loss":5.072883269008344e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008387434737869626,"policy/raw_grad_norm":0.001224517822265625,"reward/avg_pass_at_8":0.3333333333333333,"reward/avg_raw_reward":0.1953125,"timing/step":8279.12804713007,"trainer/epoch":0}
+{"step":53,"async/staleness_mean":1.0,"generate/avg_num_tokens":10057.123046875,"generate/avg_tokens_non_zero_rewards":8042.0,"generate/avg_tokens_zero_rewards":10397.577625570777,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26227,"generate/std_num_tokens":5258.414567543752,"loss/avg_final_rewards":0.14453125,"loss/avg_raw_advantages":-0.006202935706824064,"loss/avg_raw_advantages_abs":0.0868324413895607,"policy/policy_entropy":0.3381909884046763,"policy/policy_loss":1.8669722265940436e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.007297491781628196,"policy/raw_grad_norm":0.001514434814453125,"reward/avg_pass_at_8":0.25,"reward/avg_raw_reward":0.14453125,"timing/step":2664.5530663589016,"trainer/epoch":0}
+{"step":54,"async/staleness_mean":1.875,"generate/avg_num_tokens":9678.37109375,"generate/avg_tokens_non_zero_rewards":7591.064516129032,"generate/avg_tokens_zero_rewards":10141.663484486873,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":26388,"generate/std_num_tokens":4784.194531518804,"loss/avg_final_rewards":0.181640625,"loss/avg_raw_advantages":-0.005927966441959143,"loss/avg_raw_advantages_abs":0.09328899532556534,"policy/policy_entropy":0.3633612405974418,"policy/policy_loss":2.8145531665302315e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008472242967854982,"policy/raw_grad_norm":0.0013751983642578125,"reward/avg_pass_at_8":0.296875,"reward/avg_raw_reward":0.181640625,"timing/step":3650.185230393894,"trainer/epoch":0}
+{"step":55,"async/staleness_mean":2.171875,"generate/avg_num_tokens":10411.666015625,"generate/avg_tokens_non_zero_rewards":9310.28125,"generate/avg_tokens_zero_rewards":10665.83173076923,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":25941,"generate/std_num_tokens":5185.13700018814,"loss/avg_final_rewards":0.1875,"loss/avg_raw_advantages":0.005737764295190573,"loss/avg_raw_advantages_abs":0.1463140994310379,"policy/policy_entropy":0.3668097753543407,"policy/policy_loss":-1.0202376614643072e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009982707390008727,"policy/raw_grad_norm":0.0009632110595703125,"reward/avg_pass_at_8":0.40625,"reward/avg_raw_reward":0.1875,"timing/step":4766.921925783157,"trainer/epoch":0}
+{"step":56,"async/staleness_mean":1.890625,"generate/avg_num_tokens":10620.34765625,"generate/avg_tokens_non_zero_rewards":8445.822222222223,"generate/avg_tokens_zero_rewards":11084.109004739337,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":29809,"generate/std_num_tokens":5523.311386487628,"loss/avg_final_rewards":0.17578125,"loss/avg_raw_advantages":-0.007907772436738014,"loss/avg_raw_advantages_abs":0.09605777263641357,"policy/policy_entropy":0.3636972000822425,"policy/policy_loss":3.490397723737715e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.005557403340844758,"policy/raw_grad_norm":0.0018749237060546875,"reward/avg_pass_at_8":0.328125,"reward/avg_raw_reward":0.17578125,"timing/step":3964.189185673371,"trainer/epoch":0}
+{"step":57,"async/staleness_mean":1.875,"generate/avg_num_tokens":11039.845703125,"generate/avg_tokens_non_zero_rewards":9345.072164948453,"generate/avg_tokens_zero_rewards":11435.973493975904,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27418,"generate/std_num_tokens":5405.577233575115,"loss/avg_final_rewards":0.189453125,"loss/avg_raw_advantages":0.007507964037358761,"loss/avg_raw_advantages_abs":0.1060580164194107,"policy/policy_entropy":0.38697593309916556,"policy/policy_loss":-2.3567315619033025e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009201306208979076,"policy/raw_grad_norm":0.001186370849609375,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.189453125,"timing/step":4748.439351412002,"trainer/epoch":0}
+{"step":58,"async/staleness_mean":0.609375,"generate/avg_num_tokens":11945.6953125,"generate/avg_tokens_non_zero_rewards":11228.893203883496,"generate/avg_tokens_zero_rewards":12126.210268948655,"generate/failed_trajectory_fraction":0.00390625,"generate/max_num_tokens":27493,"generate/std_num_tokens":6150.510504800844,"loss/avg_final_rewards":0.201171875,"loss/avg_raw_advantages":0.0025003906339406967,"loss/avg_raw_advantages_abs":0.16300296783447266,"policy/policy_entropy":0.4177480931393802,"policy/policy_loss":3.671130777149756e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.014197787017110386,"policy/raw_grad_norm":0.00124359130859375,"reward/avg_pass_at_8":0.4166666666666667,"reward/avg_raw_reward":0.201171875,"timing/step":9875.224191051908,"trainer/epoch":0}
+{"step":59,"async/staleness_mean":0.984375,"generate/avg_num_tokens":11575.060546875,"generate/avg_tokens_non_zero_rewards":9524.396825396825,"generate/avg_tokens_zero_rewards":11862.792873051225,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":29703,"generate/std_num_tokens":5956.860779794144,"loss/avg_final_rewards":0.123046875,"loss/avg_raw_advantages":-0.0035006857942789793,"loss/avg_raw_advantages_abs":0.08761342614889145,"policy/policy_entropy":0.41764762648381293,"policy/policy_loss":2.287662400846102e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.006892739470004017,"policy/raw_grad_norm":0.001705169677734375,"reward/avg_pass_at_8":0.265625,"reward/avg_raw_reward":0.123046875,"timing/step":5967.962672992144,"trainer/epoch":0}
+{"step":60,"async/staleness_mean":1.546875,"generate/avg_num_tokens":11873.125,"generate/avg_tokens_non_zero_rewards":11056.25,"generate/avg_tokens_zero_rewards":11981.559734513274,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":29500,"generate/std_num_tokens":5626.0215739010455,"loss/avg_final_rewards":0.1171875,"loss/avg_raw_advantages":0.003636080538854003,"loss/avg_raw_advantages_abs":0.11055222153663635,"policy/policy_entropy":0.43152059568092227,"policy/policy_loss":-9.484258391978528e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008591869624069659,"policy/raw_grad_norm":0.0012264251708984375,"reward/avg_pass_at_8":0.3125,"reward/avg_raw_reward":0.1171875,"timing/step":5322.306719806045,"trainer/epoch":0}
+{"step":61,"async/staleness_mean":1.609375,"generate/avg_num_tokens":12350.1328125,"generate/avg_tokens_non_zero_rewards":11411.978571428572,"generate/avg_tokens_zero_rewards":12703.201612903225,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30514,"generate/std_num_tokens":6199.974247830961,"loss/avg_final_rewards":0.2734375,"loss/avg_raw_advantages":-0.005648551508784294,"loss/avg_raw_advantages_abs":0.14002735912799835,"policy/policy_entropy":0.4602184642571956,"policy/policy_loss":2.7435726206448408e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.013399694073996216,"policy/raw_grad_norm":0.001880645751953125,"reward/avg_pass_at_8":0.453125,"reward/avg_raw_reward":0.2734375,"timing/step":5991.592536879703,"trainer/epoch":0}
+{"step":62,"async/staleness_mean":1.546875,"generate/avg_num_tokens":11827.33203125,"generate/avg_tokens_non_zero_rewards":10418.213235294117,"generate/avg_tokens_zero_rewards":12337.01329787234,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27735,"generate/std_num_tokens":5753.3824639488375,"loss/avg_final_rewards":0.265625,"loss/avg_raw_advantages":-0.003736194223165512,"loss/avg_raw_advantages_abs":0.1392456740140915,"policy/policy_entropy":0.47746485751122236,"policy/policy_loss":9.162238097104591e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.011443705617693922,"policy/raw_grad_norm":0.0017681121826171875,"reward/avg_pass_at_8":0.46875,"reward/avg_raw_reward":0.265625,"timing/step":5385.837114124093,"trainer/epoch":0}
+{"step":63,"async/staleness_mean":1.59375,"generate/avg_num_tokens":12837.427734375,"generate/avg_tokens_non_zero_rewards":11478.38596491228,"generate/avg_tokens_zero_rewards":13007.681318681318,"generate/failed_trajectory_fraction":0.001953125,"generate/max_num_tokens":29197,"generate/std_num_tokens":6078.297916133897,"loss/avg_final_rewards":0.111328125,"loss/avg_raw_advantages":-0.009539480321109295,"loss/avg_raw_advantages_abs":0.09877653419971466,"policy/policy_entropy":0.5093152353074402,"policy/policy_loss":3.6863803991593613e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.008908780561796448,"policy/raw_grad_norm":0.002593994140625,"reward/avg_pass_at_8":0.265625,"reward/avg_raw_reward":0.111328125,"timing/step":6230.082083825022,"trainer/epoch":0}
+{"step":64,"async/staleness_mean":0.53125,"generate/avg_num_tokens":13422.99609375,"generate/avg_tokens_non_zero_rewards":12933.420289855072,"generate/avg_tokens_zero_rewards":13499.250564334086,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30092,"generate/std_num_tokens":6395.515129026726,"loss/avg_final_rewards":0.134765625,"loss/avg_raw_advantages":-0.0019149556756019592,"loss/avg_raw_advantages_abs":0.11301226168870926,"policy/policy_entropy":0.5293293185532093,"policy/policy_loss":9.82752151656996e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.009566483376602264,"policy/raw_grad_norm":0.001873016357421875,"reward/avg_pass_at_8":0.30434782608695654,"reward/avg_raw_reward":0.134765625,"timing/step":10154.383708074005,"trainer/epoch":0}
+{"step":65,"async/staleness_mean":0.984375,"generate/avg_num_tokens":12917.7109375,"generate/avg_tokens_non_zero_rewards":11311.372340425532,"generate/avg_tokens_zero_rewards":13278.944976076555,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":30576,"generate/std_num_tokens":6387.428287149228,"loss/avg_final_rewards":0.18359375,"loss/avg_raw_advantages":-0.0013121777446940541,"loss/avg_raw_advantages_abs":0.12830360233783722,"policy/policy_entropy":0.5610155819449574,"policy/policy_loss":7.220311992739425e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.011286421251043066,"policy/raw_grad_norm":0.002407073974609375,"reward/avg_pass_at_8":0.390625,"reward/avg_raw_reward":0.18359375,"timing/step":7163.567044896998,"trainer/epoch":0}
+{"step":66,"async/staleness_mean":1.375,"generate/avg_num_tokens":13958.44140625,"generate/avg_tokens_non_zero_rewards":13873.722222222223,"generate/avg_tokens_zero_rewards":13976.509478672986,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":28741,"generate/std_num_tokens":6516.526721812627,"loss/avg_final_rewards":0.17578125,"loss/avg_raw_advantages":0.004518852569162846,"loss/avg_raw_advantages_abs":0.14305809140205383,"policy/policy_entropy":0.6256877051200718,"policy/policy_loss":-1.136031368531576e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.01238623321569321,"policy/raw_grad_norm":0.002162933349609375,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.17578125,"timing/step":6706.461922962997,"trainer/epoch":0}
+{"step":67,"async/staleness_mean":1.359375,"generate/avg_num_tokens":14313.8203125,"generate/avg_tokens_non_zero_rewards":12228.776315789473,"generate/avg_tokens_zero_rewards":14677.268348623853,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":29142,"generate/std_num_tokens":6390.396745536904,"loss/avg_final_rewards":0.1484375,"loss/avg_raw_advantages":-0.009015744552016258,"loss/avg_raw_advantages_abs":0.13885138928890228,"policy/policy_entropy":0.6556471716612577,"policy/policy_loss":3.5683096690775074e-06,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.01236404105929978,"policy/raw_grad_norm":0.003376007080078125,"reward/avg_pass_at_8":0.34375,"reward/avg_raw_reward":0.1484375,"timing/step":7437.145370946993,"trainer/epoch":0}
+{"step":68,"async/staleness_mean":1.28125,"generate/avg_num_tokens":14532.927734375,"generate/avg_tokens_non_zero_rewards":12126.197674418605,"generate/avg_tokens_zero_rewards":15018.793427230046,"generate/failed_trajectory_fraction":0.0,"generate/max_num_tokens":27192,"generate/std_num_tokens":6333.561667123961,"loss/avg_final_rewards":0.16796875,"loss/avg_raw_advantages":-0.0012404834851622581,"loss/avg_raw_advantages_abs":0.12768308818340302,"policy/policy_entropy":0.6911203351337463,"policy/policy_loss":7.268206303479019e-07,"policy/policy_lr":7.999999979801942e-06,"policy/ppo_clip_ratio":0.01262365348975436,"policy/raw_grad_norm":0.003765106201171875,"reward/avg_pass_at_8":0.390625,"reward/avg_raw_reward":0.16796875,"timing/step":7510.405918068995,"trainer/epoch":0}
diff --git a/viewer/build/inputs/marin/runs/marin-q3c-tt-x5-gradnorm0p45/run.json b/viewer/build/inputs/marin/runs/marin-q3c-tt-x5-gradnorm0p45/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..1e8841d3a4524a5cb059493bb92f944a9e9f7fee
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-q3c-tt-x5-gradnorm0p45/run.json
@@ -0,0 +1,28 @@
+{
+ "id": "marin-q3c-tt-x5-gradnorm0p45",
+ "title": "TaskTrove RL, max grad norm 0.45 (Qwen3-Coder-30B-A3B)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/laion/tt-x5_gradnorm-gn0p45-30-30B/tree/main/training_logs",
+ "license": "apache-2.0",
+ "model": "laion/tt-x5_gradnorm-gn0p45-30-30B",
+ "base_model": "Qwen/Qwen3-Coder-30B-A3B-Instruct",
+ "method": "GRPO (SkyRL + Terminus-2, pass-ratio shaped verifier reward)",
+ "dataset": "DCAgent/exp_rpt_multifile",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-09-04T16:23:13Z",
+ "attempts": 0,
+ "note": "Marin TaskTrove RL hyperparameter ablation (issue #7785) on Qwen3-Coder-30B-A3B-Instruct with DCAgent/exp_rpt_multifile tasks and the Terminus-2 harness; arm: X5 gradient-clipping arm: max grad norm 0.45. Our copy has every logged step of the final lineage (13 log segments, 9 superseded rows dropped).",
+ "metrics_map": {
+  "reward": "reward/avg_raw_reward",
+  "loss": "policy/policy_loss",
+  "entropy": "policy/policy_entropy",
+  "lr": "policy/policy_lr",
+  "grad_norm": "policy/raw_grad_norm",
+  "response_length": "generate/avg_num_tokens"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-snowball-e11-deepscaler-dapo/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-snowball-e11-deepscaler-dapo/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..ef93ef6947cbf7126fde502ec1128ebd4dc0bcf0
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-snowball-e11-deepscaler-dapo/metrics.jsonl
@@ -0,0 +1,51 @@
+{"step":0,"heldout/aime24":17.67,"heldout/aime24_se":1.06,"heldout/math500":64.0,"heldout/math500_se":2.15,"heldout/olympiadbench":12.67,"heldout/olympiadbench_se":1.03}
+{"step":1,"train/pass_at_1":0.053466796875,"train/pass_at_16":0.4296875,"reward/avg_raw_reward":-0.874453125}
+{"step":2,"train/pass_at_1":0.092529296875,"train/pass_at_16":0.5390625,"reward/avg_raw_reward":-0.816494141}
+{"step":3,"train/pass_at_1":0.11279296875,"train/pass_at_16":0.52734375,"reward/avg_raw_reward":-0.750654297}
+{"step":4,"train/pass_at_1":0.177001953125,"train/pass_at_16":0.5625,"reward/avg_raw_reward":-0.677050781}
+{"step":5,"train/pass_at_1":0.226806640625,"train/pass_at_16":0.65234375,"reward/avg_raw_reward":-0.577412109}
+{"step":6,"train/pass_at_1":0.212890625,"train/pass_at_16":0.6875,"reward/avg_raw_reward":-0.465449219,"heldout/aime24":16.33,"heldout/aime24_se":1.29,"heldout/math500":69.0,"heldout/math500_se":2.07,"heldout/olympiadbench":16.67,"heldout/olympiadbench_se":1.63}
+{"step":7,"train/pass_at_1":0.2626953125,"train/pass_at_16":0.6796875,"reward/avg_raw_reward":-0.415107422}
+{"step":8,"train/pass_at_1":0.296875,"train/pass_at_16":0.7421875,"reward/avg_raw_reward":-0.377226562}
+{"step":9,"train/pass_at_1":0.2607421875,"train/pass_at_16":0.76171875,"reward/avg_raw_reward":-0.455751953}
+{"step":10,"train/pass_at_1":0.319580078125,"train/pass_at_16":0.82421875,"reward/avg_raw_reward":-0.280556641}
+{"step":11,"train/pass_at_1":0.345458984375,"train/pass_at_16":0.8515625,"reward/avg_raw_reward":-0.246933594}
+{"step":12,"train/pass_at_1":0.33642578125,"train/pass_at_16":0.9140625,"reward/avg_raw_reward":-0.242255859,"heldout/aime24":17.67,"heldout/aime24_se":0.95,"heldout/math500":74.6,"heldout/math500_se":1.95,"heldout/olympiadbench":16.67,"heldout/olympiadbench_se":1.33}
+{"step":13,"train/pass_at_1":0.3720703125,"train/pass_at_16":0.94140625,"reward/avg_raw_reward":-0.157167969}
+{"step":14,"train/pass_at_1":0.376953125,"train/pass_at_16":0.9296875,"reward/avg_raw_reward":-0.17484375}
+{"step":15,"train/pass_at_1":0.37060546875,"train/pass_at_16":0.95703125}
+{"step":16,"train/pass_at_1":0.394287109375,"train/pass_at_16":0.98828125}
+{"step":17,"train/pass_at_1":0.397705078125,"train/pass_at_16":0.984375}
+{"step":18,"train/pass_at_1":0.39111328125,"train/pass_at_16":0.99609375,"heldout/aime24":19.67,"heldout/aime24_se":0.88,"heldout/math500":72.2,"heldout/math500_se":2.0,"heldout/olympiadbench":20.0,"heldout/olympiadbench_se":1.05}
+{"step":19,"train/pass_at_1":0.43701171875,"train/pass_at_16":0.9765625}
+{"step":20,"train/pass_at_1":0.40771484375,"train/pass_at_16":0.9453125}
+{"step":21,"train/pass_at_1":0.44677734375,"train/pass_at_16":0.96484375}
+{"step":22,"train/pass_at_1":0.443359375,"train/pass_at_16":0.9765625}
+{"step":23,"train/pass_at_1":0.430908203125,"train/pass_at_16":0.96875}
+{"step":24,"train/pass_at_1":0.4208984375,"train/pass_at_16":0.95703125,"heldout/aime24":20.0,"heldout/aime24_se":1.76,"heldout/math500":72.8,"heldout/math500_se":1.99,"heldout/olympiadbench":19.33,"heldout/olympiadbench_se":0.79}
+{"step":25,"train/pass_at_1":0.4580078125,"train/pass_at_16":0.96875}
+{"step":26,"train/pass_at_1":0.43798828125,"train/pass_at_16":0.94921875}
+{"step":27,"train/pass_at_1":0.458740234375,"train/pass_at_16":1}
+{"step":28,"train/pass_at_1":0.487060546875,"train/pass_at_16":1}
+{"step":29,"train/pass_at_1":0.47265625,"train/pass_at_16":1}
+{"step":30,"train/pass_at_1":0.47509765625,"train/pass_at_16":1}
+{"step":31,"train/pass_at_1":0.46630859375,"train/pass_at_16":1}
+{"step":32,"train/pass_at_1":0.4833984375,"train/pass_at_16":1,"heldout/aime24":20.33,"heldout/aime24_se":1.85,"heldout/math500":73.4,"heldout/math500_se":1.98,"heldout/olympiadbench":16.0,"heldout/olympiadbench_se":1.4}
+{"step":33,"train/pass_at_1":0.478271484375,"train/pass_at_16":1}
+{"step":34,"train/pass_at_1":0.503662109375,"train/pass_at_16":1}
+{"step":35,"train/pass_at_1":0.5234375,"train/pass_at_16":1}
+{"step":36,"train/pass_at_1":0.536376953125,"train/pass_at_16":1}
+{"step":37,"train/pass_at_1":0.553955078125,"train/pass_at_16":1}
+{"step":38,"train/pass_at_1":0.518310546875,"train/pass_at_16":1}
+{"step":39,"train/pass_at_1":0.520751953125,"train/pass_at_16":1}
+{"step":40,"train/pass_at_1":0.54248046875,"train/pass_at_16":1,"heldout/aime24":20.0,"heldout/aime24_se":1.94,"heldout/math500":68.0,"heldout/math500_se":2.09,"heldout/olympiadbench":15.33,"heldout/olympiadbench_se":1.71}
+{"step":41,"train/pass_at_1":0.49072265625,"train/pass_at_16":1}
+{"step":42,"train/pass_at_1":0.526123046875,"train/pass_at_16":1}
+{"step":43,"train/pass_at_1":0.504638671875,"train/pass_at_16":1}
+{"step":44,"train/pass_at_1":0.5263671875,"train/pass_at_16":1}
+{"step":45,"train/pass_at_1":0.533203125,"train/pass_at_16":1}
+{"step":46,"train/pass_at_1":0.5390625,"train/pass_at_16":1}
+{"step":47,"train/pass_at_1":0.533447265625,"train/pass_at_16":1}
+{"step":48,"train/pass_at_1":0.52978515625,"train/pass_at_16":1,"heldout/aime24":20.33,"heldout/aime24_se":1.45,"heldout/math500":70.0,"heldout/math500_se":2.05,"heldout/olympiadbench":14.67,"heldout/olympiadbench_se":1.26}
+{"step":49,"train/pass_at_1":0.525146484375,"train/pass_at_16":1}
+{"step":50,"train/pass_at_1":0.51416015625,"train/pass_at_16":1}
diff --git a/viewer/build/inputs/marin/runs/marin-snowball-e11-deepscaler-dapo/run.json b/viewer/build/inputs/marin/runs/marin-snowball-e11-deepscaler-dapo/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..a0d771720049d6288573d1dba4a123a658abfcae
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-snowball-e11-deepscaler-dapo/run.json
@@ -0,0 +1,26 @@
+{
+ "id": "marin-snowball-e11-deepscaler-dapo",
+ "title": "Snowball 67B-A2B math RL, E11: DeepScaleR + DAPO",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://storage.googleapis.com/marin-public/benjaminfeuer/snowball-67b-a2b-math-rl/2026.08.27.1/index.html",
+ "license": "unknown",
+ "model": "Snowball 67B-A2B, RL arm E11",
+ "base_model": "grug-67b-a2b-sft-s2-thinking-step630 (Marin Snowball 67B-A2B, 2T Thinking SFT)",
+ "method": "DAPO",
+ "dataset": "DeepScaleR",
+ "eval_suite": "AIME24, MATH-500, OlympiadBench (held-out math, evalchemy long-generation)",
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-08-31T11:03:10Z",
+ "attempts": 0,
+ "note": "Marin math RLVR on its Snowball 67B-A2B MoE (issue #7786), E11: DeepScaleR + DAPO; recipe: DAPO objective, MuonH lr 1e-4, on the hero-v3g recipe body. train/pass_at_1 and train/pass_at_16 are per-step training-batch values as Marin exported them from W&B (pass@1 source: environment/acc); reward/avg_raw_reward is the raw ±1 verifier reward for the steps the report plots. heldout/* are AIME24 / MATH-500 / OlympiadBench percentages (± SE in *_se) from MATH_EVALS.md at checkpoints; step 0 is the SFT base the RL started from.",
+ "metrics_map": {
+  "reward": "train/pass_at_1",
+  "eval:aime24": "heldout/aime24",
+  "eval:math500": "heldout/math500",
+  "eval:olympiadbench": "heldout/olympiadbench"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-snowball-e12-deepscaler-grpo/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-snowball-e12-deepscaler-grpo/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..f876c8f7ced05118c739165f294fd32bbdfa8932
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-snowball-e12-deepscaler-grpo/metrics.jsonl
@@ -0,0 +1,25 @@
+{"step":0,"heldout/aime24":17.67,"heldout/aime24_se":1.06,"heldout/math500":64.0,"heldout/math500_se":2.15,"heldout/olympiadbench":12.67,"heldout/olympiadbench_se":1.03}
+{"step":1,"train/pass_at_1":0.04541015625,"train/pass_at_16":0.2890625}
+{"step":2,"train/pass_at_1":0.072021484375,"train/pass_at_16":0.4296875}
+{"step":3,"train/pass_at_1":0.1181640625,"train/pass_at_16":0.4921875}
+{"step":4,"train/pass_at_1":0.16748046875,"train/pass_at_16":0.5390625}
+{"step":5,"train/pass_at_1":0.182373046875,"train/pass_at_16":0.578125}
+{"step":6,"train/pass_at_1":0.201904296875,"train/pass_at_16":0.5546875}
+{"step":7,"train/pass_at_1":0.254638671875,"train/pass_at_16":0.60546875}
+{"step":8,"train/pass_at_1":0.311767578125,"train/pass_at_16":0.70703125,"heldout/aime24":20.0,"heldout/aime24_se":1.05,"heldout/math500":71.0,"heldout/math500_se":2.03,"heldout/olympiadbench":15.0,"heldout/olympiadbench_se":1.27}
+{"step":9,"train/pass_at_1":0.32373046875,"train/pass_at_16":0.73046875}
+{"step":10,"train/pass_at_1":0.36328125,"train/pass_at_16":0.76171875}
+{"step":11,"train/pass_at_1":0.373291015625,"train/pass_at_16":0.7265625}
+{"step":12,"train/pass_at_1":0.32666015625,"train/pass_at_16":0.703125}
+{"step":13,"train/pass_at_1":0.351318359375,"train/pass_at_16":0.71484375}
+{"step":14,"train/pass_at_1":0.354736328125,"train/pass_at_16":0.73828125}
+{"step":15,"train/pass_at_1":0.39208984375,"train/pass_at_16":0.7265625}
+{"step":16,"train/pass_at_1":0.377197265625,"train/pass_at_16":0.76953125,"heldout/aime24":16.67,"heldout/aime24_se":0.94,"heldout/math500":70.2,"heldout/math500_se":2.05,"heldout/olympiadbench":18.0,"heldout/olympiadbench_se":1.26}
+{"step":17,"train/pass_at_1":0.31396484375,"train/pass_at_16":0.69921875}
+{"step":18,"train/pass_at_1":0.342529296875,"train/pass_at_16":0.7265625}
+{"step":19,"train/pass_at_1":0.374267578125,"train/pass_at_16":0.76953125}
+{"step":20,"train/pass_at_1":0.389892578125,"train/pass_at_16":0.76953125}
+{"step":21,"train/pass_at_1":0.395263671875,"train/pass_at_16":0.76171875}
+{"step":22,"train/pass_at_1":0.388427734375,"train/pass_at_16":0.7578125}
+{"step":23,"train/pass_at_1":0.40087890625,"train/pass_at_16":0.74609375}
+{"step":24,"train/pass_at_1":0.400390625,"train/pass_at_16":0.74609375,"heldout/aime24":16.0,"heldout/aime24_se":1.32,"heldout/math500":71.8,"heldout/math500_se":2.01,"heldout/olympiadbench":16.33,"heldout/olympiadbench_se":0.99}
diff --git a/viewer/build/inputs/marin/runs/marin-snowball-e12-deepscaler-grpo/run.json b/viewer/build/inputs/marin/runs/marin-snowball-e12-deepscaler-grpo/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..68ac66cfbdc024d2c2c77727325909350c7f018c
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-snowball-e12-deepscaler-grpo/run.json
@@ -0,0 +1,26 @@
+{
+ "id": "marin-snowball-e12-deepscaler-grpo",
+ "title": "Snowball 67B-A2B math RL, E12: DeepScaleR + GRPO (control for E11)",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://storage.googleapis.com/marin-public/benjaminfeuer/snowball-67b-a2b-math-rl/2026.08.27.1/index.html",
+ "license": "unknown",
+ "model": "Snowball 67B-A2B, RL arm E12",
+ "base_model": "grug-67b-a2b-sft-s2-thinking-step630 (Marin Snowball 67B-A2B, 2T Thinking SFT)",
+ "method": "GRPO",
+ "dataset": "DeepScaleR",
+ "eval_suite": "AIME24, MATH-500, OlympiadBench (held-out math, evalchemy long-generation)",
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-08-31T11:03:10Z",
+ "attempts": 0,
+ "note": "Marin math RLVR on its Snowball 67B-A2B MoE (issue #7786), E12: DeepScaleR + GRPO (control for E11); recipe: GRPO objective (the E11 recipe without DAPO), 10k context. train/pass_at_1 and train/pass_at_16 are per-step training-batch values as Marin exported them from W&B (pass@1 source: environment/acc). heldout/* are AIME24 / MATH-500 / OlympiadBench percentages (± SE in *_se) from MATH_EVALS.md at checkpoints; step 0 is the SFT base the RL started from.",
+ "metrics_map": {
+  "reward": "train/pass_at_1",
+  "eval:aime24": "heldout/aime24",
+  "eval:math500": "heldout/math500",
+  "eval:olympiadbench": "heldout/olympiadbench"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-snowball-e6-rlvr-math/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-snowball-e6-rlvr-math/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..c719c4768c5ec8a2298e9c98aec729dde58bcab0
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-snowball-e6-rlvr-math/metrics.jsonl
@@ -0,0 +1,21 @@
+{"step":0,"heldout/aime24":17.67,"heldout/aime24_se":1.06,"heldout/math500":64.0,"heldout/math500_se":2.15,"heldout/olympiadbench":12.67,"heldout/olympiadbench_se":1.03}
+{"step":1,"train/pass_at_1":0.1103515625,"train/pass_at_16":0.58203125,"reward/avg_raw_reward":-0.779296875}
+{"step":2,"train/pass_at_1":0.18603515625,"train/pass_at_16":0.44921875,"reward/avg_raw_reward":-0.6279296875}
+{"step":3,"train/pass_at_1":0.230224609375,"train/pass_at_16":0.52734375,"reward/avg_raw_reward":-0.53955078125}
+{"step":4,"train/pass_at_1":0.293701171875,"train/pass_at_16":0.5625,"reward/avg_raw_reward":-0.41259765625}
+{"step":5,"train/pass_at_1":0.256103515625,"train/pass_at_16":0.5078125,"reward/avg_raw_reward":-0.48779296875,"heldout/aime24":20.33,"heldout/aime24_se":2.08,"heldout/math500":71.8,"heldout/math500_se":2.01,"heldout/olympiadbench":16.33,"heldout/olympiadbench_se":1.1}
+{"step":6,"train/pass_at_1":0.267822265625,"train/pass_at_16":0.57421875,"reward/avg_raw_reward":-0.46435546875}
+{"step":7,"train/pass_at_1":0.28564453125,"train/pass_at_16":0.58984375,"reward/avg_raw_reward":-0.4287109375}
+{"step":8,"train/pass_at_1":0.289794921875,"train/pass_at_16":0.59765625,"reward/avg_raw_reward":-0.42041015625}
+{"step":9,"train/pass_at_1":0.314453125,"train/pass_at_16":0.6015625,"reward/avg_raw_reward":-0.37109375}
+{"step":10,"train/pass_at_1":0.34765625,"train/pass_at_16":0.66015625,"reward/avg_raw_reward":-0.3046875,"heldout/aime24":25.33,"heldout/aime24_se":1.43,"heldout/math500":74.0,"heldout/math500_se":1.96,"heldout/olympiadbench":19.33,"heldout/olympiadbench_se":1.03}
+{"step":11,"train/pass_at_1":0.3427734375,"train/pass_at_16":0.63671875,"reward/avg_raw_reward":-0.314453125}
+{"step":12,"train/pass_at_1":0.33837890625,"train/pass_at_16":0.63671875,"reward/avg_raw_reward":-0.3232421875}
+{"step":13,"train/pass_at_1":0.36669921875,"train/pass_at_16":0.6484375,"reward/avg_raw_reward":-0.2666015625}
+{"step":14,"train/pass_at_1":0.39013671875,"train/pass_at_16":0.61328125,"reward/avg_raw_reward":-0.2197265625}
+{"step":15,"train/pass_at_1":0.329345703125,"train/pass_at_16":0.5703125,"reward/avg_raw_reward":-0.34130859375,"heldout/aime24":27.33,"heldout/aime24_se":1.87,"heldout/math500":78.4,"heldout/math500_se":1.84,"heldout/olympiadbench":19.67,"heldout/olympiadbench_se":1.2}
+{"step":16,"train/pass_at_1":0.33544921875,"train/pass_at_16":0.56640625,"reward/avg_raw_reward":-0.3291015625}
+{"step":17,"train/pass_at_1":0.3466796875,"train/pass_at_16":0.6015625,"reward/avg_raw_reward":-0.306640625}
+{"step":18,"train/pass_at_1":0.38623046875,"train/pass_at_16":0.64453125,"reward/avg_raw_reward":-0.2275390625}
+{"step":19,"train/pass_at_1":0.355712890625,"train/pass_at_16":0.59765625,"reward/avg_raw_reward":-0.28857421875}
+{"step":20,"train/pass_at_1":0.41162109375,"train/pass_at_16":0.6328125,"reward/avg_raw_reward":-0.1767578125,"heldout/aime24":26.0,"heldout/aime24_se":2.2,"heldout/math500":76.8,"heldout/math500_se":1.89,"heldout/olympiadbench":22.67,"heldout/olympiadbench_se":1.03}
diff --git a/viewer/build/inputs/marin/runs/marin-snowball-e6-rlvr-math/run.json b/viewer/build/inputs/marin/runs/marin-snowball-e6-rlvr-math/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..0d9fe54a46abead0da45c9bea71fb97ae0620b15
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-snowball-e6-rlvr-math/run.json
@@ -0,0 +1,26 @@
+{
+ "id": "marin-snowball-e6-rlvr-math",
+ "title": "Snowball 67B-A2B math RL, E6: RLVR-MATH + unregularized GRPO",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://storage.googleapis.com/marin-public/benjaminfeuer/snowball-67b-a2b-math-rl/2026.08.27.1/index.html",
+ "license": "unknown",
+ "model": "Snowball 67B-A2B, RL arm E6",
+ "base_model": "grug-67b-a2b-sft-s2-thinking-step630 (Marin Snowball 67B-A2B, 2T Thinking SFT)",
+ "method": "unregularized GRPO",
+ "dataset": "RLVR-MATH",
+ "eval_suite": "AIME24, MATH-500, OlympiadBench (held-out math, evalchemy long-generation)",
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-08-31T11:03:10Z",
+ "attempts": 0,
+ "note": "Marin math RLVR on its Snowball 67B-A2B MoE (issue #7786), E6: RLVR-MATH + unregularized GRPO; recipe: unregularized GRPO, AdamW 1e-5, mutable router bias, 8192-token window. train/pass_at_1 and train/pass_at_16 are per-step training-batch values as Marin exported them from W&B (pass@1 source: derived from reward/avg_raw_reward (binary -1/+1 verifier)); reward/avg_raw_reward is the raw ±1 verifier reward for the steps the report plots. heldout/* are AIME24 / MATH-500 / OlympiadBench percentages (± SE in *_se) from MATH_EVALS.md at checkpoints; step 0 is the SFT base the RL started from. The E6 original checkpoints were evaluated as router-bias-repaired exports, which the report treats as exceptional.",
+ "metrics_map": {
+  "reward": "train/pass_at_1",
+  "eval:aime24": "heldout/aime24",
+  "eval:math500": "heldout/math500",
+  "eval:olympiadbench": "heldout/olympiadbench"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/attempts.jsonl.gz b/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/attempts.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..1a611917b20518c56397dd4fed31c4f8676b6a2e
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/attempts.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06b23605be6502a3a3b3b13b671453abe7d31ad4760c27be776e77e3547f92de
+size 104201
diff --git a/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/metrics.jsonl b/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/metrics.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..d50b50b12efd3b7df32a8e803ff6eae7fd5f43a2
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/metrics.jsonl
@@ -0,0 +1,8 @@
+{"step":0,"eval/all/avg_score":0.3900156005367927,"eval/all/pass_at_1":0.33}
+{"step":2,"eval/all/avg_score":0.4240115799667958,"eval/all/pass_at_1":0.36}
+{"step":4,"eval/all/avg_score":0.39001515777121,"eval/all/pass_at_1":0.35}
+{"step":6,"eval/all/avg_score":0.4450100969889983,"eval/all/pass_at_1":0.4}
+{"step":8,"eval/all/avg_score":0.41000572190319934,"eval/all/pass_at_1":0.38}
+{"step":10,"eval/all/avg_score":0.4245046222664016,"eval/all/pass_at_1":0.38}
+{"step":12,"eval/all/avg_score":0.35450047687172154,"eval/all/pass_at_1":0.31}
+{"step":14,"eval/all/avg_score":0.278,"eval/all/pass_at_1":0.18}
diff --git a/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/run.json b/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..767b344e920dc120850cb1bb38b1ebde5d1b949e
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/run.json
@@ -0,0 +1,23 @@
+{
+ "id": "marin-snowball-v104-rlvr1-traces",
+ "title": "Snowball 67B-A2B RLVR1 (v104): rollouts and holdout samples",
+ "source": "public",
+ "org": "Marin",
+ "project": "marin",
+ "url": "https://huggingface.co/datasets/open-athena/Snowball-67B-A2B-Mixed-RLVR-Experiment-Artifacts/tree/main/01-provenance-and-history/history/v104-termination-20260917",
+ "license": "unknown (the card states none; prompts come from nvidia/Nemotron-RL-Ultra-Training-Blends, whose components are CC BY-SA 4.0, CC BY 4.0, ODC-BY 1.0, MIT and Apache-2.0)",
+ "model": "Snowball 67B-A2B RLVR1 policy (v104)",
+ "base_model": "open-athena/Grug-67B-A2B-Datakit-SFT-262K-2026.09.11",
+ "method": "GRPO in SkyRL (Megatron): 512 prompts x 16 rollouts per step, AdamW lr 4e-6 (resolved config), clip 0.2, no KL, temperature 1.0, up to 6,528 generated tokens; cancelled after 15 updates",
+ "dataset": "RLVR1: NVIDIA Nemotron RL Ultra training blend (skyrl_gym route of the TaskTrove conversion)",
+ "eval_suite": "RLVR1 holdout, 100 prompts, 1 sample each",
+ "kind": "training",
+ "state": "finished",
+ "started_at": null,
+ "updated_at": "2026-09-26T04:23:47Z",
+ "attempts": 1952,
+ "note": "Marin's Snowball 67B-A2B RLVR1 run v104 (SkyRL GRPO, 512 prompts x 16 rollouts per step, from Grug-67B-A2B-Datakit-SFT on the mixed-domain Nemotron RL Ultra blend; cancelled after 15 updates). The release keeps the retained trace archives of rollout steps 1 and 15 (6,500 and 8,165 of 8,192 rollouts; 315 and 487 prompts have all 16) and the 100-prompt holdout at steps 0-14. We kept 36 whole 16-rollout groups per step drawn at random (seed 20260925) from the complete ones (1152 rollouts; train@0 is step 1, train@14 step 15) and all 8 x 100 holdout samples. Rewards are published: reward.outcome for rollouts, the sum of the per-token score list for holdout samples (it reproduces every published avg_score). Holdout avg_score falls from 0.390 at step 0 to 0.278 at step 14; many late responses are degenerate. The expected answer or tool call, where the prompt record has one, is shown as the grader's single check. Long texts are cut (message text and reasoning at 20,000 characters, tool output at 6,000, tool arguments at 20,000, verifier output to its last 8,000); cut here: 1,076 messages, 27 reasonings, 31 tool arguments.",
+ "metrics_map": {
+  "eval:rlvr1-holdout": "eval/all/avg_score"
+ }
+}
diff --git a/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/transcripts.json.gz b/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/transcripts.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..853993d002908385a383a4e8d85d7630613d8901
--- /dev/null
+++ b/viewer/build/inputs/marin/runs/marin-snowball-v104-rlvr1-traces/transcripts.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38e468c9150087c818b0ace45950a0934806894dcb1f33be2ade7d3be966eec5
+size 690656
diff --git a/viewer/build/inputs/mimo/SOURCE.md b/viewer/build/inputs/mimo/SOURCE.md
new file mode 100644
index 0000000000000000000000000000000000000000..cb05e9b94a140ff9c6593c4960965cff4316f760
--- /dev/null
+++ b/viewer/build/inputs/mimo/SOURCE.md
@@ -0,0 +1,14 @@
+# Source of these files
+
+Published by Xiaomi MiMo on the public RL dashboard https://mimo.xiaomi.com/rl/ (JSON API under `/rl/api/`), for the mimo-v2.6-pro and mimo-v2.6-flash reinforcement-learning runs (Sept 15–21, 2026). The data remains the property of Xiaomi MiMo.
+
+Copied from the archive kept by the community project https://github.com/huanghw1989/mimo-rl-telemetry (MIT-licensed code; `data/store/` is its snapshot of the public API; `content/metrics.en.json` and `content/insights.en.json` are its metric explainers and insights). `dashboard-runs.json` is the dashboard's own `api/runs` response (official descriptions of 22 metrics), fetched Sept 26, 2026.
+
+Used by `viewer/build/labs/mimo.py` to build the demo database. Nothing here is modified; files are gzipped.
+
+## Added for the MiMo lab module (Sept 26, 2026)
+
+- `rl-oss-tasks.json.gz`: task ids and shortened instructions (first line, or about the first 220 characters) of the released RL environments, https://huggingface.co/datasets/XiaomiMiMo/MiMo-V2.6-RL-oss (Apache-2.0), read from its `code.parquet`, `general/train.parquet`, `webdev.parquet` and `music.parquet`. It keeps 2,000 of the 2,698 code tasks (sampled after leaving out 637 whose statement mentions security topics), 947 of the 989 general tasks (the terminal-bench tasks in the Security category and two others are left out), 2,000 of the 2,093 webdev tasks and all 1,000 music tasks, plus full prompts for ten sample rows and per-config counts (`stats`). No rows of `cyber.parquet` are copied; only its row count.
+- `blog-rl-curves.json`: the data behind the "RL training progress" chart in the MiMo-V2.6 launch blog, https://mimo.xiaomi.com/mimo-v2-6/rl-curves.js (snapshot 2026-09-22; the same data as the technical report's Fig. 9): benchmark score and total tokens in thousands per RL step for DeepSWE v1.1, AutomationBench v1.0.6 and MiMo Visual Coding, Pro and Flash.
+
+Every other published number the module uses (model sizes, Tables 3, 4, 6 and 7 of the technical report, the hack-agent rounds read from its Fig. 6b, the RL cost split from its Fig. 3, the verl `mimo-oss` recipe hyperparameters) is written into `viewer/build/labs/mimo.py` next to its source URL.
diff --git a/viewer/build/inputs/mimo/benchmarks.json.gz b/viewer/build/inputs/mimo/benchmarks.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..b6cd20818d54042942e6992970ef1d5823e08f83
--- /dev/null
+++ b/viewer/build/inputs/mimo/benchmarks.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8205efb8d2db620e803c8be410bfb2616affbb01bb953fe23a1f95c18e587765
+size 1007
diff --git a/viewer/build/inputs/mimo/blog-rl-curves.json b/viewer/build/inputs/mimo/blog-rl-curves.json
new file mode 100644
index 0000000000000000000000000000000000000000..7a675fd2c2667464bafb5434ee993785713f733d
--- /dev/null
+++ b/viewer/build/inputs/mimo/blog-rl-curves.json
@@ -0,0 +1 @@
+{"source":"https://mimo.xiaomi.com/mimo-v2-6/rl-curves.js","note":"Data behind the launch blog's 'RL training progress' figure (TR Fig. 9): benchmark score and total tokens in thousands per RL step, snapshot 2026-09-22.","panels":[{"domain":"Coding","title":"DeepSWE v1.1","score":{"steps":[1,2,3,4,5,6,8,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"pro":[58.41,56.25,58.41,60.47,59.59,58.55,62.24,63.72,65.78,65.97,63.27,64.6,63.42,65.18,66.37,67.46,67.95,68.05,68.15,70.92,70.36,69.35,68.56,72.57,69.54,68.25,71.09,72.57],"flash":[48.67,53.1,56.78,54.03,57.23,54.57,57.08,60.18,54.13,60.77,57.52,59.59,60.77,63.86,58.11,64.01,61.65,63.72,59.59,64.01,61.36,65.78,64.9,66.08,66.08,67.86,65.78,65.68]},"tokens":{"steps":[1,2,3,4,5,6,8,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"pro":[138.7,136.3,138.6,141.1,139,144.7,145.9,151.4,155.5,159.7,162,161.7,167.2,169.7,169.9,177,179.4,183.3,189.1,193.4,198.8,201,203.7,205.3,208.2,209.8,214.2,214],"flash":[154.1,158.1,154,156.2,158.5,158.6,161.2,165.5,170.2,170,177.5,176,177.3,181.4,193.3,200.3,196.8,203.7,207.2,207.7,225.9,214.5,220.3,229.1,228.8,228.9,234,236.6]}},{"domain":"General workflows","title":"AutomationBench v1.0.6","score":{"steps":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"pro":[46.5,45.2,45.1,45.9,45.8,46.2,47.1,46.3,47.7,47.2,47.8,50.1,48.9,49.1,49.8,50.7,49.8,51.4,50.7,50.5,50.4,51.4,51,52.1,51.9,52.1,51.3,53.3,54.1,53.1,55],"flash":[45.2,44.8,44.7,44.7,45.4,45.8,45.6,46.6,47.4,47.6,47.6,48.6,48.6,48.2,48.5,49.9,49.4,50.1,50.4,50.8,50.2,49.9,50.8,51.2,52.3,51.6,52.4,52.2,52.3,52.8,52.7]},"tokens":{"steps":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],"pro":[6.9,6.9,6.9,7,7,7.2,7.4,7.5,7.7,7.9,7.9,8,8.3,8.3,8.5,8.9,9.2,9,9.2,9.7,10.1,10.6,10.9,11.6,12.1,12.3,13.7,13.4,13.6,15.2,14.3],"flash":[7.6,7.8,7.7,7.7,7.7,7.9,7.8,7.9,7.9,8.1,8.3,8.4,8.6,8.6,9,8.6,8.7,8.8,8.8,9,9.2,9.2,9.1,9.2,9.1,9,9,9.1,8.9,9.2,9.3]}},{"domain":"Visual tasks","title":"MiMo Visual Coding","score":{"steps":[0,3,6,9,12,15,18,21,24,27,30],"pro":[68.46,70.495,69.635,71.31,69.795,71.97,71.95,73.3,74.29,74.84,74.915],"flash":[65.275,65.185,69.07,69.07,70.595,71.56,73.41,74.805,73.06,75.35,72.9]},"tokens":{"steps":[0,3,6,9,12,15,18,21,24,27,30],"pro":[80.1,80.5,80.5,79.2,86,92.9,96,102.2,116.8,127.4,139.8],"flash":[82.6,80.9,85.8,87.4,99.9,95.2,124.4,124.3,142.3,150.4,157.1]}}]}
\ No newline at end of file
diff --git a/viewer/build/inputs/mimo/dashboard-runs.json b/viewer/build/inputs/mimo/dashboard-runs.json
new file mode 100644
index 0000000000000000000000000000000000000000..946b63712b92ef8d42b8b142b3e37b8aa3a1fc44
--- /dev/null
+++ b/viewer/build/inputs/mimo/dashboard-runs.json
@@ -0,0 +1 @@
+{"title":"mimo-v2.6 RL","subtitle":"Two reinforcement-learning runs, mimo-v2.6-pro and mimo-v2.6-flash, read directly from the trainer's logs.","runs":[{"key":"pro","label":"mimo-v2.6-pro","note":"","color_index":1},{"key":"flash","label":"mimo-v2.6-flash","note":"","color_index":0}],"pins":["dynsam/avg@n","critic/rewards/mean","actor/entropy_loss","actor/pg_loss","actor/grad_norm","train_infer_diff/new_infer/kl","ctx_total_length/mean","dynsam/agg_turn/mean","perf/total_num_tokens","timing_s/step","timing_s/outer_gen","timing_s/trainer_ops","dynsam/passrate/zero","dynsam/passrate/one","dynsam/infra_error/seq_rate","env/active","partial/avg_staleness","dynsam/num_measurable"],"formats":[["^timing_s/","duration"],["^perf/time_per_step$","duration"],["^perf/gpu_time_s/","duration"],["_ns$","compact"],["_gb$","gb"],["^actor/lr$","sci"],["(^|/)(avg@n|avg@n_no_infra|score_mean|accept_rate|valid_rate)$","ratio"],["(^|/)(seq_rate|effect_ratio|ok_frac|missing_frac|zero|one|mid|zero_no_infra|one_no_infra|mid_no_infra|hist9_ratio/\\d+)$","pct"],["(^|/)(hist9_cnt/\\d+|num_[a-z_]+|n_[a-z_]+|count|size|in_flight|active|total|rollouts|max_load|min_load|dead_replaced)$","int"],["(length|tokens|_len|decode|prefill)","compact"]],"compositions":[{"key":"source","label":"data source","prefix":"dynsam","groups":["code","general","cyber","visual","chat"],"derive":"trained","unit":"prompts"},{"key":"harness","label":"harness (trained)","prefix":"train/harness","metric":"training/rollouts","unit":"rollouts"}],"categories":["code","general","cyber","visual","chat"],"social":{"handle":"@XiaomiMiMo","url":"https://x.com/XiaomiMiMo"},"footer_note":"Open is what we value.","stream_start":1789531200.0,"descriptions":{"dynsam/avg@n":"mean pass rate: for each prompt sampled this step, the fraction of its n attempts that succeed, averaged over prompts","dynsam/avg@n_no_infra":"avg@n with attempts that failed for infrastructure reasons excluded","critic/rewards/mean":"mean reward over trajectories trained on this step","actor/entropy_loss":"mean per-token entropy of the policy","actor/pg_loss":"clipped policy-gradient objective","actor/grad_norm":"global gradient norm before clipping","train_infer_diff/new_infer/kl":"KL between inference-engine and trainer log-probs on the same tokens","ctx_response_length/mean":"tokens generated per trajectory","dynsam/agg_turn/mean":"agent turns per trajectory","perf/total_num_tokens":"tokens trained on this step","timing_s/step":"wall-clock of the whole step","timing_s/outer_gen":"wall-clock of rollout generation","timing_s/trainer_ops":"wall-clock of the trainer","dynsam/passrate/zero":"share of prompts where no attempt succeeded","dynsam/passrate/one":"share of prompts where every attempt succeeded","dynsam/infra_error/seq_rate":"share of sequences lost to infrastructure failures","env/active":"sandbox environments in flight","partial/avg_staleness":"policy versions between sampling and training, on average","dynsam/num_measurable":"prompts with a measurable pass rate this step; per data source under dynsam/<source>/num_measurable","dynsam/passrate/hist9_ratio":"share of prompts by pass rate, in nine bins from none solved to all solved","train/harness/*/training/rollouts":"rollouts in the training batch, per agent harness","ctx_total_length/mean":"total context length per trajectory (prompt + response), in tokens"},"about":["We are streaming our RL big runs. The mimo-v2.6 series is coming soon.","Follow us @XiaomiMiMo."],"headline_tag":"dynsam/avg@n","hist_prefix":"dynsam/passrate/hist9_ratio/"}
\ No newline at end of file
diff --git a/viewer/build/inputs/mimo/flash-axis.json.gz b/viewer/build/inputs/mimo/flash-axis.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..2e94fd98f12efd332ccf0a193af5a83654af0bc7
--- /dev/null
+++ b/viewer/build/inputs/mimo/flash-axis.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c4952de404beb83bbe0b1950b80d5a5eb7d4e5b6b9e549fe6f165dbcd9ce1c4
+size 453
diff --git a/viewer/build/inputs/mimo/flash-events.json.gz b/viewer/build/inputs/mimo/flash-events.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..a70c62da4f4356946e3f36f472722f8a5341fe11
--- /dev/null
+++ b/viewer/build/inputs/mimo/flash-events.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:569e420dbc5ba32098f1332e37898d66e4ec3ce6498a2b5d650ec5c419599542
+size 1154
diff --git a/viewer/build/inputs/mimo/flash-live.jsonl.gz b/viewer/build/inputs/mimo/flash-live.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..e2af5302028436950b13e224a24266df1537fa02
--- /dev/null
+++ b/viewer/build/inputs/mimo/flash-live.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90ac484b220eb007a880f03d012277fd6bfeaa57bb27925fdd63dcddd181c393
+size 3444
diff --git a/viewer/build/inputs/mimo/flash-series.json.gz b/viewer/build/inputs/mimo/flash-series.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..68084894037a569076a592d8cd034b06f0bd6839
--- /dev/null
+++ b/viewer/build/inputs/mimo/flash-series.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60b6e44febcf9e791dec88c1b237df45039ad398f9b22dd92115dd8988f9e273
+size 150939
diff --git a/viewer/build/inputs/mimo/flash-status.json.gz b/viewer/build/inputs/mimo/flash-status.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..185cec8ac7e13919f8a590c8a6ccd6823aad0212
--- /dev/null
+++ b/viewer/build/inputs/mimo/flash-status.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8cf019adc0540c048f0ef3067bab642b764dfcaa23ed9a38d9ee736a7e2706f
+size 1368
diff --git a/viewer/build/inputs/mimo/flash-tags.json.gz b/viewer/build/inputs/mimo/flash-tags.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..0f72bcb968ec3c5ea1062a34206763aed4023e8e
--- /dev/null
+++ b/viewer/build/inputs/mimo/flash-tags.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cede54d9a5e96ab689d5c8d0656b4f8fe03938a806b0b20b1b2a33c46bfe8682
+size 9773
diff --git a/viewer/build/inputs/mimo/insights.json.gz b/viewer/build/inputs/mimo/insights.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..9071e78c7ab22ef2345e1ac346f1224e1c5cf0cc
--- /dev/null
+++ b/viewer/build/inputs/mimo/insights.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62f77df1c87b20afe3bd61b6d4967eb63daeb1fa46f4619969a7c53cea6b07d9
+size 56993
diff --git a/viewer/build/inputs/mimo/metrics-explainers.json.gz b/viewer/build/inputs/mimo/metrics-explainers.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..9088881b8f1898c913a9f976fdcd19296d5f9922
--- /dev/null
+++ b/viewer/build/inputs/mimo/metrics-explainers.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4db89788c3dea1af268eb10db17875d6e554d0ee3dba77b098e8ae6591d8ed50
+size 173426
diff --git a/viewer/build/inputs/mimo/notices.json.gz b/viewer/build/inputs/mimo/notices.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..1a1f9312e8dcd32e07fe27a92d2ed378b402a3b7
--- /dev/null
+++ b/viewer/build/inputs/mimo/notices.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbe236caf6e794e0f192e471083a9f2decf6d66e01f0576ca6eab10a815e15b5
+size 657
diff --git a/viewer/build/inputs/mimo/pro-axis.json.gz b/viewer/build/inputs/mimo/pro-axis.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..a77dd9a876acf2abd85afacf839daa76fa7f2ab2
--- /dev/null
+++ b/viewer/build/inputs/mimo/pro-axis.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffd33943c6ff1edd3eb396be34fa9bcb2f298870d16c52a1300bcfa4734ced0f
+size 452
diff --git a/viewer/build/inputs/mimo/pro-events.json.gz b/viewer/build/inputs/mimo/pro-events.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..c7e594b6997ae839f83e40d3029e124253487b4e
--- /dev/null
+++ b/viewer/build/inputs/mimo/pro-events.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0cb2046093e61ffb027aa43eec92c2da6083c493530f5146444faf7e8dec8b6
+size 1150
diff --git a/viewer/build/inputs/mimo/pro-live.jsonl.gz b/viewer/build/inputs/mimo/pro-live.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..3b998bf0e99cfb52d4722a0c2e7f0b02fd41a1c4
--- /dev/null
+++ b/viewer/build/inputs/mimo/pro-live.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2405aa66a2e75800d8e5e6ebc2e9cb99acdd53c2f9f3635f2b3c42fbf40e6de3
+size 11598
diff --git a/viewer/build/inputs/mimo/pro-series.json.gz b/viewer/build/inputs/mimo/pro-series.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..f1640979c88e8179872380eaa45770af81e47bf0
--- /dev/null
+++ b/viewer/build/inputs/mimo/pro-series.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00adb45c3701cf741612208785f0ffc19b766e638ccf3d9043a9d8e636e2f641
+size 143253
diff --git a/viewer/build/inputs/mimo/pro-status.json.gz b/viewer/build/inputs/mimo/pro-status.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..89014de41952ff5a568d88c0e86ebf48d3502627
--- /dev/null
+++ b/viewer/build/inputs/mimo/pro-status.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26d225466cb0d4ecf6233f0960176c78b3d7bdba19f27ec524ad33352a639505
+size 1237
diff --git a/viewer/build/inputs/mimo/pro-tags.json.gz b/viewer/build/inputs/mimo/pro-tags.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..b81852172cbed9a79e6c63e3f098f455ecd29d78
--- /dev/null
+++ b/viewer/build/inputs/mimo/pro-tags.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e3c9babe874c58446171d4877abc1e4dfc892021fdae6eb96da5cd506937056
+size 9722
diff --git a/viewer/build/inputs/mimo/rl-oss-tasks.json.gz b/viewer/build/inputs/mimo/rl-oss-tasks.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..9cfc55164370e354afbf7140fcfacf2a49e7cf42
--- /dev/null
+++ b/viewer/build/inputs/mimo/rl-oss-tasks.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c179c5b982847e12a062e7414ff8eda3a57aaeabfb29ba35575f42ea90813f30
+size 440534
diff --git a/viewer/build/inputs/olmo/SOURCE.md b/viewer/build/inputs/olmo/SOURCE.md
new file mode 100644
index 0000000000000000000000000000000000000000..aeb9ee6fa4e0e947399de1bc2ccf0a372dad1e51
--- /dev/null
+++ b/viewer/build/inputs/olmo/SOURCE.md
@@ -0,0 +1,42 @@
+# Inputs for `labs/olmo.py` (Ai2 OLMo 3)
+
+Every file here was read from a public source. None of them contains credentials; run configs were reduced to hyperparameters.
+
+## `wandb-olmo3.json.gz`
+
+Twenty public Weights & Biases runs of the OLMo 3 pipeline (entity `ai2-llm`), read anonymously on 2026-09-26 through the W&B GraphQL API with `importers/train_wandb.py` (its `build()` function, response cache redirected to a temporary directory; nothing was written to `public-runs/`).
+
+| Key | W&B run | What it is |
+|---|---|---|
+| `think-7b-sft` | [Olmo-3-7B-Think/6y6q8f7a](https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/6y6q8f7a) + [opu8p4gg](https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/opu8p4gg) | 7B Think SFT, two runs with one name chained at step 21,001 (the later run wins) |
+| `think-7b-dpo` | [Olmo-3-7B-Think/1e5w41io](https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/1e5w41io) | 7B Think DPO |
+| `think-7b-rl-extra` | [Olmo-3-7B-Think/a6w0ezf4](https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/a6w0ezf4) | keys the `public-runs` copy lacks (time/*, throughput, zero-reward ratio, judge scores, timestamps) |
+| `think-7b-rl-replica` | [Olmo-3-7B-Think/q2cscw2w](https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/q2cscw2w) | 7B Think RL replica on the newer stack |
+| `think-32b-sft-1e-4`, `think-32b-sft-5e-5` | [qyhh4ob4](https://wandb.ai/ai2-llm/Olmo-3-32B-Think/runs/qyhh4ob4), [djhcukg7](https://wandb.ai/ai2-llm/Olmo-3-32B-Think/runs/djhcukg7) | the two merged 32B Think SFT runs |
+| `think-32b-dpo` | [Olmo-3-32B-Think/19pb8hi1](https://wandb.ai/ai2-llm/Olmo-3-32B-Think/runs/19pb8hi1) | 32B Think DPO |
+| `think-32b-rl-public` | [Olmo-3-32B-Think/6elghrzv](https://wandb.ai/ai2-llm/Olmo-3-32B-Think/runs/6elghrzv) | public 32B Think RL record, steps 1-976, state failed, no config |
+| `instruct-7b-sft`, `instruct-7b-dpo` | [t4dfepkw](https://wandb.ai/ai2-llm/Olmo-3-7B-Instruct/runs/t4dfepkw), [fy6xccpa](https://wandb.ai/ai2-llm/Olmo-3-7B-Instruct/runs/fy6xccpa) | 7B Instruct SFT and DPO |
+| `instruct-32b-sft`, `instruct-32b-dpo`, `instruct-32b-rl` | [w07se025](https://wandb.ai/ai2-llm/Olmo-3-32B-Instruct/runs/w07se025), [haxulm5u](https://wandb.ai/ai2-llm/Olmo-3-32B-Instruct/runs/haxulm5u), [nc5ii9rd](https://wandb.ai/ai2-llm/Olmo-3-32B-Instruct/runs/nc5ii9rd) | Olmo 3.1 32B Instruct SFT, DPO, RL |
+| `rlzero-math-3.0` | [Olmo-3-7B-RL-Zero/zim8gcyv](https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/zim8gcyv) | RL-Zero Math 3.0 |
+| `rlzero-math-3.1-extra` | [Olmo-3-7B-RL-Zero/ydkgbnai](https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/ydkgbnai) | keys the `public-runs` copy lacks |
+| `rlzero-math-3.1-restart` | [Olmo-3-7B-RL-Zero/kl07u3lf](https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/kl07u3lf) | RL-Zero Math 3.1 restart from step 2,000 (its trainer counts from 1) |
+| `rlzero-code-3.0`, `rlzero-code-3.1` | [xleoveqq](https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/xleoveqq), [9m37ux43](https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/9m37ux43) | RL-Zero Code 3.0 and 3.1 |
+| `rlzero-if`, `rlzero-general` | [wn9zgjj3](https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/wn9zgjj3), [0egjzr3s](https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/0egjzr3s) | RL-Zero IF and General |
+
+Kept keys: the verifier objectives, KL, policy loss, clip fraction, learning rate, response lengths, stop rate, batch-filtering counters and ratios, time/*, learner throughput, tokens per step, the sampler-vs-learner KL, local held-out evals (`eval/objective/*`) and `_timestamp` for RL; loss, rewards/*, logps/*, learning rate, gradient norm and throughput for DPO; CE loss, learning rate, gradient norm, throughput and total tokens for OLMo-core SFT. Rows are thinned to evenly spaced logged steps (at most 500 for RL, 400 for SFT and DPO; every row with a local eval is kept); values are unchanged. Configs keep a whitelist of hyperparameters; storage paths are cut to their last two components and service endpoints are dropped. License: W&B run data states no license.
+
+## `public-runs/`
+
+Copied from `pta-work/public-runs/` (produced earlier by `importers/train_wandb.py`); `run.json` as is, `metrics.jsonl` gzipped. License: none stated.
+
+- `ai2-olmo3-7b-think-rl`: [Olmo-3-7B-Think/a6w0ezf4](https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/a6w0ezf4), 1,000 logged rows of 1,575 steps.
+- `ai2-olmo3-7b-rlzero-math`: [Olmo-3-7B-RL-Zero/ydkgbnai](https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/ydkgbnai), 987 rows of 1,999 steps.
+- `ai2-tulu3-8b-sft`, `ai2-tulu3-8b-dpo`, `ai2-tulu31-8b-grpo`, `ai2-olmo2-7b-grpo`, `ai2-olmo2-7b-grpo-zero`, `ai2-qwen25-7b-grpo-zero`: the open-instruct runs cited by the [open_instruct_public W&B reports](https://wandb.ai/ai2-llm/open_instruct_public/reports/) (run ids in each `run.json`).
+
+## `dolci-rows.json.gz`
+
+Rows of the allenai Dolci datasets from the Hugging Face dataset viewer: the `rows` samples the OLMo dossier cached on 2026-09-25 (Dolci-Think-SFT-7B, Dolci-Instruct-SFT, Dolci-Instruct-SFT-Tool-Use, Dolci-Think-DPO-7B, Dolci-Instruct-DPO, Dolci-Think-RL-7B, Dolci-Instruct-RL, Dolci-RL-Zero-Math/Code/IF/General-7B), plus 175 Dolci-Think-RL-7B rows read on 2026-09-26 through the viewer's `filter` endpoint (KlearReasoner code, SYNTHETIC-2 code, Llama-Nemotron difficulty 6, WildChat). RL rows keep the id, source, verifier, prompt (cut to 700 characters), a short ground truth and, where present, the DPO model's pass rate and rollout count; SFT and DPO texts are cut with their full length noted. Rows matching a keyword filter for unsafe, adult or crude content are left out, as are the WildJailbreak, WildGuardMix and CoCoNot safety rows. License: ODC-BY per the dataset cards; DPO responses are also subject to each generating model's terms.
+
+## `hf-branches.json`
+
+Step branches of the Olmo 3 model repositories on Hugging Face (for example `allenai/Olmo-3-7B-Think@step_25` … `step_1375`), read through the HF API by the dossier author on 2026-09-25. Which branch `main` equals comes from the dossier's weight-hash comparison and is written in `olmo.py`.
diff --git a/viewer/build/inputs/olmo/dolci-rows.json.gz b/viewer/build/inputs/olmo/dolci-rows.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..cece87a4eb8d816b7e84498d6c31fd7674e25c76
--- /dev/null
+++ b/viewer/build/inputs/olmo/dolci-rows.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:647495ac3663edae16b11f58b433de0364eb63d9cb5243862e7e11604cb007f3
+size 502039
diff --git a/viewer/build/inputs/olmo/hf-branches.json b/viewer/build/inputs/olmo/hf-branches.json
new file mode 100644
index 0000000000000000000000000000000000000000..6d8ef9833291fe8467c6ebc21bc517fb5dd37e30
--- /dev/null
+++ b/viewer/build/inputs/olmo/hf-branches.json
@@ -0,0 +1,551 @@
+{
+"Olmo-3-7B-Think-SFT": {
+"steps": [
+1000,
+2000,
+3000,
+4000,
+5000,
+6000,
+7000,
+8000,
+9000,
+10000,
+11000,
+12000,
+13000,
+14000,
+15000,
+16000,
+17000,
+18000,
+19000,
+20000,
+21000,
+22000,
+23000,
+24000,
+25000,
+26000,
+27000,
+28000,
+29000,
+30000,
+31000,
+32000,
+33000,
+34000,
+35000,
+36000,
+37000,
+38000,
+39000,
+40000,
+41000,
+42000,
+43000
+],
+"others": [
+"main"
+]
+},
+"Olmo-3-7B-Think-DPO": {
+"steps": [],
+"others": [
+"main"
+]
+},
+"Olmo-3-7B-Think": {
+"steps": [
+25,
+50,
+75,
+100,
+125,
+150,
+175,
+200,
+225,
+250,
+275,
+300,
+325,
+350,
+375,
+400,
+425,
+450,
+475,
+500,
+525,
+550,
+575,
+600,
+625,
+650,
+675,
+700,
+725,
+750,
+775,
+800,
+825,
+850,
+875,
+900,
+925,
+950,
+975,
+1000,
+1025,
+1050,
+1075,
+1100,
+1125,
+1150,
+1175,
+1200,
+1225,
+1250,
+1275,
+1300,
+1325,
+1350,
+1375
+],
+"others": [
+"main"
+]
+},
+"Olmo-3-32B-Think-SFT": {
+"steps": [],
+"others": [
+"main",
+"5e-5-step10790",
+"5e-5-step10000",
+"5e-5-step9000",
+"5e-5-step8000",
+"5e-5-step7000",
+"5e-5-step6000",
+"5e-5-step5000",
+"5e-5-step4000",
+"5e-5-step3000",
+"5e-5-step2000",
+"5e-5-step1000",
+"1e-4-step10790",
+"1e-4-step10000",
+"1e-4-step9000",
+"1e-4-step8000",
+"1e-4-step7000",
+"1e-4-step6000",
+"1e-4-step5000",
+"1e-4-step4000",
+"1e-4-step3000",
+"1e-4-step2000",
+"1e-4-step1000"
+]
+},
+"Olmo-3-32B-Think-DPO": {
+"steps": [],
+"others": [
+"main"
+]
+},
+"Olmo-3-32B-Think": {
+"steps": [
+50,
+100,
+150,
+200,
+250,
+300,
+350,
+400,
+450,
+500,
+550,
+600,
+650,
+700,
+750
+],
+"others": [
+"main"
+]
+},
+"Olmo-3.1-32B-Think": {
+"steps": [
+50,
+100,
+150,
+200,
+250,
+300,
+350,
+400,
+450,
+500,
+550,
+600,
+650,
+700,
+750,
+800,
+850,
+900,
+950,
+1000,
+1050,
+1100,
+1150,
+1200,
+1250,
+1300,
+1350,
+1400,
+1450,
+1500,
+1550,
+1600,
+1650,
+1700,
+1750,
+1800,
+1850,
+1900,
+1950,
+2000,
+2050,
+2100,
+2150,
+2200,
+2250,
+2300
+],
+"others": [
+"main"
+]
+},
+"Olmo-3-7B-Instruct-SFT": {
+"steps": [],
+"others": [
+"main"
+]
+},
+"Olmo-3-7B-Instruct-DPO": {
+"steps": [],
+"others": [
+"main"
+]
+},
+"Olmo-3-7B-Instruct": {
+"steps": [
+50,
+100,
+150,
+200,
+250,
+300,
+350,
+400
+],
+"others": [
+"main"
+]
+},
+"Olmo-3.1-32B-Instruct-SFT": {
+"steps": [],
+"others": [
+"main"
+]
+},
+"Olmo-3.1-32B-Instruct-DPO": {
+"steps": [],
+"others": [
+"main"
+]
+},
+"Olmo-3.1-32B-Instruct": {
+"steps": [],
+"others": [
+"main"
+]
+},
+"Olmo-3-7B-RL-Zero-Math": {
+"steps": [
+100,
+200,
+300,
+400,
+500,
+600,
+700,
+800,
+900,
+1000,
+1100,
+1200,
+1300,
+1400,
+1500,
+1600,
+1700,
+1800,
+1900
+],
+"others": [
+"main"
+]
+},
+"Olmo-3-7B-RL-Zero-Code": {
+"steps": [
+100,
+200,
+300,
+400,
+500,
+600,
+700,
+800,
+900,
+1000,
+1100,
+1200,
+1300,
+1400,
+1500,
+1600,
+1700,
+1800,
+1900,
+2000,
+2100,
+2200,
+2300,
+2400,
+2500,
+2600,
+2700,
+2800,
+2900
+],
+"others": [
+"main"
+]
+},
+"Olmo-3-7B-RL-Zero-IF": {
+"steps": [
+100,
+200,
+300,
+400,
+500,
+600,
+700,
+800,
+900,
+1000,
+1100,
+1200,
+1300,
+1400,
+1500,
+1600,
+1700,
+1800,
+1900
+],
+"others": [
+"main"
+]
+},
+"Olmo-3-7B-RL-Zero-General": {
+"steps": [
+100,
+200,
+300,
+400,
+500,
+600,
+700,
+800
+],
+"others": [
+"main"
+]
+},
+"Olmo-3-7B-RL-Zero-Mix": {
+"steps": [
+50,
+100,
+150,
+200,
+250,
+300,
+350,
+400,
+450,
+500,
+550,
+600,
+650,
+700,
+750,
+800,
+850,
+900,
+950
+],
+"others": [
+"main"
+]
+},
+"Olmo-3.1-7B-RL-Zero-Math": {
+"steps": [
+100,
+200,
+300,
+400,
+500,
+600,
+700,
+800,
+900,
+1000,
+1100,
+1200,
+1300,
+1400,
+1500,
+1600,
+1700,
+1800,
+1900,
+2000,
+2100,
+2200,
+2300,
+2400,
+2500,
+2600,
+2700,
+2800
+],
+"others": [
+"main"
+]
+},
+"Olmo-3.1-7B-RL-Zero-Code": {
+"steps": [
+50,
+100,
+150,
+200,
+250,
+300,
+350,
+400,
+450,
+500,
+550,
+600,
+650,
+700,
+800,
+850,
+900,
+1000,
+1050,
+1100,
+1150,
+1200,
+1250,
+1300,
+1350,
+1400,
+1450,
+1500,
+1600,
+1700,
+1750,
+1900,
+1950
+],
+"others": [
+"main"
+]
+},
+"Olmo-Hybrid-Think-SFT-7B": {
+"steps": [
+1000,
+2000,
+3000,
+4000,
+5000,
+6000,
+7000,
+8000,
+9000,
+10000,
+11000,
+12000,
+13000,
+14000,
+15000,
+16000,
+17000,
+18000,
+19000,
+20000,
+21000,
+22000,
+23000,
+24000,
+25000,
+26000,
+27000,
+28000,
+29000,
+30000,
+31000,
+32000,
+33000,
+34000,
+35000,
+36000,
+37000,
+38000,
+39000,
+40000,
+41000,
+42000,
+43000,
+44000,
+45000,
+45500,
+46000,
+46412
+],
+"others": [
+"main"
+]
+},
+"Olmo-Hybrid-Instruct-SFT-7B": {
+"steps": [
+1000,
+2000,
+2500,
+3000,
+3256
+],
+"others": [
+"main"
+]
+},
+"Olmo-Hybrid-Instruct-DPO-7B": {
+"steps": [],
+"others": [
+"main"
+]
+}
+}
\ No newline at end of file
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo-zero/metrics.jsonl.gz b/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo-zero/metrics.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..ccfa6e6f000b86eeef06246bc989484b62d072a2
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo-zero/metrics.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b48bca931b40fbff99190f78ba373e8a5c74680964e4913a38faad3c201d2b3a
+size 79819
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo-zero/run.json b/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo-zero/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..9d3129b41b9d00ffdacee3288b82c2959fea937f
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo-zero/run.json
@@ -0,0 +1,27 @@
+{
+ "id": "ai2-olmo2-7b-grpo-zero",
+ "title": "OLMo 2 7B zero-RL GRPO from base (open-instruct)",
+ "source": "public",
+ "org": "Ai2",
+ "project": "tulu-3",
+ "url": "https://wandb.ai/ai2-llm/open_instruct_public/reports/OLMo-2-7B-GRPO-Fast-Zero--VmlldzoxMjA0MjU4MQ",
+ "license": "unknown",
+ "model": "OLMo 2 7B zero-RL (experimental, not released)",
+ "base_model": "allenai/OLMo-2-1124-7B",
+ "method": "GRPO zero-style (RLVR from a base model, no KL)",
+ "dataset": "ai2-adapt-dev/math_ground_truth_zs",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2025-03-28T02:06:19Z",
+ "updated_at": "2025-03-28T22:44:46Z",
+ "attempts": 0,
+ "note": "Ai2 experimental R1-Zero-style GRPO from the OLMo 2 7B base model on math with ground-truth answers (48 prompts x 16 samples, lr 5e-7, beta 0). In open-instruct the val/* keys describe the training rollouts (e.g. val/sequence_lengths is the mean response length), not a held-out evaluation; objective/verifiable_correct_rate is the share of rollouts the verifier marked correct.",
+ "metrics_map": {
+  "reward": "objective/verifiable_correct_rate",
+  "kl": "objective/kl_avg",
+  "loss": "loss/policy_avg",
+  "lr": "lr",
+  "response_length": "val/sequence_lengths"
+ }
+}
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo/metrics.jsonl.gz b/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo/metrics.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..3116d71d7973ba113e4c7f8171b21592c6760377
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo/metrics.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47b94021422fa5cebbeb7810c7bb9a25829810fa092daaac45f29f0b4ff65a3f
+size 263408
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo/run.json b/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..1611cc22a89d1dcd29bfcc5cd4828a0e5cee427c
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-olmo2-7b-grpo/run.json
@@ -0,0 +1,28 @@
+{
+ "id": "ai2-olmo2-7b-grpo",
+ "title": "OLMo 2 7B Instruct GRPO reproduction (open-instruct)",
+ "source": "public",
+ "org": "Ai2",
+ "project": "tulu-3",
+ "url": "https://wandb.ai/ai2-llm/open_instruct_public/reports/OLMo-2-7B-GRPO--VmlldzoxMTkyNzc1OA",
+ "license": "unknown",
+ "model": "allenai/OLMo-2-1124-7B-Instruct (GRPO reproduction)",
+ "base_model": "allenai/OLMo-2-1124-7B-DPO",
+ "method": "GRPO (RLVR, legacy grpo_vllm_thread_ray_gtrl)",
+ "dataset": "allenai/RLVR-GSM-MATH-IF-Mixed-Constraints",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2025-03-19T03:58:14Z",
+ "updated_at": "2025-03-22T01:30:02Z",
+ "attempts": 0,
+ "note": "Ai2 GRPO run from OLMo 2 7B DPO on the Tulu 3 RLVR mix; the docs say the result outperforms the released PPO-trained OLMo-2-1124-7B-Instruct. This legacy script logs objective/kl summed over response tokens (per the open-instruct docs), unlike grpo_fast's objective/kl_avg; its entropy metrics are left out because objective/entropy counts padding (it goes negative) and policy/entropy_avg is 0 at every step. In open-instruct the val/* keys describe the training rollouts (e.g. val/sequence_lengths is the mean response length), not a held-out evaluation; objective/verifiable_correct_rate is the share of rollouts the verifier marked correct.",
+ "metrics_map": {
+  "reward": "objective/verifiable_correct_rate",
+  "reward_std": "objective/reward_std",
+  "kl": "objective/kl",
+  "loss": "loss/policy_avg",
+  "lr": "lr",
+  "response_length": "val/sequence_lengths"
+ }
+}
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-rlzero-math/metrics.jsonl.gz b/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-rlzero-math/metrics.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..d40b5ba73e8940b26d29478dbc296d3acfbfb96a
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-rlzero-math/metrics.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e08f7eb04d65088c8fb7874c7978002e5baf389b1ed478c8505a8f55ecaa82bc
+size 100130
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-rlzero-math/run.json b/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-rlzero-math/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..f1e4ec4efd4caecbbbc63868b6dd8e426fab2b3e
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-rlzero-math/run.json
@@ -0,0 +1,27 @@
+{
+ "id": "ai2-olmo3-7b-rlzero-math",
+ "title": "OLMo 3 7B RL-Zero math (Dolci-RLZero-Math)",
+ "source": "public",
+ "org": "Ai2",
+ "project": "olmo-3",
+ "url": "https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/ydkgbnai",
+ "license": "unknown",
+ "model": "OLMo 3 7B RL-Zero math",
+ "base_model": "allenai/Olmo-3-1025-7B",
+ "method": "GRPO zero-style (RLVR from the base model, no KL)",
+ "dataset": "allenai/Dolci-RLZero-Math-7B",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2025-12-12T17:06:24Z",
+ "updated_at": "2025-12-12T17:15:42Z",
+ "attempts": 0,
+ "note": "Ai2 OLMo 3 RL-Zero run on math from the OLMo 3 7B base model (32 prompts x 8 samples per step, 16k-token responses, lr 1e-6, beta 0), from the public Olmo-3-7B-RL-Zero W&B project; the trainer logged about every second step. The project also holds OLMES results (AIME, MATH-500) that evaluation jobs logged later in bursts at W&B steps that do not identify the checkpoint evaluated, so they are left out. In open-instruct the val/* keys describe the training rollouts (e.g. val/sequence_lengths is the mean response length), not a held-out evaluation; objective/verifiable_correct_rate is the share of rollouts the verifier marked correct.",
+ "metrics_map": {
+  "reward": "objective/verifiable_correct_rate",
+  "kl": "objective/kl_avg",
+  "loss": "loss/policy_avg",
+  "lr": "lr",
+  "response_length": "val/sequence_lengths"
+ }
+}
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-think-rl/metrics.jsonl.gz b/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-think-rl/metrics.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..76f4fc2f763a29dac766f1772e138eb59be7f38f
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-think-rl/metrics.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99db65e6513b90997ab83d0f559b548399143c0a8a3abfd5c918c8b11537936c
+size 127174
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-think-rl/run.json b/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-think-rl/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..62d824b497906356b0f0fe6f84e0dd6200e835ac
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-olmo3-7b-think-rl/run.json
@@ -0,0 +1,31 @@
+{
+ "id": "ai2-olmo3-7b-think-rl",
+ "title": "OLMo 3 7B Think RL stage (math, code, IF, general mix)",
+ "source": "public",
+ "org": "Ai2",
+ "project": "olmo-3",
+ "url": "https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/a6w0ezf4",
+ "license": "unknown",
+ "model": "OLMo 3 7B Think (RL stage)",
+ "base_model": "OLMo 3 7B Think DPO checkpoint sm0922-rsn-dpo-delta-yolo_scottmix1_150k-8e-8 (its DPO run is in the same W&B project)",
+ "method": "GRPO (RLVR, open-instruct grpo_fast, no KL)",
+ "dataset": "hamishivi/math_rlvr_mixture_dpo, hamishivi/code_rlvr_mixture_dpo, hamishivi/IF_multi_constraints_upto5_filtered_dpo_0625_filter, hamishivi/rlvr_general_mix",
+ "eval_suite": "held-out prompts of the RL mix, scored during training (eval/objective/*)",
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2025-12-12T05:27:36Z",
+ "updated_at": "2025-12-12T05:34:53Z",
+ "attempts": 0,
+ "note": "Ai2 RL run named olmo3_dpo_rl_final_mix in the public Olmo-3-7B-Think W&B project: GRPO from a DPO checkpoint on a math, code, instruction-following and general-chat mix (64 prompts x 8 samples per step, 32k-token responses, lr 1e-6, beta 0), logged at 1,000 of its 1,575 steps. eval/objective/* are verifier scores on held-out prompts of the same mix, scored 8 times during training; the values move in steps of 1/32 overall and 1/8 per domain, so the held-out set is small. In open-instruct the val/* keys describe the training rollouts (e.g. val/sequence_lengths is the mean response length), not a held-out evaluation; objective/verifiable_correct_rate is the share of rollouts the verifier marked correct.",
+ "metrics_map": {
+  "reward": "objective/verifiable_correct_rate",
+  "kl": "objective/kl_avg",
+  "loss": "loss/policy_avg",
+  "lr": "lr",
+  "response_length": "val/sequence_lengths",
+  "eval:verifiable_correct_rate": "eval/objective/verifiable_correct_rate",
+  "eval:math_correct_rate": "eval/objective/math_correct_rate",
+  "eval:code_correct_rate": "eval/objective/code_correct_rate",
+  "eval:ifeval_correct_rate": "eval/objective/ifeval_correct_rate"
+ }
+}
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-qwen25-7b-grpo-zero/metrics.jsonl.gz b/viewer/build/inputs/olmo/public-runs/ai2-qwen25-7b-grpo-zero/metrics.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..4b3096f6f9c9b9d96328b751b6b526e33999c0f2
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-qwen25-7b-grpo-zero/metrics.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b95c031d64f6355d8f9aaa462372ea8e495438eb24f2660ba684ace281efba4c
+size 130754
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-qwen25-7b-grpo-zero/run.json b/viewer/build/inputs/olmo/public-runs/ai2-qwen25-7b-grpo-zero/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..3d9af9dbd8eb6031c4bf882ae53adca7ccc595a6
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-qwen25-7b-grpo-zero/run.json
@@ -0,0 +1,27 @@
+{
+ "id": "ai2-qwen25-7b-grpo-zero",
+ "title": "Qwen2.5 7B zero-RL GRPO from base (open-instruct)",
+ "source": "public",
+ "org": "Ai2",
+ "project": "tulu-3",
+ "url": "https://wandb.ai/ai2-llm/open_instruct_public/reports/Qwen2-5-7B-GRPO-Fast-Zero--VmlldzoxMjA2NDExMA",
+ "license": "unknown",
+ "model": "Qwen2.5 7B zero-RL (experimental, not released)",
+ "base_model": "Qwen/Qwen2.5-7B",
+ "method": "GRPO zero-style (RLVR from a base model, no KL)",
+ "dataset": "ai2-adapt-dev/math_ground_truth_zs",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2025-03-28T17:20:10Z",
+ "updated_at": "2025-03-31T10:24:19Z",
+ "attempts": 0,
+ "note": "Ai2 experimental R1-Zero-style GRPO from the Qwen2.5 7B base model on math with ground-truth answers (48 prompts x 16 samples, 5M episodes, lr 5e-7, beta 0). In open-instruct the val/* keys describe the training rollouts (e.g. val/sequence_lengths is the mean response length), not a held-out evaluation; objective/verifiable_correct_rate is the share of rollouts the verifier marked correct. Our copy keeps every 3rd of the 6,510 logged steps (values unchanged).",
+ "metrics_map": {
+  "reward": "objective/verifiable_correct_rate",
+  "kl": "objective/kl_avg",
+  "loss": "loss/policy_avg",
+  "lr": "lr",
+  "response_length": "val/sequence_lengths"
+ }
+}
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-dpo/metrics.jsonl.gz b/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-dpo/metrics.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..6655fec9590a976a86907823bc0a5c498ae4347d
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-dpo/metrics.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16d022a4f8425097c7376bfc6ddc9c7d8670ef58cbd9c84d5f48a23eb0a0c2fd
+size 50841
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-dpo/run.json b/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-dpo/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..aa42fc243434f3390bcb27fdf7821f9b6506f039
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-dpo/run.json
@@ -0,0 +1,25 @@
+{
+ "id": "ai2-tulu3-8b-dpo",
+ "title": "Tulu 3 8B DPO reproduction (open-instruct)",
+ "source": "public",
+ "org": "Ai2",
+ "project": "tulu-3",
+ "url": "https://wandb.ai/ai2-llm/open_instruct_public/reports/Tulu3-8B-DPO--VmlldzoxMTg3NjY4Nw",
+ "license": "unknown",
+ "model": "allenai/Llama-3.1-Tulu-3-8B-DPO (reproduction)",
+ "base_model": "allenai/Llama-3.1-Tulu-3-8B-SFT",
+ "method": "DPO (length-normalized)",
+ "dataset": "allenai/llama-3.1-tulu-3-8b-preference-mixture",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2025-03-17T01:30:34Z",
+ "updated_at": "2025-03-17T04:28:53Z",
+ "attempts": 0,
+ "note": "Ai2 reproduction of the Tulu 3 8B DPO stage on the Tulu 3 8B preference mixture (length-normalized DPO, beta 5, 1 epoch, lr 5e-7). reward is mapped to the DPO implicit reward margin (chosen minus rejected); rewards/accuracy is the preference accuracy.",
+ "metrics_map": {
+  "loss": "train_loss",
+  "lr": "learning_rate",
+  "reward": "rewards/margin"
+ }
+}
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-sft/metrics.jsonl.gz b/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-sft/metrics.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..a1a5d6d27a9c254550ed282caeb5b5592380b19f
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-sft/metrics.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:faccda10366d0989cc3ae7bb8a7075a90b1fa70cba1059d123372bd47291abf7
+size 102972
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-sft/run.json b/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-sft/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..1bdf749f606e373e89f6af5ff0606aee1051df66
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-tulu3-8b-sft/run.json
@@ -0,0 +1,24 @@
+{
+ "id": "ai2-tulu3-8b-sft",
+ "title": "Tulu 3 8B SFT reproduction (open-instruct)",
+ "source": "public",
+ "org": "Ai2",
+ "project": "tulu-3",
+ "url": "https://wandb.ai/ai2-llm/open_instruct_public/reports/Tulu3-8B-SFT--VmlldzoxMTk0OTY4MA",
+ "license": "unknown",
+ "model": "allenai/Llama-3.1-Tulu-3-8B-SFT (reproduction)",
+ "base_model": "meta-llama/Llama-3.1-8B",
+ "method": "SFT",
+ "dataset": "allenai/tulu-3-sft-mixture",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2025-03-22T03:23:29Z",
+ "updated_at": "2025-03-22T12:10:15Z",
+ "attempts": 0,
+ "note": "Ai2 reproduction of the Tulu 3 8B SFT stage on the Tulu 3 SFT mixture (2 epochs, lr 5e-6). The run sums the token loss per batch (reduce_loss=sum), so train_loss is on that larger scale rather than a per-token mean. Our copy keeps every 5th of the 14,678 logged steps (values unchanged).",
+ "metrics_map": {
+  "loss": "train_loss",
+  "lr": "learning_rate"
+ }
+}
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-tulu31-8b-grpo/metrics.jsonl.gz b/viewer/build/inputs/olmo/public-runs/ai2-tulu31-8b-grpo/metrics.jsonl.gz
new file mode 100644
index 0000000000000000000000000000000000000000..1cb9ff01e3aedbf3ebd2f717d5a9a7278d7c4d65
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-tulu31-8b-grpo/metrics.jsonl.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1c8f8aae0e6773d76cd433188503732b29c7a314cf53b2f529164062c3ce1f5
+size 172363
diff --git a/viewer/build/inputs/olmo/public-runs/ai2-tulu31-8b-grpo/run.json b/viewer/build/inputs/olmo/public-runs/ai2-tulu31-8b-grpo/run.json
new file mode 100644
index 0000000000000000000000000000000000000000..6b661f54ac92d7493349188fbabb7b416f959975
--- /dev/null
+++ b/viewer/build/inputs/olmo/public-runs/ai2-tulu31-8b-grpo/run.json
@@ -0,0 +1,27 @@
+{
+ "id": "ai2-tulu31-8b-grpo",
+ "title": "Tulu 3.1 8B GRPO reproduction (open-instruct)",
+ "source": "public",
+ "org": "Ai2",
+ "project": "tulu-3",
+ "url": "https://wandb.ai/ai2-llm/open_instruct_public/reports/Tulu3-1-8B-GRPO-Fast--VmlldzoxMTk0NzcwOA",
+ "license": "unknown",
+ "model": "allenai/Llama-3.1-Tulu-3.1-8B (reproduction)",
+ "base_model": "allenai/Llama-3.1-Tulu-3-8B-DPO",
+ "method": "GRPO (RLVR, grpo_fast)",
+ "dataset": "allenai/RLVR-GSM-MATH-IF-Mixed-Constraints",
+ "eval_suite": null,
+ "kind": "training",
+ "state": "finished",
+ "started_at": "2025-03-22T03:29:01Z",
+ "updated_at": "2025-03-23T00:16:23Z",
+ "attempts": 0,
+ "note": "Ai2 reproduction of Tulu 3.1 8B: GRPO with verifiable rewards on GSM8K, MATH and IFEval-style constraints from the Tulu 3 8B DPO model (48 prompts x 16 samples per step, lr 5e-7, beta 0.01, seed 40). The report shows two seed-40 runs; this is the 48-prompt one. In open-instruct the val/* keys describe the training rollouts (e.g. val/sequence_lengths is the mean response length), not a held-out evaluation; objective/verifiable_correct_rate is the share of rollouts the verifier marked correct.",
+ "metrics_map": {
+  "reward": "objective/verifiable_correct_rate",
+  "kl": "objective/kl_avg",
+  "loss": "loss/policy_avg",
+  "lr": "lr",
+  "response_length": "val/sequence_lengths"
+ }
+}
diff --git a/viewer/build/inputs/olmo/wandb-olmo3.json.gz b/viewer/build/inputs/olmo/wandb-olmo3.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..5b6f49e5ae1824ca179d81b166038185c60c74cc
--- /dev/null
+++ b/viewer/build/inputs/olmo/wandb-olmo3.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b47aad285fa4c4483dae3676c049c4b0c81705c60ad878ec1a1f3da29485d58c
+size 1125099
diff --git a/viewer/build/inputs/openthoughts/SOURCE.md b/viewer/build/inputs/openthoughts/SOURCE.md
new file mode 100644
index 0000000000000000000000000000000000000000..f11fc3a43232551bebf123675129b59730ad5d6d
--- /dev/null
+++ b/viewer/build/inputs/openthoughts/SOURCE.md
@@ -0,0 +1,14 @@
+# Inputs for `labs/openthoughts.py`
+
+Everything here was copied from public sources on 2026-09-26. The viewer build reads only these files. Published numbers that are not in these files (paper tables, hyperparameters, task counts) are written in `labs/openthoughts.py` next to their source URL. Strings that look like credentials were replaced with `[redacted]` while copying.
+
+The public `llm-verifier-freelancer` task files embed a hard-coded API key; nothing from those task files (instructions, tests or ids beyond the numbering pattern) was copied.
+
+| File | What it is | Where it came from | License |
+|---|---|---|---|
+| `sft_trainer_states.json.gz` | `log_history` (step, loss, grad_norm, learning_rate, epoch) and run summary of five published `trainer_state.json` files: OpenThinkerAgent-32B (steps 5-3,600 of 4,520), the cold-start 8B SFT that the RL config starts from (`...-131k-fixthink`), the released cold-start model, `DCAgent/g1_diverse_tezos_100k_8b`, and OpenThinker-Agent-v1-SFT. | https://huggingface.co/open-thoughts/OpenThinkerAgent-32B, https://huggingface.co/laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink, https://huggingface.co/open-thoughts/OpenThinkerAgent-8B-ColdStartSFTForRL, https://huggingface.co/DCAgent/g1_diverse_tezos_100k_8b, https://huggingface.co/open-thoughts/OpenThinker-Agent-v1-SFT | apache-2.0 (open-thoughts and laion repos); `other` (DCAgent repo) |
+| `hero_rl_config.json` | The SkyRL/Harbor launch arguments of the RL hero run (`skyrl_hydra_args`, node and GPU counts); fields named like tokens or keys were dropped (they were empty). | https://huggingface.co/open-thoughts/OpenThinkerAgent-8B-RL/blob/main/swesmith-fixthink-pymethods2test_rl_config.json | apache-2.0 |
+| `tb2_rl45_trials.json.gz` | All 265 Terminal-Bench 2.0 trials (89 tasks) of the released RL checkpoint from one public eval job (2026-05-04): task, trial, result (reward or error name) and the terminus-2 conversation converted to the viewer's message format (messages cut at 700 characters, at most 30 per trial). Transcripts of 12 security-related tasks (cracking, cryptanalysis, XSS filtering, secret recovery, crash reproduction) were not copied; only their outcomes are kept. | https://huggingface.co/datasets/DCAgent2/terminal_bench_2_rl_swesmith_fixthink_pymethods2test_45_20260504_234427 | not stated |
+| `tasks_and_benchmarks.json.gz` | (a) The 5,000 OpenThoughts-Agent-RL-5K (pymethods2test) task ids, with the task description (first 450 characters of `instruction.md`) for 2,002 of them; (b) the first public task examples of six other RL sources (code-contests, r2egym, nemotron-code-oracle, inferredbugs, swesmith, nl2bash) with their packaging sizes; (c) task lists of OpenThoughts-TBLite (100), OpenThoughts-TB-dev (70), Terminal-Bench 2.0 (89) and SWE-bench Verified (500 instance ids, repos and issue titles); (d) 15 sample rows of OpenThoughts-Agent-SFT-100K (first 8 messages, cut at 1,200 characters). | https://huggingface.co/datasets/open-thoughts/OpenThoughts-Agent-RL-5K, https://huggingface.co/datasets/open-thoughts/TaskTrove, https://huggingface.co/datasets/open-thoughts/CodeContests, https://huggingface.co/datasets/open-thoughts/OpenThoughts-Agent-v1-RL, https://huggingface.co/datasets/open-thoughts/OpenThoughts-TBLite, https://huggingface.co/datasets/open-thoughts/OpenThoughts-TB-dev, https://huggingface.co/datasets/R2E-Gym/SWE-Bench-Verified, https://huggingface.co/datasets/open-thoughts/OpenThoughts-Agent-SFT-100K | apache-2.0 (open-thoughts datasets except CodeContests, whose card states none); SWE-bench Verified copy: not stated |
+
+The v1 SFT curve in `sft_trainer_states.json.gz` is the same `trainer_state.json` that `~/benchflow/pta-work/public-runs/openthoughts-agent-v1-sft/` imported. No W&B logs of the RL runs are public ("available on request"), so the RL runs in the demo are simulated around the published numbers (see each run's description).
diff --git a/viewer/build/inputs/openthoughts/hero_rl_config.json b/viewer/build/inputs/openthoughts/hero_rl_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..6b67d72dad57d56d274968a04c857f10ab4f6f48
--- /dev/null
+++ b/viewer/build/inputs/openthoughts/hero_rl_config.json
@@ -0,0 +1,117 @@
+{
+ "skyrl_hydra_args": [
+  "+terminal_bench_config=terminal_bench",
+  "trainer.strategy=fsdp2",
+  "trainer.algorithm.advantage_estimator=rloo_n",
+  "trainer.algorithm.use_kl_loss=false",
+  "trainer.algorithm.kl_loss_coef=0.0",
+  "trainer.algorithm.eps_clip_low=0.2",
+  "trainer.algorithm.eps_clip_high=0.2",
+  "trainer.algorithm.loss_reduction=token_mean",
+  "trainer.epochs=2",
+  "trainer.max_steps=60",
+  "trainer.update_epochs_per_batch=1",
+  "trainer.train_batch_size=64",
+  "trainer.policy_mini_batch_size=64",
+  "trainer.eval_batch_size=64",
+  "trainer.micro_forward_batch_size_per_gpu=4",
+  "trainer.micro_train_batch_size_per_gpu=1",
+  "trainer.max_prompt_length=999999",
+  "trainer.eval_interval=999999",
+  "trainer.eval_before_train=false",
+  "trainer.ckpt_interval=999999",
+  "trainer.resume_mode=latest",
+  "trainer.hf_save_interval=5",
+  "++trainer.hf_hub_repo_id=laion/swesmith-fixthink-pymethods2test",
+  "++trainer.hf_hub_private=false",
+  "++trainer.hf_hub_revision=main",
+  "++trainer.enable_db_registration=true",
+  "trainer.project_name=OpenThoughts-Agent",
+  "trainer.log_level=INFO",
+  "trainer.tracker_commit_each_step=true",
+  "trainer.run_name=swesmith-fixthink-pymethods2test",
+  "trainer.ckpt_path=experiments/swesmith-fixthink-pymethods2test/swesmith-fixthink-pymethods2test/checkpoints",
+  "trainer.export_path=experiments/swesmith-fixthink-pymethods2test/swesmith-fixthink-pymethods2test/exports",
+  "trainer.policy.optimizer_config.lr=5e-6",
+  "trainer.policy.optimizer_config.weight_decay=0.0",
+  "trainer.policy.optimizer_config.adam_betas=[0.9,0.999]",
+  "trainer.policy.fsdp_config.cpu_offload=true",
+  "trainer.policy.fsdp_config.reshard_after_forward=true",
+  "trainer.policy.fsdp_config.fsdp_size=4",
+  "trainer.policy.model.path=/pscratch/sd/p/penfever/hub/models--laion--GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink/snapshots/0e3bff0c4e51f6b9ec0713b98b9eec36efb91cc6",
+  "trainer.ref.fsdp_config.cpu_offload=true",
+  "trainer.ref.fsdp_config.reshard_after_forward=true",
+  "trainer.ref.fsdp_config.fsdp_size=4",
+  "trainer.placement.colocate_all=false",
+  "trainer.placement.policy_num_nodes=2",
+  "trainer.placement.ref_num_nodes=2",
+  "trainer.placement.policy_num_gpus_per_node=4",
+  "trainer.placement.ref_num_gpus_per_node=4",
+  "trainer.fully_async.max_staleness_steps=16",
+  "trainer.fully_async.num_parallel_generation_workers=768",
+  "generator.backend=vllm",
+  "generator.timeout_multiplier=1.0",
+  "generator.model_dtype=bfloat16",
+  "generator.inference_engine_tensor_parallel_size=1",
+  "generator.num_inference_engines=16",
+  "generator.n_samples_per_prompt=8",
+  "generator.eval_n_samples_per_prompt=8",
+  "generator.gpu_memory_utilization=0.9",
+  "generator.max_num_seqs=24",
+  "generator.enable_prefix_caching=true",
+  "generator.enable_chunked_prefill=true",
+  "generator.run_engines_locally=true",
+  "generator.weight_sync_backend=nccl",
+  "generator.async_engine=true",
+  "generator.batched=false",
+  "generator.enable_http_endpoint=true",
+  "generator.enable_ray_prometheus_stats=false",
+  "generator.vllm_stats_interval=1",
+  "generator.max_turns=999999",
+  "generator.sampling_params.max_generate_length=4096",
+  "generator.sampling_params.temperature=0.7",
+  "generator.sampling_params.top_p=0.95",
+  "generator.sampling_params.top_k=20",
+  "++generator.engine_init_kwargs={max_model_len: 32768, custom_chat_template_chat_completion_path: chat_templates/qwen3_thinking_acc.jinja2, served_model_name: 0e3bff0c4e51f6b9ec0713b98b9eec36efb91cc6}",
+  "data.train_data=[\"/pscratch/sd/p/penfever/tasks/exp_rpt_pymethods2test-large\"]",
+  "data.val_data=[\"/pscratch/sd/p/penfever/tasks/OpenThoughts-TB-dev\"]",
+  "+terminal_bench_config.trials_dir=experiments/swesmith-fixthink-pymethods2test/swesmith-fixthink-pymethods2test/trace_jobs",
+  "+terminal_bench_config.harbor.name=terminus-2",
+  "+terminal_bench_config.harbor.max_episodes=999999",
+  "+terminal_bench_config.harbor.enable_summarize=false",
+  "+terminal_bench_config.harbor.store_all_messages=true",
+  "+terminal_bench_config.harbor.enable_episode_logging=false",
+  "+terminal_bench_config.harbor.record_terminal_session=false",
+  "+terminal_bench_config.harbor.enable_pane_logging=false",
+  "+terminal_bench_config.harbor.strict_json_parser=true",
+  "+terminal_bench_config.harbor.interleaved_thinking=true",
+  "+terminal_bench_config.harbor.extra_body.chat_template_kwargs={enable_thinking: true}",
+  "+terminal_bench_config.harbor.override_timeout_sec=1800",
+  "+terminal_bench_config.harbor.override_cpus=1",
+  "+terminal_bench_config.harbor.override_memory_mb=2048",
+  "+terminal_bench_config.harbor.override_storage_mb=2048",
+  "+terminal_bench_config.harbor.auto_snapshot=true",
+  "+terminal_bench_config.harbor.verifier_override_timeout_sec=120",
+  "+terminal_bench_config.harbor.max_retries=3",
+  "+terminal_bench_config.harbor.min_wait_sec=60.0",
+  "+terminal_bench_config.harbor.max_wait_sec=600.0",
+  "+terminal_bench_config.harbor.wait_multiplier=2.0",
+  "+terminal_bench_config.harbor.exclude_exceptions=[\"AgentTimeoutError\",\"VerifierTimeoutError\",\"RewardFileNotFoundError\",\"RewardFileEmptyError\",\"VerifierOutputParseError\",\"ContextLengthExceededError\"]",
+  "+terminal_bench_config.harbor.n_concurrent_trials=280",
+  "+terminal_bench_config.harbor.log_level=INFO",
+  "+terminal_bench_config.harbor.enable_reward_shaping=false",
+  "+terminal_bench_config.harbor.enable_error_classification=true",
+  "+terminal_bench_config.harbor.mask_exceptions=[\"DaytonaError\",\"EnvironmentStartTimeoutError\",\"NetworkError\",\"ConnectionError\",\"RewardFileNotFoundError\",\"RewardFileEmptyError\",\"AgentEnvironmentTimeoutError\",\"AgentTimeoutError\",\"ContextLengthExceededError\"]",
+  "+terminal_bench_config.harbor.default_error_treatment=zero",
+  "+terminal_bench_config.archiving.enabled=false",
+  "+terminal_bench_config.trace_upload.enabled=true",
+  "+terminal_bench_config.trace_upload.repo_org=DCAgent",
+  "+terminal_bench_config.trace_upload.episodes=last",
+  "+terminal_bench_config.trace_upload.dataset_type=SFT"
+ ],
+ "num_nodes": 6,
+ "gpus_per_node": 4,
+ "cluster_name": "perlmutter",
+ "agent_name": "terminus-2",
+ "harbor_env": "daytona"
+}
\ No newline at end of file
diff --git a/viewer/build/inputs/openthoughts/sft_trainer_states.json.gz b/viewer/build/inputs/openthoughts/sft_trainer_states.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..38f73279744e6b6423e82344d042df3efadedac0
--- /dev/null
+++ b/viewer/build/inputs/openthoughts/sft_trainer_states.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc394daf564599ba88cb3925d0bd6f1c513826eafd07324f9d0d19fa5b1cac22
+size 154389
diff --git a/viewer/build/inputs/openthoughts/tasks_and_benchmarks.json.gz b/viewer/build/inputs/openthoughts/tasks_and_benchmarks.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..e6e2b0d800287b6f19067480f1c24e3e42d0a491
--- /dev/null
+++ b/viewer/build/inputs/openthoughts/tasks_and_benchmarks.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:947a76461a2d11ef319b1ac7903f2fbd1b798cd378695349f49f5e426ad8cec4
+size 308228
diff --git a/viewer/build/inputs/openthoughts/tb2_rl45_trials.json.gz b/viewer/build/inputs/openthoughts/tb2_rl45_trials.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..1d575ddd27118826f4f93174a4752a079ee6779f
--- /dev/null
+++ b/viewer/build/inputs/openthoughts/tb2_rl45_trials.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09da28b49dd9b7948e0bc490ade22b66f25c91cf95224a952e1ecaac6db66ea1
+size 674535
diff --git a/viewer/build/inputs/prime/SOURCE.md b/viewer/build/inputs/prime/SOURCE.md
new file mode 100644
index 0000000000000000000000000000000000000000..88311e00be9cf452593559f07aec3b23525552af
--- /dev/null
+++ b/viewer/build/inputs/prime/SOURCE.md
@@ -0,0 +1,13 @@
+# Inputs for `labs/prime.py`
+
+Everything here was copied from public sources on 2026-09-26. The viewer build reads only these files. Published numbers that are not in these files (report tables, hyperparameters, task counts) are written in `labs/prime.py` next to their source URL. Strings that look like credentials were replaced with `[redacted]` while copying (none were found).
+
+| File | What it is | Where it came from | License |
+|---|---|---|---|
+| `i3_rl_rows.json.gz` | 2,000 rows from each of the `math`, `code`, `science` and `logic` configs of INTELLECT-3-RL (20 pages of 100 rows at evenly spaced offsets, plus logic rows 250, 2750, 3750, 5750, 7500 named in the dossier): question (cut at 700 characters), answer (cut at 120), the published Qwen3-4B solve-rate columns (`avg@8_*` / `avg@16_*`), and for code the function name and test count, for logic the task type. | https://huggingface.co/datasets/PrimeIntellect/INTELLECT-3-RL via https://datasets-server.huggingface.co/rows | not stated on the dataset card |
+| `deepdive_qa_rl.json.gz` | All 2,234 rows of the `qa_rl` split: id, question (cut at 700), answer (cut at 160). | https://huggingface.co/datasets/zai-org/DeepDive via datasets-server | not stated in our copy (see the card) |
+| `r2e_gym_subset.json.gz` | For all 4,578 R2E-Gym-Subset rows: repo, commit (12 characters), non-test files and lines changed, first two relevant files; plus the real problem statement (title and first 900 characters) of the 11 rows we downloaded whole (rows 0-4, 590, 1739, 2038, 2253, 2514, 3134). | https://huggingface.co/datasets/R2E-Gym/R2E-Gym-Subset (metadata columns and `/rows` for single rows) | apache-2.0 |
+| `pi_runs.json.gz` | `run.json` and every row of `metrics.jsonl` for five Prime Intellect Lab hosted runs shared publicly: `pi-calendar-scheduling-qwen3-30b-a3b` (https://app.primeintellect.ai/training/shared/wxhl0r3gqmj6qxgpcg35m605), `pi-prime-grep-qwen35-35b-a3b` (…/zauvj22d2hddluabwzzrz83m), `pi-webvoyager-qwen3-4b-browserbase` (…/aixtf0gfgstmasfsugb9x3bg, a Browserbase user's run), `pi-webvoyager-qwen3-vl-8b` (…/v8uz1wu40av5bssrqz3mi203), `pi-wikispeedia-nemotron3-nano-30b` (…/teb5rp1wohiggj9cdh82if8g). | Local imports in `~/benchflow/pta-work/public-runs/<run>/` made by `importers/train_primeintellect.py` from Prime's public tRPC API (`fineTuning.getPublicRun`, `getPublicRunMetrics`, `getPublicRunMetricSeries`). Numbers unchanged. | unknown (shared publicly on Prime Intellect Lab; no license stated) |
+| `pi_rollouts.json.gz` | Every sample rollout the Lab stores for three of those runs (80 + 80 + 96: 8 rollouts at every 10th step): reward, rubric metrics, turns, tool calls, agent time, and the transcript converted to the viewer's message format (system/user/assistant/tool). Message text cut at 6,000 characters and tool results at 3,000; screenshots were already dropped by the importer. | `~/benchflow/pta-work/public-runs/pi-*-rollouts/` (`attempts.jsonl`, `traces/`), made by `importers/rollouts_primeintellect.py` from the same public API. | unknown (as above) |
+
+Not copied: the INTELLECT-3 technical report and model cards are cited by URL only; no INTELLECT-3 or INTELLECT-3.1 training logs are public, so their runs in the demo are simulated (see each run's description).
diff --git a/viewer/build/inputs/prime/deepdive_qa_rl.json.gz b/viewer/build/inputs/prime/deepdive_qa_rl.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..d5fbef8e641c9069ef2d03603aba6832cd701280
--- /dev/null
+++ b/viewer/build/inputs/prime/deepdive_qa_rl.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4252b30ccbb65f76ac29bc7d53cf9d0e674f33ca52658a18698c720f747d9b7f
+size 615830
diff --git a/viewer/build/inputs/prime/i3_rl_rows.json.gz b/viewer/build/inputs/prime/i3_rl_rows.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..d9f9bf18cbdf815df5810ea13d9a6f352cdebf13
--- /dev/null
+++ b/viewer/build/inputs/prime/i3_rl_rows.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e30e2dd39eb91da57d92294c9e8873369504c2a9c8f27112307e8dead3aa481c
+size 1128530
diff --git a/viewer/build/inputs/prime/pi_rollouts.json.gz b/viewer/build/inputs/prime/pi_rollouts.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..342b5d0d754d1d01303b0a98db0ec637aef19976
--- /dev/null
+++ b/viewer/build/inputs/prime/pi_rollouts.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09fada7730e0c77157d468fc934084534e201a554d8cc7abf1ed5621708e8828
+size 317226
diff --git a/viewer/build/inputs/prime/pi_runs.json.gz b/viewer/build/inputs/prime/pi_runs.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..0b66c050518ae74d6be69e80af304a82287dae17
--- /dev/null
+++ b/viewer/build/inputs/prime/pi_runs.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e81693330a7fc28e192886fa138059ea73f0afc97058c20e99534a8fd27b8442
+size 71266
diff --git a/viewer/build/inputs/prime/r2e_gym_subset.json.gz b/viewer/build/inputs/prime/r2e_gym_subset.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..91e44ec52ddcefc22d65ce90a2d942cc5bc17785
--- /dev/null
+++ b/viewer/build/inputs/prime/r2e_gym_subset.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ff5dbf29d1f08533a6c249539c4f7c973c4db8c3813e5dd9dfbd5a0b7e2b6a0
+size 65635
diff --git a/viewer/build/kit.py b/viewer/build/kit.py
new file mode 100644
index 0000000000000000000000000000000000000000..056e4b9a60f4c9fee7b45260036e0f59a9a233a3
--- /dev/null
+++ b/viewer/build/kit.py
@@ -0,0 +1,223 @@
+"""Helpers every lab module uses to write records (see PROTOCOL.md).
+
+A lab module calls these in order: org → project → models → datasets → graders/environments →
+runs (training.rl_run / sft_run / dpo_run, or real metrics via import_metrics) → benchmarks and
+evals (training.benchmark / eval_run) → jobs/usage → reports. Every helper takes the World `w`
+and returns ids (or objects) for later references.
+"""
+import datetime as dt
+import math
+
+from . import signals as sig
+from .sim import Env, make_tasks, rid, rng, solve_skill, task_rows
+
+# ------------------------------------------------------------------ scope
+
+def org(w, slug, name, about="", url=""):
+    oid = rid("org", slug)
+    w.add("orgs", {"id": oid, "slug": slug, "name": name, "about": about, "url": url})
+    return oid
+
+
+def project(w, org_id, slug, name, summary, sources, data_note, created_at, pins=None):
+    pid = rid("proj", org_id, slug)
+    w.add("projects", {"id": pid, "org_id": org_id, "slug": slug, "name": name, "summary": summary,
+                       "created_at": created_at, "sources": sources, "data_note": data_note, "pins": pins or []})
+    return pid
+
+
+# ------------------------------------------------------------------ models
+
+def model(w, pid, key, name, kind="checkpoint", *, hf_repo=None, arch=None, params_total=None, params_active=None,
+          context_len=None, parent_id=None, run_key=None, step=None, stage=None, created_at=None, status="available",
+          notes="", source=""):
+    """kind: base | checkpoint | teacher | reward | judge | external. params in billions."""
+    mid = rid("model", pid, key)
+    w.add("models", {"id": mid, "project_id": pid, "name": name, "kind": kind, "hf_repo": hf_repo, "arch": arch,
+                     "params_total": params_total, "params_active": params_active, "context_len": context_len,
+                     "parent_id": parent_id, "run_id": rid("run", pid, run_key) if run_key else None, "step": step,
+                     "stage": stage, "created_at": created_at, "status": status, "notes": notes, "source": source})
+    return mid
+
+
+def run_id(pid, key):
+    return rid("run", pid, key)
+
+
+# ------------------------------------------------------------------ datasets
+
+def dataset(w, pid, key, name, kind, *, rows=None, tokens=None, sources=(), processing=(), samples=(),
+            version="", parent_key=None, license=None, hf_repo=None, description="", created_at=None,
+            source="", provenance="published", fields=None):
+    """sources: [{name, category, rows, tokens, synthetic, generator, license, url}]
+    processing: [{step, rows_in, rows_out, note}]
+    samples: [{"source": ..., "category": ..., "data": {"messages": [...]} or {"prompt","chosen","rejected"} or {...}}]
+    """
+    did = rid("ds", pid, key)
+    w.add("datasets", {"id": did, "project_id": pid, "name": name, "kind": kind, "version": version,
+                       "parent_id": rid("ds", pid, parent_key) if parent_key else None, "rows": rows, "tokens": tokens,
+                       "license": license, "hf_repo": hf_repo, "description": description, "created_at": created_at,
+                       "processing": list(processing), "fields": fields, "source": source, "provenance": provenance})
+    for s in sources:
+        w.add("dataset_sources", {"dataset_id": did, "name": s["name"], "category": s.get("category"),
+                                  "rows": s.get("rows"), "tokens": s.get("tokens"),
+                                  "synthetic": None if s.get("synthetic") is None else int(bool(s.get("synthetic"))),
+                                  "generator": s.get("generator"), "license": s.get("license"), "url": s.get("url")})
+    for i, smp in enumerate(samples):
+        w.add("dataset_rows", {"dataset_id": did, "idx": i, "source": smp.get("source"), "category": smp.get("category"),
+                               "data": smp["data"], "tokens": smp.get("tokens")})
+    return did
+
+
+def dataset_id(pid, key):
+    return rid("ds", pid, key)
+
+
+# ------------------------------------------------------------------ graders and environments
+
+def grader(w, pid, key, name, kind, description, components, formula=None):
+    gid = rid("grader", pid, key)
+    w.add("graders", {"id": gid, "project_id": pid, "name": name, "kind": kind, "description": description,
+                      "components": components,
+                      "formula": formula or ("reward = " + " + ".join(f"{c.get('weight', 1)}×{c['name']}" for c in components))})
+    return gid
+
+
+def environment(w, pid, key, name, domain, *, n_tasks, bank, grader_id=None, harness=None, tools=(),
+                reward_kind="binary", sandbox=None, description="", version="", source="", provenance="mixed",
+                difficulty=(0.0, 2.0), statuses=None, profile=None, created_at=None, task_count=None, checks=None):
+    """Create an environment and its tasks.
+
+    n_tasks tasks are stored (keep it ≤ 2,000); task_count is the real size if larger.
+    profile: Env fields for simulation, e.g. {"turns": (20, 100), "tokens_out": 30000, "seconds": 600,
+    "infra_rate": 0.01, "timeout_rate": 0.02, "partial_steps": 0, "judge": False, "max_tokens": 65536}.
+    checks: published validation results, e.g. [{"name": "Hack agent", "status": "pass|warn|fail",
+    "detail": "...", "rounds": [0.92, 0.49, 0.33, 0.22], "source": url}]. When absent the page derives
+    checks from task statuses.
+    """
+    eid = rid("env", pid, key)
+    tasks = make_tasks(eid, n_tasks, bank, difficulty, statuses or {})
+    prof = dict(profile or {})
+    env = Env(id=eid, project_id=pid, name=name, domain=domain, harness=harness or "", reward_kind=reward_kind,
+              tasks=tasks, tools=list(tools), **prof)
+    w.add("environments", {"id": eid, "project_id": pid, "name": name, "domain": domain, "version": version,
+                           "description": description, "harness": harness, "tools": list(tools), "grader_id": grader_id,
+                           "reward_kind": reward_kind, "sandbox": sandbox, "task_count": task_count or n_tasks,
+                           "created_at": created_at, "source": source, "provenance": provenance,
+                           "checks": list(checks) if checks else None})
+    return env
+
+
+def write_tasks(w, env, base_pass=None, latest_pass=None, base_skill=None, latest_skill=None, attempts=8):
+    """Store the environment's tasks with pass rates for the base and latest policy.
+
+    Give either pass rates (mean over tasks, 0-1) or skills."""
+    d = [t.difficulty for t in env.tasks]
+    if base_skill is None:
+        base_skill = solve_skill(d, min(0.99, max(0.01, base_pass if base_pass is not None else 0.3)))
+    if latest_skill is None and latest_pass is not None:
+        latest_skill = solve_skill(d, min(0.99, max(0.01, latest_pass)))
+    w.add_many("tasks", list(task_rows(env, base_skill, latest_skill, attempts=attempts)))
+
+
+# ------------------------------------------------------------------ metrics you already have
+
+def import_metrics(w, run_id_, series, step_key=None):
+    """series: {tag: [(step, value), ...]} → metrics rows."""
+    rows = []
+    for tag, pts in series.items():
+        for step, v in pts:
+            if v is None or (isinstance(v, float) and (math.isnan(v) or math.isinf(v))):
+                continue
+            rows.append({"run_id": run_id_, "tag": tag, "step": int(step), "value": float(v)})
+    w.add_many("metrics", rows)
+
+
+def metric_defs(w, pid, framework, pinned=(), extra=()):
+    """Register canonical-signal definitions for a framework's tags, plus extra rows
+    ({tag, label, description, unit, format, grp, better, pinned, signal})."""
+    rows = sig.metric_defs(pid, framework, pinned)
+    have = {r["tag"] for r in rows}
+    for r in extra:
+        r = dict({"project_id": pid, "unit": "", "format": "num3", "grp": r.get("tag", "").split("/")[0], "better": "none",
+                  "pinned": 0, "signal": None, "description": "", "label": r.get("tag")}, **r)
+        if r["tag"] in have:
+            rows = [x for x in rows if x["tag"] != r["tag"]]
+        rows.append(r)
+    existing = {r[0] for r in w.conn.execute("SELECT tag FROM metric_defs WHERE project_id=?", (pid,))}
+    w.add_many("metric_defs", [r for r in rows if r["tag"] not in existing])
+
+
+# ------------------------------------------------------------------ operations
+
+def cluster(w, org_id, key, name, provider, gpu=None, gpus=None, region=None, price_hour=None):
+    cid = rid("cluster", org_id, key)
+    w.add("clusters", {"id": cid, "org_id": org_id, "name": name, "provider": provider, "gpu": gpu, "gpus": gpus,
+                       "region": region, "price_hour": price_hour})
+    return cid
+
+
+def jobs_for_run(w, pid, run, cluster_id, *, restarts=(), workers=None, extra=()):
+    """Trainer job attempts split at restarts (each restart ends one attempt), plus optional rollout
+    workers {"name", "gpus", "gpu", "share"} and extra job dicts."""
+    start, end = run["started_at"], run.get("ended_at") or run.get("updated_at") or start
+    bounds = [start] + sorted(t for t in restarts if start < t < end) + [end]
+    total = run.get("cost_usd") or 0.0
+    span = max(1.0, end - start)
+    status = run.get("status", "completed")
+    for i in range(len(bounds) - 1):
+        a, b = bounds[i], bounds[i + 1]
+        last = i == len(bounds) - 2
+        w.add("jobs", {"id": rid("job", run["id"], "train", i), "project_id": pid, "run_id": run["id"], "eval_id": None,
+                       "name": f"{run['name']} · trainer" + (f" (attempt {i + 1})" if len(bounds) > 2 else ""), "kind": "train",
+                       "status": status if last else "failed", "cluster_id": cluster_id, "gpu": run.get("gpu"),
+                       "gpus": run.get("gpus"), "nodes": (run.get("gpus") or 0) // 8 or None, "started_at": a,
+                       "ended_at": None if (last and status == "running") else b,
+                       "cost_usd": round(total * (b - a) / span, 2), "exit": ("restarted" if not last else status),
+                       "log_tail": ""})
+    for wk in (workers or []):
+        w.add("jobs", {"id": rid("job", run["id"], wk["name"]), "project_id": pid, "run_id": run["id"], "eval_id": None,
+                       "name": f"{run['name']} · {wk['name']}", "kind": wk.get("kind", "rollout"), "status": status,
+                       "cluster_id": wk.get("cluster_id", cluster_id), "gpu": wk.get("gpu"), "gpus": wk.get("gpus"),
+                       "nodes": None, "started_at": start, "ended_at": None if status == "running" else end,
+                       "cost_usd": round(total * wk.get("share", 0), 2) if wk.get("share") else None,
+                       "exit": status, "log_tail": ""})
+    for j in extra:
+        w.add("jobs", dict({"project_id": pid, "run_id": run["id"], "eval_id": None, "nodes": None, "log_tail": "",
+                            "exit": j.get("status")}, **j))
+
+
+def usage_for_run(w, org_id, pid, start, end, cost, split=(("training", 0.45), ("rollouts", 0.5), ("evals", 0.05))):
+    """Spread a run's cost over the UTC days it ran."""
+    if not cost or not start or not end or end <= start:
+        return
+    day = 86400
+    t = start
+    while t < end:
+        nxt = min(end, (math.floor(t / day) + 1) * day)
+        d = dt.datetime.fromtimestamp(t, dt.timezone.utc).strftime("%Y-%m-%d")
+        spend = cost * (nxt - t) / (end - start)
+        for cat, share in split:
+            w.add("usage", {"org_id": org_id, "project_id": pid, "day": d, "category": cat, "quantity": None,
+                            "unit": "usd", "cost_usd": round(spend * share, 2)})
+        t = nxt
+
+
+def report(w, pid, key, title, author, created_at, summary, claims, run_keys=(), body=""):
+    """claims: [{"claim", "verdict": upheld|rejected|open, "evidence"}]"""
+    w.add("reports", {"id": rid("report", pid, key), "project_id": pid, "title": title, "author": author,
+                      "created_at": created_at, "run_ids": [rid("run", pid, k) for k in run_keys],
+                      "summary": summary, "body": body, "claims": list(claims)})
+
+
+def deployment(w, pid, key, model_id, name, gpu, replicas, created_at, status="serving", requests_24h=None,
+               p50_ms=None, tokens_24h=None):
+    w.add("deployments", {"id": rid("dep", pid, key), "project_id": pid, "model_id": model_id, "name": name,
+                          "status": status, "endpoint": f"https://api.posttrain.example/v1/{name}", "gpu": gpu,
+                          "replicas": replicas, "created_at": created_at, "requests_24h": requests_24h,
+                          "p50_ms": p50_ms, "tokens_24h": tokens_24h})
+
+
+def ts(s):
+    """'2026-09-15 18:32' (UTC) → epoch seconds."""
+    return dt.datetime.strptime(s, "%Y-%m-%d %H:%M").replace(tzinfo=dt.timezone.utc).timestamp()
diff --git a/viewer/build/labs/__init__.py b/viewer/build/labs/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..923d8cc3b5e339bbbc77fe416434aa545abb9bd5
--- /dev/null
+++ b/viewer/build/labs/__init__.py
@@ -0,0 +1 @@
+"""One module per lab; each exposes build(world, now)."""
diff --git a/viewer/build/labs/agentica.py b/viewer/build/labs/agentica.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cca319cd01f7b376a2a0dc33b9cadbb9742709b
--- /dev/null
+++ b/viewer/build/labs/agentica.py
@@ -0,0 +1,675 @@
+"""Agentica: DeepSWE-Preview, Qwen3-32B trained with RL only on R2E-Gym-Subset (rLLM on a verl fork).
+
+Published (inputs/agentica, see SOURCE.md): every logged W&B series of the final run (part 1 steps
+1-170, part 2 steps 171-253) and of the two public ablations; per-instance results of 7 of the 16
+official SWE-bench Verified evaluation runs and 112 of their trajectories; card and blog scores.
+Simulated: training rollouts (drawn to match each step's logged pass rate), per-task results of the
+9 evaluation runs we do not hold, per-task results behind the other published scores, run dates.
+"""
+import gzip
+import json
+import math
+import random
+from collections import defaultdict
+from pathlib import Path
+
+from .. import kit
+from ..sim import Env, attempt, rid, rng, solve_skill, stable_seed
+from ..training import Bench, benchmark, eval_run
+
+INPUTS = Path(__file__).resolve().parent.parent / "inputs" / "agentica"
+CARD = "https://huggingface.co/agentica-org/DeepSWE-Preview"
+BLOG = ("https://pretty-radio-b75.notion.site/DeepSWE-Training-a-Fully-Open-sourced-State-of-the-Art-Coding-Agent-by-"
+        "Scaling-RL-22281902c1468193aabbe9a8c59bbe33")
+TOGETHER = "https://www.together.ai/blog/deepswe"
+WANDB = "https://wandb.ai/mluo/deepswe"
+W1, W2 = WANDB + "/runs/bx0o5d9l", WANDB + "/runs/fmwxpge7"
+WT, WD = WANDB + "/runs/tzaqgde3", WANDB + "/runs/dax4at2n"
+EVAL_LOGS = "https://drive.google.com/file/d/10LIwpJeaFuiX6Y-qEG2a4a335PEuQJeS"
+R2E_PAPER = "https://arxiv.org/abs/2504.07164"
+R2E_DS = "https://huggingface.co/datasets/R2E-Gym/R2E-Gym-Subset"
+SWEBV = "https://huggingface.co/datasets/R2E-Gym/SWE-Bench-Verified"
+VERIFIER = "https://huggingface.co/agentica-org/DeepSWE-Verifier"
+OT_PAPER = "https://arxiv.org/abs/2606.24855"
+RLLM = "https://github.com/rllm-org/rllm/blob/6458960c24/examples/swe/train_deepswe_32b.sh"
+REAL_RUNS = ["0", "1", "2", "5", "10", "11", "13"]
+LIMIT_OUTCOME = {"token_limit": ("truncated", "max_tokens"), "abs_step_limit": ("max_turns", "max_turns"),
+                 "max_step_limit": ("max_turns", "max_turns"), "agent_max_step_limit": ("max_turns", "max_turns"),
+                 "llm_query_error": ("infra_error", "llm_query_error")}
+
+
+def _load(name):
+    with gzip.open(INPUTS / name, "rt") as fh:
+        return json.load(fh)
+
+
+def _logit(p):
+    p = min(0.98, max(0.02, p))
+    return math.log(p / (1 - p))
+
+
+def _fix_score(w, eval_id, value):
+    """Store a published score exactly when the simulated per-task results can only approximate it."""
+    w.conn.execute("UPDATE evals SET score=? WHERE id=?", (round(value, 5), eval_id))
+
+
+def _with_k(bench, k):
+    b = Bench(bench.id, bench.project_id, bench.name, bench.tasks, k, bench.metric)
+    b.store_tasks = True
+    return b
+
+
+def _eval_exact(w, bench, *, model_id, passes, k, score, key, started, run_id=None, step=None, duration=3600.0,
+                source="", provenance="mixed", config=None, command="", turns=None, tokens=None):
+    """An eval from given per-task pass counts; the stored score is the published one."""
+    eval_id = rid("eval", bench.id, key)
+    n = len(bench.tasks)
+    means = [p / k for p in passes]
+    mean = sum(means) / n
+    sd = (sum((m - mean) ** 2 for m in means) / max(1, n - 1)) ** 0.5
+    w.add("evals", {"id": eval_id, "project_id": bench.project_id, "benchmark_id": bench.id, "model_id": model_id,
+                    "run_id": run_id, "step": step, "status": "completed", "score": round(score, 5),
+                    "stderr": round(sd / math.sqrt(n), 5), "n_tasks": n, "k": k, "n_infra": None, "started_at": started,
+                    "ended_at": started + duration, "cost_usd": None, "config": config, "command": command,
+                    "source": source, "provenance": provenance})
+    w.add_many("eval_tasks", [{"eval_id": eval_id, "task_id": t.id, "task_name": t.name, "attempts": k, "passes": passes[i],
+                               "infra": 0, "score": round(passes[i] / k, 4),
+                               "mean_turns": (turns or {}).get(t.name), "mean_tokens": (tokens or {}).get(t.name)}
+                              for i, t in enumerate(bench.tasks)])
+    return eval_id
+
+
+def _pick_weighted(r, items, weights, n):
+    """n items without replacement, more likely the heavier ones (Efraimidis-Spirakis keys)."""
+    keyed = sorted(items, key=lambda i: -(r.random() ** (1.0 / max(1e-6, weights[i]))))
+    return set(keyed[:n])
+
+
+def _series(rows, offset=0):
+    out = defaultdict(list)
+    for row in rows:
+        step = row.get("_step")
+        if step is None:
+            continue
+        for k, v in row.items():
+            if k.startswith("_") or isinstance(v, bool) or not isinstance(v, (int, float)):
+                continue
+            if isinstance(v, float) and (math.isnan(v) or math.isinf(v)):
+                continue
+            out[k].append((int(step) + offset, float(v)))
+    return out
+
+
+def _add_shares(series, batch=64):
+    for tag in ("batch/solve_none", "batch/solve_all"):
+        if tag in series:
+            series[tag + "_share"] = [(s, v / batch) for s, v in series[tag]]
+
+
+def _steps_rows(run_id, series, t0, stored=None, gap_after=None, gap=0.0):
+    """run_steps from the logged series; returns rows and {step: (start, end)}."""
+    by = defaultdict(dict)
+    for tag, pts in series.items():
+        for s, v in pts:
+            by[s][tag] = v
+    rows, when, t = [], {}, t0
+    for s in sorted(by):
+        d = by[s]
+        if "critic/score/mean" not in d:
+            continue
+        dur = d.get("timing_s/step") or 1800.0
+        start = t
+        t = t + dur
+        when[s] = (start, t)
+        solve_none, solve_all = d.get("batch/solve_none"), d.get("batch/solve_all")
+        rows.append({"run_id": run_id, "step": s, "phase": "train", "started_at": start, "ended_at": t, "prompts": 64,
+                     "rollouts": 512, "rollouts_stored": (stored or {}).get(s, 0), "reward_mean": d.get("critic/rewards/mean"),
+                     "pass_rate": d.get("critic/score/mean"),
+                     "tokens": int(512 * ((d.get("response_length/mean") or 0) + (d.get("prompt_length/mean") or 0))),
+                     "groups_all_pass": None if solve_all is None else int(solve_all),
+                     "groups_all_fail": None if solve_none is None else int(solve_none),
+                     "groups_mixed": None if solve_all is None or solve_none is None else int(64 - solve_all - solve_none),
+                     "infra_errors": None,
+                     "truncated": None if d.get("response_length/clip_ratio") is None else int(round(d["response_length/clip_ratio"] * 512))})
+        if gap_after is not None and s == gap_after:
+            t += gap
+    return rows, when
+
+
+def _config_text(meta):
+    run = meta["data"]["project"]["run"] if "data" in meta else meta
+    cfg = run.get("config")
+    if isinstance(cfg, str):
+        cfg = json.loads(cfg)
+    flat = {}
+
+    def walk(o, p=""):
+        if isinstance(o, dict):
+            if "value" in o and len(o) <= 2:
+                walk(o["value"], p)
+                return
+            for k, x in o.items():
+                walk(x, f"{p}.{k}" if p else k)
+        else:
+            flat[p] = o
+    walk(cfg or {})
+    keep = ("actor_rollout_ref.model.path", "actor_rollout_ref.actor.optim.lr", "actor_rollout_ref.actor.optim.weight_decay",
+            "actor_rollout_ref.actor.clip_ratio_low", "actor_rollout_ref.actor.clip_ratio_high", "actor_rollout_ref.actor.use_kl_loss",
+            "actor_rollout_ref.actor.entropy_coeff", "actor_rollout_ref.actor.loss_agg_mode", "actor_rollout_ref.actor.ppo_mini_batch_size",
+            "actor_rollout_ref.actor.ppo_epochs", "actor_rollout_ref.actor.grad_clip", "actor_rollout_ref.actor.ulysses_sequence_parallel_size",
+            "actor_rollout_ref.rollout.n", "actor_rollout_ref.rollout.name", "actor_rollout_ref.rollout.temperature",
+            "actor_rollout_ref.rollout.tensor_model_parallel_size", "actor_rollout_ref.rollout.gpu_memory_utilization",
+            "algorithm.adv_estimator", "agent.max_steps", "agent.trajectory_timeout", "agent.overlong_filter",
+            "data.train_batch_size", "data.max_prompt_length", "data.max_response_length", "data.train_files", "data.val_files",
+            "trainer.nnodes", "trainer.n_gpus_per_node", "trainer.test_freq", "trainer.experiment_name")
+    lines = [f"# W&B config of run {run.get('name')} ({run.get('displayName')}); selected keys"]
+    for k in keep:
+        if k in flat:
+            lines.append(f"{k}: {json.dumps(flat[k]) if not isinstance(flat[k], str) else flat[k]}")
+    return "\n".join(lines), flat
+
+
+def build(w, now):
+    org_id = kit.org(w, "agentica", "Agentica",
+                     about="Open-source agent RL project from UC Berkeley (the rLLM framework and the DeepScaleR/DeepCoder/DeepSWE models); DeepSWE was trained together with Together AI.",
+                     url="https://huggingface.co/agentica-org")
+    pid = kit.project(
+        w, org_id, "deepswe", "DeepSWE",
+        "DeepSWE-Preview: Qwen3-32B trained as a coding agent with reinforcement learning only (no SFT) on 4,578 R2E-Gym-Subset tasks with rLLM; 42.2% Pass@1 on SWE-bench Verified, 59.0% with hybrid test-time scaling.",
+        [{"title": "DeepSWE-Preview model card", "url": CARD}, {"title": "DeepSWE blog (Notion, Jul 2025)", "url": BLOG},
+         {"title": "DeepSWE on the Together AI blog", "url": TOGETHER}, {"title": "W&B project mluo/deepswe", "url": WANDB},
+         {"title": "Evaluation logs (deepswe.zip, 16 runs)", "url": EVAL_LOGS}, {"title": "R2E-Gym paper", "url": R2E_PAPER},
+         {"title": "R2E-Gym-Subset", "url": R2E_DS}, {"title": "rLLM DeepSWE training script", "url": RLLM},
+         {"title": "OpenThoughts-Agent paper (third-party evals of DeepSWE-Preview)", "url": OT_PAPER}],
+        "Training curves are Agentica's public W&B logs (every key, every step) for the final run and two failed ablations. "
+        "SWE-bench Verified scores are the card's and blog's; per-instance results and 112 trajectories come from 7 of the 16 "
+        "published evaluation runs, and the other 9 runs are simulated so the 16-run Pass@1 is exactly 42.2% and Pass@16 exactly "
+        "71.0%. Training rollouts were never released: the ones shown are simulated to match each step's logged pass rate. "
+        "Dates are placed before the 2025-07-01 release (W&B timestamps are upload times); step durations are the logged ones. "
+        "No costs are published, so none are shown.",
+        kit.ts("2025-05-15 00:00"), pins=["critic/score/mean", "val/test_score/swe", "batch/solve_none_share", "actor/entropy_loss"])
+
+    # models ---------------------------------------------------------------
+    qwen32 = kit.model(w, pid, "qwen3-32b", "Qwen3-32B", "base", hf_repo="Qwen/Qwen3-32B", arch="dense", params_total=32.8,
+                       context_len=32768, notes="Thinking mode on. 'Context Length: 32,768 natively and 131,072 tokens with YaRN.' No SFT before RL.",
+                       source="https://huggingface.co/Qwen/Qwen3-32B")
+    qwen14 = kit.model(w, pid, "qwen3-14b", "Qwen3-14B", "base", hf_repo="Qwen/Qwen3-14B", arch="dense",
+                       notes="Base of the public 14B ablation run and of DeepSWE-Verifier.", source=WT)
+    sft14 = kit.model(w, pid, "qwen3-14b-agent-sft", "Qwen3-14B agent SFT (global_step_30)", "checkpoint", arch="dense",
+                      parent_id=qwen14, stage="SFT", status="internal",
+                      notes="Start of the public 'swe-sft-rl-fail' run (model.path .../swe-14b-agent-sft/global_step_30/actor/checkpoint in its W&B config). Its SFT data is not published; the blog's SFT-then-RL attempts used Qwen3-32B models fine-tuned on Claude Sonnet 3.7/4 traces.",
+                      source=WD)
+    deepswe = kit.model(w, pid, "deepswe-preview", "DeepSWE-Preview", "checkpoint", hf_repo="agentica-org/DeepSWE-Preview",
+                        arch="dense", params_total=32.8, context_len=40960, parent_id=qwen32, run_key="deepswe-preview",
+                        stage="RL", created_at=kit.ts("2025-07-01 12:00"), status="released",
+                        notes="32,762,123,264 parameters stored in FP32 (131 GB). config.json sets max_position_embeddings 40,960; the card serves at 65,536 and recommends temperature 1. Which global step was exported is not stated (the card says 'just 200 steps'; W&B logs 253). MIT license.",
+                        source=CARD)
+    verifier = kit.model(w, pid, "deepswe-verifier", "DeepSWE-Verifier", "reward", hf_repo="agentica-org/DeepSWE-Verifier",
+                         arch="dense (LoRA)", params_total=14.0, parent_id=qwen14, stage="SFT", created_at=kit.ts("2025-07-01 12:00"),
+                         status="released",
+                         notes="Execution-free verifier for test-time scaling: LoRA (r 64, alpha 128) SFT of Qwen3-14B with LLaMA-Factory, lr 1e-5 cosine, 2 epochs, 7,532 steps. Not used during RL. Its training set is not disclosed.",
+                         source=VERIFIER)
+    kit.model(w, pid, "r2e-testgen", "R2E-TestgenAgent", "judge", hf_repo="R2E-Gym/R2E-TestgenAgent",
+              notes="Writes reproduction tests for the execution-based half of the hybrid verifier.",
+              source="https://github.com/R2E-Gym/R2E-Gym/blob/0d94c4eb94/reproduction/DEEPSWE_TTS_REPRODUCTION.MD")
+    refs = {}
+    for key, name, notes in (("devstral", "Devstral-Small (24B)", "OpenHands scaffold; number as listed on the DeepSWE card."),
+                             ("swe-agent-lm", "SWE-Agent-LM (32B)", "SWE-agent scaffold; as listed on the DeepSWE card."),
+                             ("skywork-swe", "Skywork-SWE (32B)", "OpenHands scaffold; as listed on the DeepSWE card."),
+                             ("skywork-swe-ef8", "Skywork-SWE (32B) + execution-free verifier", "Best@8 with an execution-free verifier; as listed on the DeepSWE card."),
+                             ("openhands-lm", "OpenHands-LM (32B)", "Iterative OpenHands; as listed on the DeepSWE card."),
+                             ("r2egym-agent", "R2EGym-Agent (32B)", "R2E-Gym scaffold; as listed on the DeepSWE card."),
+                             ("skyrl-agent", "SkyRL-Agent (14B)", "OpenHands scaffold; as listed on the DeepSWE card.")):
+        refs[key] = kit.model(w, pid, key, name, "external", notes=notes, source=CARD)
+
+    # datasets ---------------------------------------------------------------
+    r2e = _load("r2e_gym_subset.json.gz")
+    meta, statements = r2e["meta"], {int(k): v for k, v in r2e["statements"].items()}
+    repos = [("pandas", 1444), ("numpy", 781), ("pillow", 620), ("orange3", 482), ("aiohttp", 299), ("tornado", 261),
+             ("scrapy", 215), ("pyramid", 189), ("datalad", 179), ("coveragepy", 108)]
+    ds_r2e = kit.dataset(
+        w, pid, "r2e-gym-subset", "R2E-Gym-Subset", "rl_prompts", rows=4578, hf_repo="R2E-Gym/R2E-Gym-Subset", license="apache-2.0",
+        description="Executable Python repository tasks built by SWE-GEN from commits (test generation plus back-translated issue text), minus repositories that overlap SWE-bench's test repos. One Docker image per task.",
+        sources=[{"name": n, "category": "swe", "rows": c, "synthetic": True, "generator": "SWE-GEN back-translation", "license": "apache-2.0", "url": R2E_DS} for n, c in repos],
+        processing=[{"step": "SWE-GEN curation from commits", "rows_in": None, "rows_out": 8135,
+                     "note": "8,135 tasks across 13 repos (R2E-Gym paper, Table 1); commit filters such as at most 5 non-test files and 100 edited lines."},
+                    {"step": "decontam (repositories overlapping SWE-bench)", "rows_in": 8135, "rows_out": 4578,
+                     "note": "'removing repositories overlapping with SWE-Bench test-set repositories, obtaining 4578 problems' (the appendix says 4538). The HF data equal V1 minus sympy, matplotlib and moto."}],
+        samples=[{"source": meta[i]["repo"], "category": "swe",
+                  "data": {"prompt": statements[i]["text"], "task": f"{meta[i]['repo']}@{meta[i]['commit']}"}}
+                 for i in (0, 590, 1739, 2253, 3134) if i in statements],
+        created_at=kit.ts("2025-04-09 00:00"), source=R2E_DS)
+    kit.dataset(w, pid, "swebv-val", "SWE-Bench Verified (validation file)", "eval", rows=500, hf_repo="R2E-Gym/SWE-Bench-Verified",
+                description="Validation parquet of the final run (SWE_Bench_Verified.parquet), scored greedily every 10 steps.",
+                processing=[{"step": "filter overlong prompts", "rows_in": 500, "rows_out": 493,
+                             "note": "Every logged validation score is a multiple of 1/493; 7 prompts exceed max_prompt_length 4,096 with filter_overlong_prompts on (dossier reproduction with the Qwen3 tokenizer, not stated by Agentica)."}],
+                source=W1)
+
+    # grader and training environment -----------------------------------------
+    gid = kit.grader(w, pid, "r2e-tests", "R2E-Gym hidden tests", "unit_tests",
+                     "After the agent calls finish, the task's selected Fail2Pass and Pass2Pass tests run in its container; every parsed test status must equal the task's expected_output_json. Five-minute limit (the official SWE-bench harness allows 30).",
+                     [{"name": "tests", "weight": 1.0, "rule": "1 if every selected test ends with its expected status within 5 minutes, else 0."}])
+    stride = 4578 / 2000.0
+    picks = sorted({int(i * stride) for i in range(2000)} | set(statements))
+    picks = [i for i in picks if i not in statements][: 2000 - len(statements)] + sorted(statements)
+    picks = sorted(picks)[:2000]
+
+    def r2e_bank(_r, i):
+        m = meta[picks[i]]
+        name = f"{m['repo']}@{m['commit'][:10]}"
+        st = statements.get(picks[i])
+        if st:
+            return name, st["text"]
+        rel = ", ".join(m.get("rel") or []) or "not listed"
+        return name, (f"Resolve the issue behind commit {m['commit']} of {m['repo']} ({m.get('files')} non-test file(s), "
+                      f"{m.get('lines')} lines changed upstream; relevant: {rel}). The back-translated problem statement is not copied into the demo.")
+    env = kit.environment(
+        w, pid, "r2e-gym", "R2E-Gym (DeepSWE harness)", "swe", n_tasks=len(picks), bank=r2e_bank, grader_id=gid,
+        harness="R2E-Gym scaffold in rLLM SWEEnv", tools=["file_editor", "execute_bash", "search", "finish"],
+        reward_kind="binary", sandbox={"image": "one image per task (namanjain12/<repo>_final:<commit>)", "runtime": "Kubernetes pod",
+                                       "cpu": 1, "memory_gb": 1},
+        description="R2E-Gym-Subset tasks run through the R2E-Gym agent scaffold: XML-style <function=...> calls, one per step, at most 50 steps in training (100 at evaluation); the prompt begins 'I have uploaded a python code repository in the /testbed directory.' Stored: 2,000 of the 4,578 tasks (real repo@commit ids; problem statements for the 11 rows we downloaded whole).",
+        version="R2E-Gym@0d94c4eb94", source=R2E_PAPER, provenance="mixed", task_count=4578, created_at=kit.ts("2025-05-01 00:00"),
+        profile={"turns": (30, 50), "tokens_out": 16000, "tokens_in": 1800, "seconds": 1200, "infra_rate": 0.004,
+                 "timeout_rate": 0.02, "max_tokens": 32768},
+        checks=[{"name": "Tests hidden from the agent", "status": "warn",
+                 "detail": "Tests are moved to /root but symlinked back into the repository (R2E-Gym runtime/docker.py), so an agent could read them.",
+                 "source": "https://github.com/R2E-Gym/R2E-Gym/tree/0d94c4eb94"},
+                {"name": "Overlap with SWE-bench", "status": "pass",
+                 "detail": "Repositories that appear in SWE-bench's test set were removed (8,135 → 4,578 tasks).", "source": R2E_PAPER},
+                {"name": "Learning signal", "status": "pass",
+                 "detail": "Blog: 'R2E-Gym works best for RL training, since it provided sufficient curriculum learning'; SWE-Smith and SWE-Gym 'often showing high solve-none rate'.",
+                 "source": BLOG}])
+    for i, t in enumerate(env.tasks):  # larger upstream fixes are harder: shift difficulty by lines changed
+        lines = meta[picks[i]].get("lines") or 9
+        t.difficulty += 0.35 * (math.log1p(lines) - math.log1p(9))
+        t.tags = [meta[picks[i]]["repo"]]
+
+    # runs: real W&B series ------------------------------------------------------
+    wb = _load("wandb_runs.json.gz")
+    p1, p2 = _series(wb["bx0o5d9l"]["rows"]), _series(wb["fmwxpge7"]["rows"], offset=170)
+    main = defaultdict(list)
+    for s in (p1, p2):
+        for tag, pts in s.items():
+            main[tag].extend(pts)
+    _add_shares(main)
+    run_main = kit.run_id(pid, "deepswe-preview")
+    score = dict(main["critic/score/mean"])
+    base_pass = score[1]
+    late = [score[s] for s in sorted(score)[-5:]]
+    kit.write_tasks(w, env, base_pass=base_pass, latest_pass=sum(late) / len(late), attempts=8)
+
+    # simulated training rollouts: 2 groups × 8 attempts per step at the step's logged pass rate
+    r = rng("agentica-rollouts")
+    rolls, stored = [], {}
+    diffs = [t.difficulty for t in env.tasks]
+    for step in sorted(score):
+        # about 12% of would-pass attempts end truncated at 32,768 tokens (scored 0), so aim a little higher
+        skill = solve_skill(diffs, min(0.99, max(0.01, score[step] / 0.88)))
+        for g in range(2):
+            task = env.tasks[r.randrange(len(env.tasks))]
+            atts = [attempt(r, env, task, skill) for _ in range(8)]
+            vals = [a["reward"] for a in atts]
+            scored = [v for v in vals if v is not None]
+            tot = sum(scored)
+            for j, a in enumerate(atts):
+                adv = None if a["reward"] is None or len(scored) < 2 else round(a["reward"] - (tot - a["reward"]) / (len(scored) - 1), 4)
+                masked = a["reward"] is None or a["outcome"] in ("truncated", "timeout", "max_turns")
+                rolls.append({"id": rid("roll", run_main, step, g, j), "run_id": run_main, "eval_id": None, "step": step,
+                              "phase": "train", "group_id": rid("grp", run_main, step, g), "sample": j, "task_id": task.id,
+                              "env_id": env.id, "harness": env.harness, "model_id": qwen32, "reward": a["reward"],
+                              "advantage": adv, "scores": None, "outcome": a["outcome"], "stop_reason": a["stop_reason"],
+                              "turns": a["turns"], "tool_calls": a["tool_calls"], "tokens_in": a["tokens_in"],
+                              "tokens_out": a["tokens_out"], "tokens_cached": a["tokens_cached"], "duration_s": a["duration_s"],
+                              "timing": a["timing"], "staleness": 0, "flags": None, "seed": stable_seed(run_main, step, g, j),
+                              "trained": 0 if masked else 1})
+        stored[step] = 16
+    t0 = kit.ts("2025-06-08 00:00")
+    steps_main, when = _steps_rows(run_main, main, t0, stored, gap_after=170, gap=3 * 3600.0)
+    cfg1, flat1 = _config_text(wb["bx0o5d9l"]["meta"])
+    cfg2, _ = _config_text(wb["fmwxpge7"]["meta"])
+    end_main = steps_main[-1]["ended_at"]
+    w.add("runs", {
+        "id": run_main, "project_id": pid, "name": "DeepSWE-Preview RL (Qwen3-32B)", "kind": "rl", "stage": "RL", "algorithm": "GRPO++",
+        "framework": "rLLM (verl fork)", "status": "completed", "status_reason": "", "base_model_id": qwen32, "output_model_id": deepswe,
+        "started_at": t0, "ended_at": end_main, "updated_at": end_main, "steps_planned": 253, "steps_done": 253,
+        "primary_metric": "critic/score/mean", "gpu": "H100", "gpus": 64, "cost_usd": None, "cost_rate": None,
+        "owner": "Agentica (Michael Luo, Naman Jain, Jaskirat Singh, Sijun Tan, Colin Cai et al.)", "tags": ["published", "swe", "rl-only"],
+        "code_ref": "rllm-org/rllm@6458960c24 + agentica-project/verl@777704aa", "config": cfg1 + "\n\n" + cfg2, "config_format": "yaml",
+        "hyperparams": {"prompts_per_step": 64, "group_size": 8, "lr": 1e-6, "weight_decay": 0.01, "grad_clip": 1.0,
+                        "clip_ratio_low": 0.2, "clip_ratio_high": 0.28, "use_kl_loss": False, "entropy_coeff": 0,
+                        "adv_estimator": "loop (leave-one-out baseline, no std)", "loss_agg_mode": "seq-mean-token-sum",
+                        "overlong_filter": True, "max_prompt_length": 4096, "max_response_length": 32768, "agent_max_steps": 50,
+                        "trajectory_timeout_s": "5400 (part 1) / 3600 (part 2)", "rollout_temperature": 1.0, "ppo_mini_batch_size": 64,
+                        "ppo_epochs": 1, "val_every_steps": 10},
+        "parent_run_id": None, "group_name": "deepswe",
+        "description": ("GRPO++ on R2E-Gym-Subset: DAPO clip-high (0.28), no KL, no entropy loss, leave-one-out advantage without std "
+                        "(Dr.GRPO / RLOO), length-normalised loss, and compact filtering (trajectories that hit max context, max steps "
+                        "or the timeout are masked). 64 tasks × 8 rollouts = 512 Docker containers per step. Published: every metric "
+                        "series (W&B part 1 steps 1-170 on 4 × 8 H100, part 2 steps 171-253 on 8 × 8 H100 resumed from global_step_170). "
+                        "The blog says 'six days on 64 H100 GPUs' and the card 'just 200 steps'; the logged step times sum to about "
+                        "192 h. Simulated: the stored rollouts (2 groups per step drawn at the step's logged pass rate) and the dates."),
+        "source": W1, "provenance": "mixed"})
+    w.add("run_inputs", {"run_id": run_main, "kind": "environment", "ref_id": env.id, "weight": 1.0})
+    w.add("run_inputs", {"run_id": run_main, "kind": "dataset", "ref_id": ds_r2e, "weight": 1.0})
+    kit.import_metrics(w, run_main, main)
+    w.add_many("run_steps", steps_main)
+    w.add_many("rollouts", rolls)
+    ev = [{"run_id": run_main, "t": t0, "step": 0, "kind": "start", "severity": "info", "title": "Run started",
+           "body": "Part 1 (W&B bx0o5d9l): 4 nodes × 8 H100, trajectory timeout 5,400 s."}]
+    for s in sorted({s for s, _ in main.get("timing_s/save_checkpoint", [])}):
+        if s in when:
+            ev.append({"run_id": run_main, "t": when[s][1], "step": s, "kind": "checkpoint", "severity": "info",
+                       "title": f"Checkpoint global_step_{s if s <= 170 else s - 170}" + (" (part 2)" if s > 170 else ""), "body": ""})
+            w.add("checkpoints", {"id": rid("ckpt", run_main, s), "run_id": run_main, "step": s, "model_id": None,
+                                  "path": f"checkpoints/{'swe-32b' if s <= 170 else 'swe-32b-v1'}/global_step_{s if s <= 170 else s - 170}",
+                                  "size_gb": None, "created_at": when[s][1], "kept": 1})
+    ev.append({"run_id": run_main, "t": when[165][1], "step": 165, "kind": "alert", "severity": "warning",
+               "title": "Gradient-norm spike", "body": "actor/grad_norm 0.53 against a median of about 0.009; training continued."})
+    ev.append({"run_id": run_main, "t": when[170][1] + 3 * 3600, "step": 171, "kind": "restart", "severity": "warning",
+               "title": "Resumed as part 2 on 64 GPUs",
+               "body": "W&B run fmwxpge7 loaded part 1's global_step_170 on 8 × 8 H100 (was 4 × 8), with the trajectory timeout cut from 5,400 s to 3,600 s. Its data loader restarted, so steps 171+ revisit part 1's prompt order."})
+    ev.append({"run_id": run_main, "t": end_main, "step": 253, "kind": "end", "severity": "info", "title": "Run completed",
+               "body": "253 steps logged; the released checkpoint's step is not stated."})
+    w.add_many("run_events", ev)
+
+    # the two public ablations -------------------------------------------------
+    abl = {}
+    for key, wid, name, base, t0a, src, desc, reason in (
+            ("no-overlong-filter-14b", "tzaqgde3", "swe-14b-no-overlong-filter-fail", qwen14, kit.ts("2025-05-20 00:00"), WT,
+             "Qwen3-14B with the same recipe but without compact filtering (1,200 s trajectory timeout, no overlong filter). Public history covers steps 41-273. Validation peaked at 0.268 (step 190) and fell to 0.191 (step 270); response length fell from about 25K to 13.6K tokens and the gradient norm spiked to 27.2 at step 231. Agentica published it as the collapse that compact filtering prevents.",
+             "Collapsed: validation 0.268 → 0.191, gradient norm 27.2 at step 231."),
+            ("sft-then-rl-14b", "dax4at2n", "swe-sft-rl-fail", sft14, kit.ts("2025-06-01 00:00"), WD,
+             "RL from an SFT'ed Qwen3-14B checkpoint (swe-14b-agent-sft global_step_30) with the same recipe, 100 steps. Validation went 0.262 → 0.304. The blog: SFT-then-RL attempts on Qwen3-32B 'did not improve after 100 iterations', so the final run starts from the base model.",
+             "Kept as a failed direction: RL from the base model was chosen instead.")):
+        rid_ = kit.run_id(pid, key)
+        s = _series(wb[wid]["rows"])
+        _add_shares(s)
+        rows_, when_ = _steps_rows(rid_, s, t0a)
+        cfg, flat = _config_text(wb[wid]["meta"])
+        end_ = rows_[-1]["ended_at"]
+        first_step = rows_[0]["step"]
+        w.add("runs", {"id": rid_, "project_id": pid, "name": name, "kind": "rl", "stage": "RL (ablation)", "algorithm": "GRPO++",
+                       "framework": "rLLM (verl fork)", "status": "completed", "status_reason": reason, "base_model_id": base,
+                       "output_model_id": None, "started_at": t0a, "ended_at": end_, "updated_at": end_,
+                       "steps_planned": rows_[-1]["step"], "steps_done": rows_[-1]["step"], "primary_metric": "critic/score/mean",
+                       "gpu": "H100", "gpus": int((flat.get("trainer.nnodes") or 4) * (flat.get("trainer.n_gpus_per_node") or 8)),
+                       "cost_usd": None, "cost_rate": None, "owner": "Agentica", "tags": ["published", "ablation"],
+                       "code_ref": "rllm-org/rllm", "config": cfg, "config_format": "yaml",
+                       "hyperparams": {"prompts_per_step": 64, "group_size": 8, "lr": 1e-6,
+                                       "overlong_filter": bool(flat.get("agent.overlong_filter", False)),
+                                       "trajectory_timeout_s": flat.get("agent.trajectory_timeout"), "agent_max_steps": flat.get("agent.max_steps")},
+                       "parent_run_id": None, "group_name": "deepswe-ablations",
+                       "description": desc + " Published: every logged series; dates assumed.", "source": src, "provenance": "published"})
+        w.add("run_inputs", {"run_id": rid_, "kind": "environment", "ref_id": env.id, "weight": 1.0})
+        kit.import_metrics(w, rid_, s)
+        w.add_many("run_steps", rows_)
+        evs = [{"run_id": rid_, "t": t0a, "step": first_step, "kind": "start", "severity": "info", "title": "Run started",
+                "body": f"Public history starts at step {first_step}."}]
+        for cs in sorted({x for x, _ in s.get("timing_s/save_checkpoint", [])}):
+            if cs in when_:
+                evs.append({"run_id": rid_, "t": when_[cs][1], "step": cs, "kind": "checkpoint", "severity": "info",
+                            "title": f"Checkpoint global_step_{cs}", "body": ""})
+        evs.append({"run_id": rid_, "t": end_, "step": rows_[-1]["step"], "kind": "end", "severity": "info", "title": "Run completed", "body": reason})
+        w.add_many("run_events", evs)
+        abl[key] = (rid_, s, when_, int((flat.get("trainer.nnodes") or 4) * (flat.get("trainer.n_gpus_per_node") or 8)))
+
+    # metric definitions --------------------------------------------------------
+    kit.metric_defs(w, pid, "verl", pinned=("pass_rate",), extra=[
+        {"tag": "critic/score/mean", "label": "Solved share", "format": "pct", "grp": "learning", "better": "up", "pinned": 1,
+         "signal": "pass_rate", "description": "Share of the step's 512 trajectories whose patch passed the task's tests."},
+        {"tag": "critic/rewards/mean", "label": "Reward", "format": "num3", "grp": "learning", "better": "up", "signal": "reward",
+         "description": "Mean reward of the step's trajectories (equals the solved share: binary reward)."},
+        {"tag": "batch/solve_none", "label": "Tasks with no solved rollout (of 64)", "format": "int", "grp": "signal", "better": "down",
+         "signal": None, "description": "Count logged by rLLM: tasks where all 8 rollouts failed."},
+        {"tag": "batch/solve_all", "label": "Tasks with every rollout solved (of 64)", "format": "int", "grp": "signal", "better": "down",
+         "signal": None, "description": "Count logged by rLLM: tasks where all 8 rollouts passed."},
+        {"tag": "batch/solve_none_share", "label": "No-signal: all failed", "format": "pct", "grp": "signal", "better": "down",
+         "signal": "all_fail_share", "description": "batch/solve_none ÷ 64, derived by the demo from the logged count."},
+        {"tag": "batch/solve_all_share", "label": "No-signal: all passed", "format": "pct", "grp": "signal", "better": "down",
+         "signal": "all_pass_share", "description": "batch/solve_all ÷ 64, derived by the demo from the logged count."},
+        {"tag": "timing_s/collect_trajectory", "label": "Rollout time", "format": "duration", "grp": "throughput", "better": "down",
+         "signal": "gen_time", "description": "Wall-clock of collecting the step's 512 agent trajectories."},
+        {"tag": "val/test_score/swe", "label": "SWE-bench Verified (in-training)", "format": "pct", "grp": "eval", "better": "up",
+         "signal": None, "description": "Greedy decoding, 32K tokens, 50 agent steps, 493 prompts, every 10 steps."},
+        {"tag": "response_length/clip_ratio", "label": "Truncated", "format": "pct", "grp": "length", "better": "down",
+         "signal": "truncation_rate", "description": "Share of trajectories that hit 32,768 response tokens (compact filtering masks them)."},
+    ])
+
+    # benchmarks and evals --------------------------------------------------------
+    inst = _load("swebv_instances.json.gz")
+    names = [x["id"] for x in inst]
+    titles = {x["id"]: x["title"] for x in inst}
+    evals_real = _load("eval_runs_7of16.json.gz")
+    real = defaultdict(list)
+    turns = defaultdict(list)
+    toks = defaultdict(list)
+    for run_no in REAL_RUNS:
+        for x in evals_real[run_no]:
+            real[x["instance_id"]].append(1 if (x["reward"] or 0) >= 1 else 0)
+            turns[x["instance_id"]].append(x["n_steps"])
+            toks[x["instance_id"]].append(x["completion_tokens_sum"])
+    b_p1 = benchmark(w, project_id=pid, key="swebv-pass1", name="SWE-bench Verified · Pass@1", version="Verified (500)",
+                     category="swe", metric="pass@1 (mean of 16 runs)", harness="R2E-Gym scaffold, 64K context, 100 steps, temperature 1",
+                     n_tasks=500, k=16, bank=lambda _r, i: (names[i], titles[names[i]]), source=CARD,
+                     description=("Agentica's headline protocol: 16 independent runs over the 500 tasks, Pass@1 = mean over runs. For "
+                                  "DeepSWE-Preview, 7 of the 16 published run logs are imported per task (their mean is 41.3% counting "
+                                  "the 75 llm_query_error trajectories as failures, 42.2% excluding them); the other 9 runs are simulated "
+                                  "so the 16-run mean is exactly 42.2% and exactly 355 tasks (71.0%) are solved at least once. Qwen3-32B's "
+                                  "23.0% is assumed to follow the same protocol. Other agents' numbers are as listed on the DeepSWE card "
+                                  "(their own scaffolds, one attempt per task assumed)."))
+    rr = rng("agentica-pass16")
+    real_k = [sum(real[n]) for n in names]
+    extra = 9
+    sim = [sum(1 for _ in range(extra) if rr.random() < (x + 0.5) / 8.0) for x in real_k]
+    zero = [i for i, x in enumerate(real_k) if x == 0]
+    need = 355 - sum(1 for x in real_k if x > 0)
+    got = [i for i in zero if sim[i] > 0]
+    rest = [i for i in zero if sim[i] == 0]
+    rr.shuffle(got)
+    rr.shuffle(rest)
+    chosen = set((got + rest)[:need])
+    for i in zero:
+        sim[i] = max(1, sim[i]) if i in chosen else 0
+    target = 3376 - sum(real_k)
+    guard = 0
+    while sum(sim) != target and guard < 200000:
+        guard += 1
+        i = rr.randrange(500)
+        lo = 1 if i in chosen else 0
+        if real_k[i] == 0 and i not in chosen:
+            continue
+        if sum(sim) < target and sim[i] < extra:
+            sim[i] += 1
+        elif sum(sim) > target and sim[i] > lo:
+            sim[i] -= 1
+    passes16 = [real_k[i] + sim[i] for i in range(500)]
+    assert sum(passes16) == 3376 and sum(1 for p in passes16 if p) == 355
+    for i, t in enumerate(b_p1.tasks):  # difficulty follows DeepSWE's per-task rate, so other models' results correlate
+        t.difficulty = -_logit((passes16[i] + 0.5) / 17.0) + rr.gauss(0, 0.4)
+    started = kit.ts("2025-06-24 00:00")
+    e_p1 = _eval_exact(w, b_p1, model_id=deepswe, passes=passes16, k=16, score=0.422, key="deepswe|pass1", started=started,
+                       duration=2 * 86400.0, source=CARD, provenance="mixed",
+                       config={"runs": 16, "real_runs_imported": [int(x) for x in REAL_RUNS], "max_steps_absolute": 100,
+                               "max_token_limit": 65536, "temperature": 1.0},
+                       turns={n: round(sum(turns[n]) / len(turns[n]), 1) for n in names},
+                       tokens={n: round(sum(toks[n]) / len(toks[n])) for n in names})
+    eval_run(w, b_p1, model_id=qwen32, score=0.230, started=started - 86400 * 3, duration=86400, source=CARD, provenance="mixed",
+             key="qwen3-32b|pass1")
+    for key_, score_ in (("devstral", 46.6), ("swe-agent-lm", 40.2), ("skywork-swe", 38.0), ("openhands-lm", 37.2),
+                         ("r2egym-agent", 34.4), ("skyrl-agent", 21.6)):
+        eval_run(w, _with_k(b_p1, 1), model_id=refs[key_], score=score_ / 100, started=started - 86400 * 20, source=CARD,
+                 provenance="mixed", key=f"{key_}|pass1")
+
+    # the evaluation environment, so real trajectories link to task text
+    eval_env_id = rid("env", pid, "swebv-eval")
+    w.add("environments", {"id": eval_env_id, "project_id": pid, "name": "SWE-bench Verified (evaluation harness)", "domain": "swe",
+                           "version": "Verified (500)", "harness": "R2E-Gym scaffold, 100 steps, 64K context",
+                           "description": "Held-out benchmark, not used for training. Stored as an environment so the 112 imported evaluation trajectories link to their issue text. Base pass rate: Qwen3-32B (simulated per task around its published 23.0%); latest: DeepSWE-Preview's 16-run per-task rate (7 runs real).",
+                           "tools": ["file_editor", "execute_bash", "search", "finish"], "grader_id": gid, "reward_kind": "binary",
+                           "sandbox": {"image": "slimshetty/swebench-verified:sweb.eval.x86_64.<instance>", "cpu": None, "memory_gb": None},
+                           "task_count": 500, "created_at": kit.ts("2025-06-20 00:00"), "source": SWEBV, "provenance": "mixed", "checks": None})
+    qskill = solve_skill([t.difficulty for t in b_p1.tasks], 0.23)
+    w.add_many("tasks", [{"id": t.id, "env_id": eval_env_id, "name": t.name, "instruction": t.instruction, "difficulty": round(t.difficulty, 3),
+                          "tags": [t.name.split("__")[0]], "status": "ok", "status_reason": "", "oracle_score": 1.0, "noop_score": 0.0,
+                          "reruns": 0, "rerun_agree": None, "base_pass": round(1 / (1 + math.exp(-(qskill - t.difficulty))), 3),
+                          "latest_pass": round(passes16[i] / 16, 3), "attempts": 16} for i, t in enumerate(b_p1.tasks)])
+    traj = _load("eval_trajectories.json.gz")
+    by_name = {t.name: t for t in b_p1.tasks}
+    erolls, trans = [], []
+    for iid, runs_ in sorted(traj.items()):
+        t = by_name.get(iid)
+        if t is None:
+            continue
+        for run_no, x in sorted(runs_.items(), key=lambda kv: int(kv[0])):
+            rew = x["reward"]
+            ok = (rew or 0) >= 1
+            outcome, stop = ("passed", "submitted") if ok else LIMIT_OUTCOME.get(x["exit_reason"], ("failed", "submitted"))
+            if ok and x["exit_reason"] in LIMIT_OUTCOME:
+                stop = LIMIT_OUTCOME[x["exit_reason"]][1]
+            ro_id = rid("roll", e_p1, iid, run_no)
+            erolls.append({"id": ro_id, "run_id": None, "eval_id": e_p1, "step": None, "phase": "eval", "group_id": rid("grp", e_p1, iid),
+                           "sample": int(run_no), "task_id": t.id, "env_id": eval_env_id, "harness": "R2E-Gym scaffold",
+                           "model_id": deepswe, "reward": None if outcome == "infra_error" else (1.0 if ok else 0.0),
+                           "advantage": None, "scores": None, "outcome": outcome, "stop_reason": stop, "turns": x["n_steps"],
+                           "tool_calls": x["n_steps"], "tokens_in": x["prompt_tokens_sum"], "tokens_out": x["completion_tokens_sum"],
+                           "tokens_cached": None, "duration_s": round(x["total_time"], 1),
+                           "timing": {"generation": round(x["llm_time"], 1), "environment": round(x["env_time"], 1),
+                                      "scoring": round(x["reward_calc_time"] or 0, 1)},
+                           "staleness": 0, "flags": None, "seed": stable_seed(e_p1, iid, run_no), "trained": 0})
+            trans.append({"rollout_id": ro_id, "messages": x["messages"]})
+    w.add_many("rollouts", erolls)
+    w.add_many("transcripts", trans)
+
+    # Pass@16 and test-time scaling (subsets of the tasks solved at least once)
+    solved = [i for i, p in enumerate(passes16) if p]
+    wts = {i: passes16[i] / 16 for i in solved}
+    later = started + 2 * 86400.0
+    for key_, name_, metric_, score_, n_sel, desc_, src_ in (
+            ("swebv-pass16", "SWE-bench Verified · Pass@16", "pass@16", 71.0, 355,
+             "A task counts as solved if any of DeepSWE-Preview's 16 runs solved it; per task it follows the Pass@1 eval (7 runs real, 9 simulated).", BLOG),
+            ("swebv-hybrid-best16", "SWE-bench Verified · hybrid TTS Best@16", "best@16", 59.0, 295,
+             "Hybrid test-time scaling: DeepSWE-Verifier (execution-free) plus R2E-TestgenAgent reproduction tests (execution-based) pick one of 16 trajectories. Which tasks the selection solved is simulated (a subset of the Pass@16 tasks); settings such as top-n are not published. Agentica's sources also give 59.2.", BLOG),
+            ("swebv-hybrid-best8", "SWE-bench Verified · hybrid TTS Best@8", "best@8", 57.9, 290,
+             "Hybrid verifier choosing among 8 trajectories. Per-task selection simulated; 57.9% is not a multiple of 1/500, so the per-task results average to 58.0% and the published score is stored as given.", CARD),
+            ("swebv-ef-best16", "SWE-bench Verified · execution-free verifier Best@16", "best@16", 53.7, 269,
+             "DeepSWE-Verifier alone choosing among 16 trajectories (card figure bestk_plot_agent.png). Per-task selection simulated; stored score as published.", CARD),
+            ("swebv-eb-best16", "SWE-bench Verified · execution-based verifier Best@16", "best@16", 52.4, 262,
+             "Reproduction tests alone choosing among 16 trajectories (card figure). Per-task selection simulated.", CARD)):
+        b = benchmark(w, project_id=pid, key=key_, name=name_, version="Verified (500)", category="swe", metric=metric_,
+                      harness="R2E-Gym scaffold, 64K context, 100 steps", n_tasks=500, k=1,
+                      bank=lambda _r, i: (names[i], titles[names[i]]), source=src_, description=desc_)
+        sel = set(solved) if n_sel == 355 else _pick_weighted(rng("agentica-tts", key_), solved, wts, n_sel)
+        _eval_exact(w, b, model_id=deepswe, passes=[1 if i in sel else 0 for i in range(500)], k=1, score=score_ / 100,
+                    key=f"deepswe|{key_}", started=later, source=src_, provenance="mixed")
+        if key_ == "swebv-hybrid-best8":
+            b_ef8 = benchmark(w, project_id=pid, key="swebv-ef-best8", name="SWE-bench Verified · execution-free verifier Best@8",
+                              version="Verified (500)", category="swe", metric="best@8", harness="OpenHands", n_tasks=500, k=1,
+                              bank=lambda _r, i: (names[i], titles[names[i]]), source=CARD,
+                              description="Skywork-SWE with its execution-free verifier, as listed on the DeepSWE card. Per-task results simulated.")
+            eval_run(w, b_ef8, model_id=refs["skywork-swe-ef8"], score=0.47, started=later - 86400 * 20, source=CARD,
+                     provenance="mixed", key="skywork|ef8")
+    b128 = benchmark(w, project_id=pid, key="swebv-128k", name="SWE-bench Verified · Pass@1 at 128K context", version="Verified (500)",
+                     category="swe", metric="pass@1", harness="R2E-Gym scaffold, 128K context", n_tasks=500, k=1,
+                     bank=lambda _r, i: (names[i], titles[names[i]]), source=BLOG,
+                     description="Blog: 43.2% at 128K context, 'performance increase beyond 32K context is marginal'. One run per task assumed; per-task results simulated.")
+    for i, t in enumerate(b128.tasks):
+        t.difficulty = b_p1.tasks[i].difficulty
+    eval_run(w, b128, model_id=deepswe, score=0.432, started=later + 86400, source=BLOG, provenance="mixed", key="deepswe|128k")
+
+    # in-training validation (real scores every 10 steps; per-task results simulated around them)
+    order = sorted(range(500), key=lambda i: -inst[i]["len"])
+    drop = set(order[:7])
+    keep_idx = [i for i in range(500) if i not in drop]
+    b_val = benchmark(w, project_id=pid, key="swebv-val493", name="SWE-bench Verified · in-training validation",
+                      version="493 of 500", category="swe", metric="greedy pass@1", harness="rLLM SWEEnv (R2E-Gym), 32K tokens, 50 steps",
+                      n_tasks=493, k=1, bank=lambda _r, i: (names[keep_idx[i]], titles[names[keep_idx[i]]]), source=W1,
+                      description="val/test_score/swe as logged every 10 steps (scores are multiples of 1/493). Which 7 prompts the length filter dropped is not published; the demo drops the 7 longest problem statements as a stand-in. Per-task results are simulated to average exactly to each logged score. The card figure calls this axis 'SWE-Bench-Hard'.")
+    for j, t in enumerate(b_val.tasks):
+        t.difficulty = b_p1.tasks[keep_idx[j]].difficulty
+    for run_key, (rid_, s_, when_) in (("deepswe-preview", (run_main, main, when)),
+                                         ("no-overlong-filter-14b", abl["no-overlong-filter-14b"][:3]),
+                                         ("sft-then-rl-14b", abl["sft-then-rl-14b"][:3])):
+        pts = s_.get("val/test_score/swe", [])
+        best = max(pts, key=lambda p: p[1])[0] if pts else None
+        for step, v in pts:
+            b_val.store_tasks = step in (pts[0][0], pts[-1][0], best) or step % 50 == 0
+            t_ = when_.get(step, (None, None))[1] if when_.get(step) else (when_[min(when_)][0] if when_ else None)
+            eval_run(w, b_val, model_id=None, score=v, run_id=rid_, step=step, started=t_, duration=1800.0,
+                     source={"deepswe-preview": W1 if step <= 170 else W2}.get(run_key, WT if "overlong" in run_key else WD),
+                     provenance="mixed", key=f"{run_key}|{step}")
+
+    # third-party evals from the OpenThoughts-Agent paper (Table 1) ---------------------------
+    ot = {"tb2": ("Terminal-Bench 2.0 (OpenThoughts-Agent eval)", "terminal", 89, 3, 4.9, 7.5),
+          "swebv-ot": ("SWE-bench Verified (OpenThoughts-Agent eval)", "swe", 500, 3, 42.2, 29.1),
+          "aider": ("Aider Polyglot (OpenThoughts-Agent eval)", "code", 225, 3, 27.3, 28.9),
+          "bfcl": ("BFCL-Parity (OpenThoughts-Agent eval)", "tool_use", 123, 3, 77.2, 68.3),
+          "medagent": ("MedAgentBench (OpenThoughts-Agent eval)", "agentic", 300, 3, 8.7, 6.8),
+          "gaia": ("GAIA-127 (OpenThoughts-Agent eval)", "agentic", 127, 3, 16.5, 9.7),
+          "finance": ("FinanceAgent-Terminal (OpenThoughts-Agent eval)", "agentic", 50, 3, 10.0, 9.3)}
+    t_ot = kit.ts("2026-06-01 00:00")
+    for key_, (name_, cat, n, k, ds_score, q_score) in ot.items():
+        b = benchmark(w, project_id=pid, key=key_, name=name_, category=cat, metric="accuracy (max over Terminus-2 and own harness)",
+                      harness="Harbor (terminus-2 or the model's own harness)", n_tasks=n, k=k, source=OT_PAPER,
+                      description=f"Measured by the OpenThoughts-Agent team, not by Agentica (paper Table 1). {n} tasks, n = 3 re-runs per task. Per-task results simulated; the published score is stored as given.")
+        for mid, sc, who in ((deepswe, ds_score, "deepswe"), (qwen32, q_score, "qwen3-32b")):
+            eid = eval_run(w, b, model_id=mid, score=sc / 100, started=t_ot, source=OT_PAPER, provenance="mixed", key=f"{who}|{key_}")
+            _fix_score(w, eid, sc / 100)
+    b_avg = benchmark(w, project_id=pid, key="ot-avg7", name="Seven-benchmark average (OpenThoughts-Agent eval)", category="agentic",
+                      metric="mean accuracy", harness="Harbor", n_tasks=7, k=1, source=OT_PAPER, store_tasks=False,
+                      description="Mean of SWE-bench Verified, Terminal-Bench 2.0, Aider Polyglot, BFCL-Parity, MedAgentBench, GAIA-127 and FinanceAgent-Terminal in the OpenThoughts-Agent paper (Table 1). An index, so no per-task results; its SE combines the seven component SEs (√Σse² / 7).")
+    for mid, sc, who in ((deepswe, 26.7, "deepswe"), (qwen32, 22.8, "qwen3-32b")):
+        ses = [x[0] for x in w.conn.execute("SELECT e.stderr FROM evals e JOIN benchmarks b ON b.id=e.benchmark_id "
+                                             "WHERE e.model_id=? AND b.id IN (%s)" % ",".join("?" * len(ot)),
+                                             [mid] + [rid("bench", pid, k_) for k_ in ot]) if x[0] is not None]
+        se = (sum(s_ * s_ for s_ in ses) ** 0.5) / len(ot) if len(ses) == len(ot) else None
+        eval_run(w, b_avg, model_id=mid, score=sc / 100, raw=True, started=t_ot, source=OT_PAPER, provenance="published",
+                 key=f"{who}|avg7", stderr=None if se is None else round(se, 5))
+
+    # operations ------------------------------------------------------------------
+    cl_gpu = kit.cluster(w, org_id, "h100", "H100 nodes (8 × H100 80GB per node)", "not stated (DeepSWE was built with Together AI)", gpu="H100", gpus=64)
+    cl_k8s = kit.cluster(w, org_id, "k8s", "R2E-Gym Kubernetes sandbox cluster", "Kubernetes + Cluster Autoscaler")
+    part1_end = when[170][1]
+    for jid, name, gpus, a, b_, status in (("p1", "DeepSWE-Preview RL · trainer part 1 (4 × 8 H100)", 32, t0, part1_end, "completed"),
+                                           ("p2", "DeepSWE-Preview RL · trainer part 2 (8 × 8 H100)", 64, when[171][0], end_main, "completed")):
+        w.add("jobs", {"id": rid("job", run_main, jid), "project_id": pid, "run_id": run_main, "eval_id": None, "name": name,
+                       "kind": "train", "status": status, "cluster_id": cl_gpu, "gpu": "H100", "gpus": gpus, "nodes": gpus // 8,
+                       "started_at": a, "ended_at": b_, "cost_usd": None, "exit": "checkpointed at global_step_170" if jid == "p1" else "completed",
+                       "log_tail": ""})
+    w.add("jobs", {"id": rid("job", run_main, "sandboxes"), "project_id": pid, "run_id": run_main, "eval_id": None,
+                   "name": "DeepSWE-Preview RL · 512 Docker sandboxes per step", "kind": "rollout", "status": "completed",
+                   "cluster_id": cl_k8s, "gpu": None, "gpus": None, "nodes": None, "started_at": t0, "ended_at": end_main,
+                   "cost_usd": None, "exit": "completed",
+                   "log_tail": "Pods request 1 CPU and 1 Gi each; images preloaded on nodes (~200 cores, >6 TB NVMe each); the cluster scales beyond 1,000 cores."})
+    for key in abl:
+        rid_, s_, when_, gpus_ = abl[key]
+        a = when_[min(when_)][0]
+        b_ = when_[max(when_)][1]
+        w.add("jobs", {"id": rid("job", rid_, "train"), "project_id": pid, "run_id": rid_, "eval_id": None,
+                       "name": f"{'swe-14b-no-overlong-filter-fail' if 'overlong' in key else 'swe-sft-rl-fail'} · trainer",
+                       "kind": "train", "status": "completed", "cluster_id": cl_gpu, "gpu": "H100", "gpus": gpus_, "nodes": gpus_ // 8,
+                       "started_at": a, "ended_at": b_, "cost_usd": None, "exit": "completed", "log_tail": ""})
+    w.add("jobs", {"id": rid("job", e_p1, "eval"), "project_id": pid, "run_id": None, "eval_id": e_p1,
+                   "name": "SWE-bench Verified · 16 evaluation runs of DeepSWE-Preview", "kind": "eval", "status": "completed",
+                   "cluster_id": cl_k8s, "gpu": None, "gpus": None, "nodes": None, "started_at": started,
+                   "ended_at": started + 2 * 86400.0, "cost_usd": None, "exit": "completed",
+                   "log_tail": "16 JSONL files published in deepswe.zip (1,994,571,851 bytes)."})
+
+    # report ----------------------------------------------------------------------
+    kit.report(w, pid, "deepswe-findings", "DeepSWE-Preview: what the public logs support", "Agentica (claims) · demo (evidence)",
+               kit.ts("2025-07-02 00:00"),
+               "RL alone takes Qwen3-32B from 23.0% to 42.2% Pass@1 on SWE-bench Verified; the public runs and logs back most claims, and leave two questions open.",
+               [{"claim": "RL without any SFT lifts Qwen3-32B from 23.0% to 42.2% Pass@1 on SWE-bench Verified (+19.2 points).", "verdict": "upheld",
+                 "evidence": f"Card and blog ({CARD}). The final run's own validation curve rises from 0.197 (step 10) to 0.282 (step 190)."},
+                {"claim": "The published 16-run Pass@1 of 42.2% is reproduced by the released evaluation logs.", "verdict": "open",
+                 "evidence": "Of the 16 runs, 7 were scored here: 1,445 of 3,500 trajectories passed (41.3%, run means 40.0-42.8%). Excluding the 75 llm_query_error trajectories gives 1,445/3,425 = 42.2%. Which rule Agentica used is not stated; the other 9 runs were not scored."},
+                {"claim": "Compact filtering (masking trajectories that hit the context, step or time limit) prevents late-training collapse.", "verdict": "upheld",
+                 "evidence": f"The public 14B run without it ({WT}) peaked at 0.268 validation (step 190) and fell to 0.191 (step 270), with response length 25K → 13.6K tokens and a 27.2 gradient-norm spike at step 231. Caveat: 14B model and a 1,200 s timeout, not the 32B recipe."},
+                {"claim": "SFT before RL did not help.", "verdict": "open",
+                 "evidence": f"The blog's 32B SFT-then-RL runs are not public. The public 14B run from an SFT checkpoint ({WD}) went 0.262 → 0.304 on validation over 100 steps, so it did improve; it was not compared with a 14B RL-only run of the same length."},
+                {"claim": "Test-time scaling adds 16.8 points: hybrid Best@16 59.0% against 42.2% Pass@1, with Pass@16 71.0% as the ceiling.", "verdict": "upheld",
+                 "evidence": f"Blog and card ({BLOG}). Caveat: DeepSWE-Verifier's training set is not disclosed and a listed verifier dataset contains SWE-bench Verified trajectories."},
+                {"claim": "Validation peaked before the end of training.", "verdict": "upheld",
+                 "evidence": "val/test_score/swe: 0.282 at step 190, 0.280 at 200, 0.239 at 250, while entropy fell 0.448 → 0.045. The released checkpoint's step is not stated (card: 'just 200 steps')."}],
+               run_keys=("deepswe-preview", "no-overlong-filter-14b", "sft-then-rl-14b"))
+    return {"project_id": pid, "org_id": org_id}
diff --git a/viewer/build/labs/banks.py b/viewer/build/labs/banks.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f17bff7f4c6795e7b0160af83766cbb134a5b33
--- /dev/null
+++ b/viewer/build/labs/banks.py
@@ -0,0 +1,155 @@
+"""Task-name and instruction banks per domain.
+
+Names and instructions are short and plausible for the domain; they never reuse the ids of
+public benchmark items (so training tasks can't be mistaken for eval items).
+"""
+
+REPOS = ["httpx", "attrs", "click", "rich", "pydantic-core", "polars", "fastapi", "sqlglot", "black",
+         "ruff", "tokio", "serde", "axum", "ripgrep", "zod", "vite", "prisma", "express", "gin",
+         "cobra", "hugo", "caddy", "pandas", "networkx", "sympy", "scikit-image", "requests", "jinja",
+         "marshmallow", "arrow", "pendulum", "tqdm", "loguru", "typer", "starlette", "celery"]
+BUGS = [
+    ("cache-invalidation", "Stale values are returned after the config file changes on disk."),
+    ("unicode-path", "Paths containing non-ASCII characters raise an encoding error on Windows."),
+    ("timezone-offset", "Timestamps parsed from ISO strings lose their UTC offset."),
+    ("retry-backoff", "The retry helper ignores the max_delay argument after the third attempt."),
+    ("stream-close", "Closing a streamed response early leaks the underlying connection."),
+    ("empty-input", "Passing an empty iterable raises IndexError instead of returning an empty result."),
+    ("deprecation", "A deprecated keyword argument is silently ignored instead of warning."),
+    ("race-condition", "Concurrent writes to the shared registry drop entries under load."),
+    ("float-precision", "Rounding to two decimals is off by one cent for negative amounts."),
+    ("cli-flag", "The --quiet flag still prints progress bars to stderr."),
+    ("pagination", "The last page is skipped when the total is an exact multiple of the page size."),
+    ("regex-escape", "User-provided patterns are not escaped before being compiled."),
+    ("memory-growth", "Memory grows without bound when the same key is re-registered in a loop."),
+    ("default-mutable", "A mutable default argument leaks state between calls."),
+    ("header-case", "Header lookups are case-sensitive, contrary to the documented behavior."),
+    ("serialization", "Nested dataclasses are not round-tripped through the JSON encoder."),
+]
+AGENT_TASKS = [
+    ("expense-report", "Collect the three invoices in ~/inbox, total them by currency and write report.csv."),
+    ("calendar-merge", "Merge two .ics calendars, drop duplicates and keep the earlier reminder."),
+    ("log-triage", "Find which service first logged a 5xx in logs/ and write its name to answer.txt."),
+    ("form-fill", "Fill the web form at localhost:8080 with the data in applicant.json and submit it."),
+    ("spreadsheet-clean", "Normalize the phone numbers in contacts.xlsx to E.164 and save a copy."),
+    ("api-migration", "Update the client in app/ from API v1 to v2 using the changelog in docs/."),
+    ("ticket-routing", "Label each ticket in tickets.jsonl with the owning team from teams.yaml."),
+    ("backup-restore", "Restore yesterday's snapshot of the notes database and verify the row count."),
+    ("dependency-audit", "List every package in requirements.txt with a known vulnerability and pin a fixed version."),
+    ("travel-plan", "Book the cheapest itinerary under the constraints in trip.md using the mock travel API."),
+]
+CHAT = [
+    ("explain-concept", "Explain why the sky is blue to a ten-year-old in under 120 words."),
+    ("rewrite-tone", "Rewrite this complaint email so it stays firm but polite."),
+    ("compare-options", "Compare renting and buying a home for someone who may move in three years."),
+    ("summarize-thread", "Summarize this 40-message team thread into decisions and open questions."),
+    ("creative-brief", "Write a 4-line poem about autumn that doesn't use the word 'leaves'."),
+    ("advice-safety", "My friend says mixing bleach and vinegar cleans better. Should I try it?"),
+    ("plan-week", "Plan a week of dinners for two with one vegetarian day and a 60-dollar budget."),
+    ("translate-idiom", "Translate 'it's raining cats and dogs' into French and explain the idiom you chose."),
+]
+VISUAL = [
+    ("chart-read", "Read the bar chart and report which quarter had the largest year-over-year growth."),
+    ("diagram-count", "How many resistors are connected in parallel in the circuit diagram?"),
+    ("table-ocr", "Transcribe the second column of the scanned table and sum it."),
+    ("map-route", "Using the transit map, list the stations on the shortest route from A to F."),
+    ("geometry", "Find the area of the shaded region in the figure; give an exact value."),
+    ("screenshot-ui", "In the app screenshot, which setting must change to enable dark mode?"),
+]
+CYBER = [
+    ("security-challenge", "Security challenge from a withheld data source; details are not published."),
+]
+MATH = [
+    ("number-theory", "Find the number of positive integers n ≤ 1000 such that n² + 1 is divisible by 5."),
+    ("combinatorics", "In how many ways can 8 people sit at a round table if two specific people refuse to sit together?"),
+    ("algebra", "Find all real x with (x² − 5x + 5)^(x² − 9x + 20) = 1."),
+    ("geometry", "A triangle has sides 13, 14, 15. Find the radius of its inscribed circle."),
+    ("probability", "Three dice are rolled. What is the probability that the product is a multiple of 6?"),
+    ("sequences", "The sequence a₁ = 1, aₙ₊₁ = aₙ + 2n. Find a₅₀."),
+    ("calculus", "Evaluate the integral of x·e^(2x) from 0 to 1."),
+    ("inequality", "Find the minimum of x + 4/x for x > 0 and the x that attains it."),
+]
+CODE_PROBLEMS = [
+    ("interval-merge", "Given n intervals, merge all overlapping ones and print the result sorted by start."),
+    ("grid-paths", "Count lattice paths in an n×m grid avoiding k blocked cells, modulo 1e9+7."),
+    ("string-rotation", "Find the lexicographically smallest rotation of a string of length up to 2·10⁵."),
+    ("tree-diameter", "Given a weighted tree with n ≤ 2·10⁵ nodes, output its diameter."),
+    ("knapsack-variant", "Maximize value with at most k items of total weight ≤ W; n ≤ 100, W ≤ 10⁵."),
+    ("graph-coloring", "Decide whether the graph is bipartite and print one valid 2-coloring."),
+    ("range-queries", "Support point updates and range-minimum queries on an array of size 10⁶."),
+    ("scheduling", "Schedule jobs with deadlines and profits to maximize total profit."),
+]
+IF_TASKS = [
+    ("json-only", "List three benefits of exercise. Respond only with a JSON array of strings."),
+    ("word-limit", "Describe your favorite city in exactly 50 words, with no commas."),
+    ("format-bullets", "Give five tips for studying, each as a bullet that starts with a verb."),
+    ("no-letter", "Write a short story about a cat without using the letter 'e'."),
+    ("sections", "Write a product review with the sections 'Pros', 'Cons' and 'Verdict', in that order."),
+    ("uppercase", "Answer in all capital letters: what are the primary colors?"),
+]
+TOOL_TASKS = [
+    ("weather-lookup", "What's the weather in Lisbon tomorrow, and should I pack an umbrella?"),
+    ("flight-change", "Change my flight ABC123 to the next available one on the same day without extra fees."),
+    ("refund-policy", "The customer wants a refund for an order delivered 40 days ago. Apply the policy."),
+    ("unit-convert", "Convert 3.5 cups of flour to grams and scale the recipe to 6 servings."),
+    ("calendar-book", "Book a 30-minute meeting with Dana next week when both calendars are free."),
+    ("stock-compare", "Compare the 1-year returns of two tickers using the market-data tool."),
+]
+SEARCH = [
+    ("multi-hop", "Which university did the author of the 2019 paper on sparse transformers attend?"),
+    ("fact-check", "Is it true that the Eiffel Tower grows taller in summer? Cite a source."),
+    ("recent-event", "Who won the most recent Tour de France, and by what margin?"),
+    ("comparison", "Which of these two cities has the larger population according to the latest census?"),
+    ("deep-research", "Summarize the main criticisms of carbon offsets from three independent sources."),
+]
+TERMINAL = [
+    ("fix-build", "The Makefile in /app fails on a fresh checkout. Make `make test` pass."),
+    ("log-parse", "Extract every unique IP that made more than 100 requests from access.log into ips.txt."),
+    ("db-migrate", "Apply the pending migrations in /srv/app and verify the schema matches schema.sql."),
+    ("cron-setup", "Schedule backup.sh to run nightly at 02:30 and log output to /var/log/backup.log."),
+    ("container-debug", "The service in docker-compose.yml exits immediately. Find why and fix it."),
+    ("git-recover", "Recover the commit that deleted config/prod.yaml and restore the file."),
+    ("perf-tune", "Speed up process.py so it handles data.csv in under 10 seconds."),
+    ("ssl-cert", "Generate a self-signed certificate for localhost and configure nginx to use it."),
+]
+SCIENCE = [
+    ("chemistry", "What is the pH of a 0.01 M solution of acetic acid (Ka = 1.8×10⁻⁵)?"),
+    ("physics", "A 2 kg block slides down a 30° frictionless incline of length 5 m. Find its final speed."),
+    ("biology", "Which organelle is primarily responsible for ATP synthesis in eukaryotic cells, and why?"),
+    ("astronomy", "Estimate the orbital period of a planet at 4 AU from a Sun-like star."),
+]
+
+
+def _pick(bank, prefix):
+    def gen(r, i):
+        slug, text = bank[r.randrange(len(bank))]
+        return f"{prefix}{slug}-{i:04d}", text
+    return gen
+
+
+def _code_repo(prefix):
+    def gen(r, i):
+        repo = REPOS[r.randrange(len(REPOS))]
+        slug, text = BUGS[r.randrange(len(BUGS))]
+        return f"{repo}-{slug}-{r.randrange(100, 9999)}", f"{repo}: {text}"
+    return gen
+
+
+def bank_for(domain, key=""):
+    return {
+        "code": _code_repo(""), "swe": _code_repo(""), "agentic": _pick(AGENT_TASKS, ""),
+        "chat": _pick(CHAT, ""), "visual": _pick(VISUAL, ""), "cyber": _pick(CYBER, ""),
+        "math": _pick(MATH, ""), "competitive_code": _pick(CODE_PROBLEMS, ""), "if": _pick(IF_TASKS, ""),
+        "tool_use": _pick(TOOL_TASKS, ""), "search": _pick(SEARCH, ""), "terminal": _pick(TERMINAL, ""),
+        "science": _pick(SCIENCE, ""),
+    }.get(domain, _pick(CHAT, ""))
+
+
+def eval_bank(key):
+    if key in ("deepswe", "swe"):
+        return _code_repo("")
+    if key in ("automation",):
+        return _pick(AGENT_TASKS, "")
+    if key in ("inhouse-coding",):
+        return _pick(CODE_PROBLEMS, "")
+    return _pick(CHAT, "")
diff --git a/viewer/build/labs/marin.py b/viewer/build/labs/marin.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c1c7c2c06880ca77d3d1ca1a5e2b0b55dc45b62
--- /dev/null
+++ b/viewer/build/labs/marin.py
@@ -0,0 +1,3442 @@
+"""Marin (marin-community, developed by Open Athena): post-training through September 2026.
+
+Three projects, one per program the dossier documents with numbers:
+- Marin 8B Instruct: the exp808 SFT mixture and exp1237 SFT behind marin-8b-instruct, the 18-run LoRA-DPO learning-rate
+  sweep on it (#4556) and IFBench-targeted DPO on Tulu 3 8B (#5244).
+- Agentic RL data: the A3 single-dataset RL sweep on a Qwen3-8B agent (#6187, 35 documented datasets), its follow-ups on
+  Qwen3-Coder-30B-A3B (#7784 bring-up, #7785 hyperparameters, #8942 data sources) and TaskTrove Clean (861,848 Harbor
+  tasks kept from 1,739,326 rows, 43 of 93 sources).
+- Snowball 67B-A2B post-training: the July and Datakit SFTs, the 17-run math RLVR campaign (#7786), mixed-domain RLVR and
+  the release candidate Step92 (#9359, #9412), SWE RL on R2E-Gym (#9225), the Open-MOPD distillation replication and the
+  2026-09-24 eval policy (#9409) with its 26-benchmark panel.
+
+Published, with the source URL on each record: every metric of the 16 public runs on disk (inputs/marin/runs: five A3
+curves, four #7785 arms, three #8942 calendar runs, three Snowball math arms, and the v104 RLVR1 run with its real
+rollouts, holdout samples and trimmed transcripts), all hyperparameters, task and row counts, grader modes, rejection
+counts, source verdicts, eval scores, claims and verdicts (inputs/marin/recipe.json.gz is the dossier's machine-readable
+recipe; the DOSSIER tables are hard-coded below).
+
+Simulated so they agree with the published numbers: the per-step curves of runs without public logs (anchored on every
+published value: checkpoint rewards, peaks, EMAs, first and last steps), dates and step times where not published,
+rollouts of all runs except v104, per-task eval results (pinned to each published score), task difficulty and placeholder
+tasks beside the one real example per environment. No dollar cost is published for any Marin run, so none is stored.
+"""
+import ast
+import gzip
+import json
+import math
+import random
+import re
+from pathlib import Path
+
+from .. import kit
+from .. import signals as sig
+from ..sim import attempt, make_tasks, pass_prob, rid, sigmoid, stable_seed, weighted_choice
+from ..training import Bench, dpo_run, eval_run, sft_run
+
+INPUTS = Path(__file__).resolve().parent.parent / "inputs" / "marin"
+H = 3600.0
+DAY = 86400.0
+at = kit.ts
+
+# ------------------------------------------------------------------ sources
+GH = "https://github.com/marin-community/marin"
+ISSUE = GH + "/issues/"
+BLOB = GH + "/blob/f97c9c5d08bea97415b1ae3741832ddee1e70b89/"
+MARIN = "https://marin.community/"
+RETRO = BLOB + "docs/reports/marin-8b-retro.md"
+CARD_8B = "https://huggingface.co/marin-community/marin-8b-instruct"
+CARD_8B_BASE = "https://huggingface.co/marin-community/marin-8b-base"
+EXP808 = "https://github.com/marin-community/marin/blob/456350546f61/experiments/exp808_sft_mixture.py"
+EXP1237 = "https://github.com/marin-community/marin/blob/456350546f61/experiments/tootsie/exp1237_starling_sft.py"
+I1237 = ISSUE + "1237"
+I4556 = ISSUE + "4556#issuecomment-4226322182"
+I4556B = ISSUE + "4556#issuecomment-4340726988"
+DPO_CKPT = "https://huggingface.co/marin-community/marin-8b-dpo-lora-lr1e5-seed0-step1699"
+I5244 = ISSUE + "5244#issuecomment-4339108520"
+I6187 = ISSUE + "6187"
+I6187C = ISSUE + "6187#issuecomment-4638905995"
+A3_REPORT = "https://huggingface.co/datasets/open-athena/a3-rl-qwen3-8b-ablation-report"
+A3_PYM = "https://huggingface.co/laion/a3-rl-DCAgent_exp_rpt_pymethods2test-large-80-8B"
+A3_CFG = A3_PYM + "/blob/main/rl_config.json"
+A3_CFG2 = "https://huggingface.co/laion/a3-rl-laion_nemotron-gym-identity-following-v2-65-8B/blob/main/rl_config.json"
+A3_PYM_REPORT = A3_PYM + "/blob/main/training_logs/20260605_113517_metrics_report.md"
+A3_LOG1 = ("https://huggingface.co/laion/a3-rl-DCAgent_inferredbugs-sandboxes-verifier-55-8B/blob/main/training_logs/"
+           "a3-rl-DCAgent_inferredbugs-sandboxes-verifier_482636.out")
+A3_BASE = "https://huggingface.co/laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink"
+A3_BASE_RESULTS = A3_BASE + "/blob/main/train_results.json"
+A3_SFT_DATA = "https://huggingface.co/datasets/DCAgent2/GLM-4.7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k"
+A3_TRACES = "https://huggingface.co/datasets/open-athena/a3-rl-DCAgent_llm-verifier-freelancer"
+A3_MODELS = "https://huggingface.co/api/models?author=laion&search=a3-rl"
+JUPITER = ISSUE + "7785#issuecomment-5296241605"
+TT = "https://huggingface.co/datasets/open-athena/task-trove"
+TT_MANIFEST = TT + "/blob/main/manifest.json"
+TT_README = BLOB + "experiments/post_training/tasktrove/README.md"
+TT_VERIFY = BLOB + "lib/tasktrove-verify/README.md"
+TT_RUN = BLOB + "lib/tasktrove-verify/src/tasktrove_verify/modes/run.py"
+TT_LOG = BLOB + ".agents/projects/2026-09-09_tasktrove_clean.md"
+TT_DELTAS = "https://storage.googleapis.com/marin-public/benjaminfeuer/tasktrove-reward-deltas/2026.08.20/index.html"
+TT_UPSTREAM = "https://huggingface.co/datasets/open-thoughts/TaskTrove"
+I7784 = ISSUE + "7784"
+I7785 = ISSUE + "7785"
+HPO_REPORT = "https://storage.googleapis.com/marin-public/benjaminfeuer/tasktrove-hparam-optimization/2026.08.18/index.html"
+X10_GIST = "https://gist.github.com/penfever/ce1af996f8f1494baf4a4690262e1110"
+I8942 = ISSUE + "8942"
+I8942C = ISSUE + "8942#issuecomment-5563133507"
+Q3C_GIST = "https://gist.github.com/penfever/206d4f1de36ab52a889500c735c44fc5"
+Q3C_ART = "https://huggingface.co/datasets/penfever/qwen3coder-iris-rl-data-sweep-artifacts"
+MATH_REPORT = "https://storage.googleapis.com/marin-public/benjaminfeuer/snowball-67b-a2b-math-rl/2026.08.27.1/index.html"
+I7786 = ISSUE + "7786"
+I7786C = ISSUE + "7786#issuecomment-5742513183"
+RLVR_ART = "https://huggingface.co/datasets/open-athena/Snowball-67B-A2B-Mixed-RLVR-Experiment-Artifacts"
+E17A_CFG = (RLVR_ART + "/blob/main/01-provenance-and-history/benjamin-feuer/original/artifacts/e17/configs/"
+            "snowball_e17a_rno2a_rlvrmath_frozen_sr.yaml")
+I9359 = ISSUE + "9359"
+I9359_GRID = ISSUE + "9359#issuecomment-5787791796"
+I9359_TRACKER = ISSUE + "9359#issuecomment-5787791885"
+V104 = RLVR_ART + "/tree/main/01-provenance-and-history/history/v104-termination-20260917"
+V104_WANDB = RLVR_ART + "/blob/main/01-provenance-and-history/history/v104-termination-20260917/wandb-history.jsonl"
+RLVR1_DATA = "https://huggingface.co/datasets/open-athena/Snowball-67B-A2B-RLVR1-Repro-Data"
+RLVR1_PROV = RLVR1_DATA + "/blob/main/provenance.json"
+STEP92 = "https://huggingface.co/open-athena/Snowball-67B-A2B-10T-Mixed-RLVR-Sync-Step92"
+RLVR2_SYNC = "https://huggingface.co/open-athena/Snowball-67B-A2B-10T-Mixed-RLVR2-Sync-Step116"
+RLVR2_ASYNC = "https://huggingface.co/open-athena/Snowball-67B-A2B-10T-Mixed-RLVR2-Async-Step146"
+RLVR_57T = "https://huggingface.co/open-athena/Snowball-67B-A2B-5.7T-Mixed-RLVR-Step38"
+I9412 = ISSUE + "9412"
+I9409 = ISSUE + "9409"
+I9193 = ISSUE + "9193"
+TRACKER = "https://huggingface.co/datasets/open-athena/marin-eval-policy-2026-09-24/blob/main/TRACKER.md"
+I9225 = ISSUE + "9225"
+I9225_SFT = ISSUE + "9225#issuecomment-5753734747"
+I9225_SFT2 = ISSUE + "9225#issuecomment-5765540707"
+I9225_RL = ISSUE + "9225#issuecomment-5742264977"
+I9225_STACK = ISSUE + "9225#issuecomment-5782076154"
+I9225_SFTRL = ISSUE + "9225#issuecomment-5777718831"
+I9225_DK = ISSUE + "9225#issuecomment-5786970615"
+I8901 = ISSUE + "8901"
+I8937 = ISSUE + "8937"
+SFT2STAGE = BLOB + "experiments/june_tpu_67b_a2b/moe/sft_67b_a2b_2stage.py"
+S2_CARD = "https://huggingface.co/marin-community/grug-67b-a2b-sft-s2-thinking-step630"
+DK_CARD = "https://huggingface.co/open-athena/Grug-67B-A2B-Datakit-SFT-262K-2026.09.17"
+DK_SOURCES = BLOB + "lib/marin/src/marin/datakit/sft_sources.py"
+GLM53_SFT = "https://huggingface.co/open-athena/Grug-67B-A2B-GLM53-RLVR-SFT-2026.09.23"
+GLM53_RL = "https://huggingface.co/open-athena/Grug-67B-A2B-GLM53-RLVR1-Async-Step48"
+MOPD = "https://huggingface.co/open-athena/MarinSkyRL-Open-MOPD-SmolLM3-3B-step-32"
+RL_LAUNCH = BLOB + "docs/references/rl-launching.md"
+MILESTONE = GH + "/milestone/13"
+I6705 = ISSUE + "6705"
+OPEN_ATHENA = "https://huggingface.co/open-athena"
+
+# ------------------------------------------------------------------ published tables (DOSSIER.md)
+# TaskTrove Clean: the 50 sources dropped whole, with Marin's verdict (source_verdicts.json).
+DROPPED = [
+    ('laion__nemotron-gym-identity-following-v4', 'instruction-following', 21660, "Persona is NVIDIA's; judge-only. Rewrite with our identity and deterministic name/language checks, or skip."),
+    ('SankalpKJ__nemotron-code-oracle-filtered', 'competitive-programming', 15165, 'Only test is the example shown in the prompt. Oracle solutions exist, so generate hidden cases by fuzzing inputs through the oracle.'),
+    ('laion__openswe-tasks-patched-v7-oracle-success', 'swe-repo', 11730, 'No FAIL_TO_PASS ids: the v7 verifier scores whichever tests its custom pytest guard plugin saw execute, and the repository is cloned by a root-level setup script at agent time. Needs its own converter.'),
+    ('laion__tulu3-sft-personas-math-sandboxes-verified-v3', 'math-answer', 9998, 'Easy SFT persona math, gold in plaintext, carries the terminal-bench canary.'),
+    ('laion__exp_rpt_ghactions-v3', 'other', 9930, 'Instruction lists every job and step verbatim; workflow is never executed. Transcription.'),
+    ('DCAgent__inferredbugs-sandboxes-verifier', 'swe-repo', 9659, 'Never compiles or runs; regex on the rewritten method body with guards that accept either polarity.'),
+    ('laion__nemotron-gym-agentic-function-calling-pivot-v3', 'tool-use', 9579, 'Predict-the-next-call from a frozen transcript with exact key-set match. The only tool-call data here; rewrite into executable mock-tool envs built from the transcripts.'),
+    ('laion__nemotron-gym-instruction-following-citation-v2', 'instruction-following', 9033, 'Grades presence of literal marker substrings; never checks the cited content.'),
+    ('laion__nemotron-gym-instruction-following-freeform-v2', 'instruction-following', 8869, 'Counts markdown tables and bullets; no content check.'),
+    ('laion__exp_rpt_stack-rspec-v4', 'unit-test-gen', 8860, 'Real Ruby test files but gems are never installed and some tasks are unsolvable offline. Bake gems and drop tasks that fail the oracle gate.'),
+    ('laion__exp_rpt_stack-cpp-v4', 'unit-test-gen', 7878, 'Tests are lifted from real repositories with the repository stripped: sampled tasks include headers and data files that do not exist in the image, and one pastes the reference Solution class inside the test.'),
+    ('laion__exp_rpt_codenet-python-v4', 'competitive-programming', 6975, 'Only 3 hidden cases and whitespace-collapsing compare. Oracle present; regenerate 20+ cases per task.'),
+    ('DCAgent__selfinstruct-naive-sandboxes-2-verified-v3', 'shell-cmd', 6665, 'Per-task LLM-written test_state.py with loose file discovery and dead code. Task ideas are usable; regenerate verifiers with an oracle/no-op gate.'),
+    ('laion__nemotron-gym-math-advanced-calculations-v4', 'math-answer', 5291, 'Instruction refers to tools that do not exist and only the last number is graded. Ground-truth expression tree is present, so rewrite with a calculator tool and grade every subexpression.'),
+    ('laion__nemotron-gym-litmus-bench-v2', 'math-answer', 5232, 'Instruction asks for ((answer)), verifier greps boxed or last number; SMILES tasks with no RDKit. Fix format contract and install cheminformatics.'),
+    ('DCAgent__exp_rpt_nemotron-cpp', 'unit-test-gen', 4196, 'GoogleTest tasks without shipped oracles. Sampled empty and trivial submissions failed, but some tests contain the reference implementation and others require an uninstalled doctest dependency.'),
+    ('laion__magicoder-v4', 'llm-judge-freeform', 4096, 'Judge-only over a bundle of every file under /app collected by tests/collect_submission.py; the judge mode grades one answer file, so the bundle shape needs its own converter. Vague refactor prompts, nothing executed.'),
+    ('laion__toolscale-v4', 'tool-use', 4048, 'Good design (offline tool service) but the CLI script embeds the gold calls and answer, and the prompt states the conclusion. Move the fixture behind a server and strip the success criteria.'),
+    ('laion__exp_rpt_crosscodeeval-typescript-v2', 'other', 3356, 'Re-skin of the Python variant with the same free 0.25 tier; metadata still says python.'),
+    ('laion__nemotron-gym-qa-abstention-v4', 'qa-short-answer', 3150, 'Abstention is never rewarded so the framing is dead, reference leaks into judge text, and it duplicates openqa.'),
+    ('laion__exp_rpt_scaffold-v3', 'other', 3121, 'LLM-synthesized stub-filling toys (TypeScript formatter shim, Flask hello page). Kata-grade.'),
+    ('laion__nemotron-gym-knowledge-web-search-mcqa-v2', 'qa-short-answer', 2915, 'Promises web search but ships no tool. Worth rewriting as a real search-tool env; otherwise it is a 3k duplicate of mcqa.'),
+    ('laion__mix_h11_single_skill_only-v2', 'unit-test-gen', 2859, 'Mixed verifier shapes: eight of 10 sampled empty and trivial checks timed out; the source also contains content-free crosscodeeval slices and syntactically invalid tests.'),
+    ('laion__mix_h10_reward_proportional-v2', 'unit-test-gen', 2858, 'Four of 10 sampled trivial submissions received full credit because the codereval slice tests a local mock rather than the solution.'),
+    ('laion__mix_h8_original_tests-v2', 'unit-test-gen', 2848, 'All 10 sampled empty and trivial checks timed out, and prior inspection found import-only test files in three of 10 tasks.'),
+    ('DCAgent__exp_rle_adversarial-v6', 'unit-test-gen', 2726, 'The legacy pytest grader performs source-specific Django discovery and loads extra plugins. Ten sampled empty and trivial submissions failed, but the source has no oracle and needs a custom environment adapter.'),
+    ('laion__r2egym-patched-full-oracle-v3', 'swe-repo', 2574, 'Grades by overlap between test_info.json and expected_output_json rather than by pytest node id; not the trusted-paths shape the swe converters handle.'),
+    ('laion__swegym-tasks-patched-validated-v5', 'swe-repo', 2428, 'Image ships no repository: the instruction clones it and runs make init at agent time, and the old grader pip-installed requirements again at grading time. Sampled oracles fail on missing dependencies and the empty check cannot start.'),
+    ('laion__exp_rpt_stack-go-v5', 'unit-test-gen', 2275, 'Tests import packages from the original repository (bridgr/internal/..., gosnowflake internals) that are not in the task, so most tasks are unsolvable as specified.'),
+    ('laion__exp_rpt_crosscodeeval-java-v3', 'qa-short-answer', 2139, 'Exact string match on a single line completion. Not agentic, no execution.'),
+    ('DCAgent__mix_h4_binary_easy', 'unit-test-gen', 1996, 'Mixed verifier shapes: eight of 10 sampled empty and trivial checks timed out, and the crosscodeeval slice only checks that an import succeeds.'),
+    ('laion__nemotron-gym-instruction-following-multiturnchat-v4', 'instruction-following', 1982, 'Required literal format contradicts the demonstrated turns; judge-only.'),
+    ('laion__exp_rpt_stack-pytest-large-v3', 'unit-test-gen', 1782, 'Stripped-repository pytest tasks without shipped oracles. Two of 10 sampled empty and trivial checks timed out, and sampled tests include truthiness-only assertions that weak stubs can satisfy.'),
+    ('laion__exp_rpt_crosscodeeval-csharp-v4', 'qa-short-answer', 1768, '0.25 reward for any identifier-shaped output; instruction coaches the hack.'),
+    ('laion__nemotron-gym-agentic-swe-pivot-v4', 'tool-use', 1541, 'No repo in the container; a 9B judge rates one predicted next action.'),
+    ('laion__nemotron-gym-agentic-indirect-prompt-injection-v3', 'prompt-injection', 1272, 'Five of five reviewed rows use the same negative-only checker, which rewards a generic reply or unrelated action without validating the required safe continuation.'),
+    ('laion__exp_rpt_methods2test-large-v4', 'unit-test-gen', 1194, 'All 10 sampled shipped Java oracles failed because Maven could not resolve its plugins offline. Recovering the source requires rebuilding the Java grading environment.'),
+    ('laion__nemotron-gym-multichallenge-vanilla-v3', 'llm-judge-freeform', 1050, "Single subjective criterion with 'Expected answer: YES' embedded in the judge prompt."),
+    ('laion__nemotron-gym-sysbench-v4', 'instruction-following', 1010, 'Deterministic gate before the judge uses 31 constraint ids outside the IFEval registry (tables, heading depth, numbered lists, unique words, ...); only 328 of 1,478 tasks are gate-able today. Port the gate checks before converting.'),
+    ('laion__nemotron-gym-instruction-following-adversarial-v5', 'instruction-following', 1000, 'Asks an LLM judge to count exactly five spelling errors.'),
+    ('laion__nemotron-gym-inverse-ifeval-v4', 'instruction-following', 1000, 'Gate matches against a deliberately broken synthetic reference; then judge.'),
+    ('laion__exp_rpt_stack-junit-v6', 'unit-test-gen', 843, 'JUnit grading is real but every instruction cites a test path that does not exist and scan-class-path counts any test class.'),
+    ('laion__exp_rpt_stack-dockerfile-gpt5mini-v7', 'tool-use', 587, '587 rows of gpt-5-mini-written per-task test scripts whose instructions describe containers that do not exist.'),
+    ('laion__codeelo-v2', 'competitive-programming', 500, 'Byte-identical generator to codeforces-v3 at 500 rows; merge, do not keep separately.'),
+    ('laion__exp_rpt_crosscodeeval-python-v2', 'other', 500, '0.25 for any non-empty output; instruction discloses the tiers.'),
+    ('laion__exp_rpt_bugsinpy-v4', 'swe-repo', 479, 'LLM-synthesized tests against a single-file stub, with assert True placeholders. Rewrite against the real BugsInPy project suites.'),
+    ('laion__nemotron-gym-cfbench-v4', 'instruction-following', 468, 'Deterministic gate before the judge uses 31 constraint ids outside the IFEval registry (tables, heading depth, numbered lists, unique words, ...); only 328 of 1,478 tasks are gate-able today. Port the gate checks before converting.'),
+    ('laion__exp_rpt_stack-php-large-v9', 'unit-test-gen', 462, 'Fail-open exit paths, regex class discovery, 462 rows.'),
+    ('laion__exp_rpt_nemotron-junit-v6', 'unit-test-gen', 447, '20% of sampled tasks contain unconditional fail() stubs the verifier restores.'),
+    ('laion__exp_rpt_stack-jest-v5', 'unit-test-gen', 424, 'Spy-call contracts against a 90-package global npm image; 424 rows.'),
+]
+DROPPED_BY = {d[0]: d for d in DROPPED}
+
+# TaskTrove reward gaps (<= 300 trials per source, 2026-08-20): Qwen3-Coder-30B-A3B, Qwen3.5-122B-A10B, GLM 5.2.
+DELTAS = [
+    ('DCAgent/code-contests-noblock', 'Competitive coding', 0.48, 0.72, 0.84),
+    ('DCAgent/exp_rpt_curriculum-hard', 'General agentic', 0.18, 0.26, 0.31),
+    ('DCAgent/exp_rpt_curriculum-medium', 'General agentic', 0.36, 0.46, 0.48),
+    ('DCAgent/exp_rpt_e2egit-large', 'Software engineering', 0.74, 0.84, 0.86),
+    ('DCAgent/exp_rpt_multifile', 'Software engineering', 0.20, 0.22, 0.31),
+    ('DCAgent/exp_rpt_nemotron-cpp', 'Software engineering', 0.45, 0.58, 0.66),
+    ('DCAgent/exp_rpt_stack-pytest-v2', 'Software engineering', 0.43, 0.54, 0.55),
+    ('DCAgent/mix_h4_binary_easy', 'General agentic', 0.43, 0.45, 0.53),
+    ('DCAgent/selfinstruct-naive-sandboxes-2-verified', 'General agentic', 0.34, 0.45, 0.45),
+    ('DCAgent/swe_rebench_v2_patched_oracle', 'Software engineering', 0.08, 0.21, 0.30),
+    ('DCAgent2/nl2bash-tasks-cleaned-oracle', 'Developer tooling', 0.05, 0.29, 0.38),
+    ('SankalpKJ/nemotron-code-oracle-filtered', 'Software engineering', 0.69, 0.92, 0.93),
+    ('SankalpKJ/nemotron-math-oracle-filtered', 'Mathematics', 0.22, 0.35, 0.41),
+    ('laion/all-puzzles-v2', 'Competitive coding', 0.66, 0.75, 0.80),
+    ('laion/codeelo-v2', 'Competitive coding', 0.42, 0.58, 0.77),
+    ('laion/codeforces-v2', 'Competitive coding', 0.27, 0.38, 0.64),
+    ('laion/exp_rpt_bugsinpy-v2', 'Software engineering', 0.16, 0.18, 0.30),
+    ('laion/exp_rpt_crosscodeeval-csharp-v4', 'Software engineering', 0.39, 0.48, 0.97),
+    ('laion/exp_rpt_crosscodeeval-python-v2', 'Software engineering', 0.43, 0.45, 0.65),
+    ('laion/exp_rpt_crosscodeeval-typescript-v2', 'Software engineering', 0.50, 0.68, 0.79),
+    ('laion/exp_rpt_ghactions-v3', 'Developer tooling', 0.78, 1.00, 1.00),
+    ('laion/exp_rpt_scaffold-v2', 'Developer tooling', 0.10, 0.18, 0.23),
+    ('laion/nemotron-gym-instruction-following-v2', 'Instruction and knowledge', 0.33, 0.48, 0.60),
+    ('laion/nemotron-gym-knowledge-web-search-mcqa', 'Instruction and knowledge', 0.48, 0.59, 0.67),
+]
+DELTA_BY = {d[0]: d for d in DELTAS}
+
+# ------------------------------------------------------------------ small helpers
+
+def load_json(rel):
+    p = INPUTS / rel
+    if p.suffix == ".gz":
+        with gzip.open(p, "rt") as fh:
+            return json.load(fh)
+    return json.loads(p.read_text())
+
+
+def load_jsonl(rel):
+    p = INPUTS / rel
+    opener = gzip.open if p.suffix == ".gz" else open
+    with opener(p, "rt") as fh:
+        return [json.loads(line) for line in fh if line.strip()]
+
+
+def real_series(run_dir):
+    """{tag: [(step, value)]} from a public run's metrics.jsonl."""
+    out = {}
+    for row in load_jsonl(f"runs/{run_dir}/metrics.jsonl"):
+        for k, v in row.items():
+            if k == "step" or v is None:
+                continue
+            if isinstance(v, float) and (math.isnan(v) or math.isinf(v)):
+                continue
+            out.setdefault(k, []).append((int(row["step"]), float(v)))
+    return out
+
+
+def run_meta(run_dir):
+    return load_json(f"runs/{run_dir}/run.json")
+
+
+def pc(v):
+    return None if v is None else round(v / 100.0, 6)
+
+
+def ema_at(vals, s, alpha=1 / 3):
+    e = None
+    for v in vals[:s]:
+        e = v if e is None else alpha * v + (1 - alpha) * e
+    return e
+
+
+def anchor_curve(n, anchors, *, noise=0.03, ar=0.6, seed="", lo=0.0, hi=1.0, ema=None, alpha=1 / 3):
+    """n per-step values (steps 1..n) through {step: value}: a piecewise-linear path plus AR(1) noise bridged to zero at
+    every anchor, so anchored steps are exact. ema={step: value} pins Marin's trailing EMA (alpha 1/3) at that step by
+    shifting the unanchored raw values in the five steps before it."""
+    r = random.Random(stable_seed("curve", seed))
+    pts = sorted((int(s), float(v)) for s, v in anchors.items() if 1 <= int(s) <= n)
+    if pts[0][0] != 1:
+        pts.insert(0, (1, pts[0][1]))
+    if pts[-1][0] != n:
+        pts.append((n, pts[-1][1]))
+
+    def interp(p, s):
+        for (s0, v0), (s1, v1) in zip(p, p[1:]):
+            if s0 <= s <= s1:
+                return v0 if s1 == s0 else v0 + (v1 - v0) * (s - s0) / (s1 - s0)
+        return p[-1][1]
+    e, raw = 0.0, []
+    for _ in range(n):
+        e = ar * e + r.gauss(0, noise)
+        raw.append(e)
+    knots = [(s, raw[s - 1]) for s, _ in pts]
+    vals = [min(hi, max(lo, interp(pts, s) + raw[s - 1] - interp(knots, s))) for s in range(1, n + 1)]
+    fixed = {int(s) for s in anchors}
+    for s, v in anchors.items():
+        if 1 <= int(s) <= n:
+            vals[int(s) - 1] = float(v)
+    for s, target in (ema or {}).items():
+        for _ in range(6):
+            cur = ema_at(vals, s, alpha)
+            if abs(cur - target) < 5e-5:
+                break
+            window = [t for t in range(max(2, s - 4), s + 1) if t not in fixed]
+            wsum = sum(alpha * (1 - alpha) ** (s - t) for t in window)
+            if not window or wsum <= 0:
+                break
+            d = (target - cur) / wsum
+            for t in window:
+                vals[t - 1] = min(hi, max(lo, vals[t - 1] + d))
+    return vals
+
+
+def step_times(n, median, seed, sigma=0.3, first=3.0):
+    r = random.Random(stable_seed("dt", seed))
+    return [median * (first if i == 0 else 1.0) * math.exp(r.gauss(0, sigma)) for i in range(n)]
+
+
+GRID = [i / 10.0 for i in range(-140, 141)]
+
+
+class Pools:
+    """Per-environment task pool and a pass-rate -> skill table (inverting the mean of sigmoid(skill - difficulty))."""
+
+    def __init__(self):
+        self.cache = {}
+
+    def get(self, env):
+        c = self.cache.get(env.id)
+        if c is None:
+            pool = [t for t in env.tasks if t.status not in ("excluded", "invalid")] or list(env.tasks)
+            ds = [t.difficulty for t in pool]
+            if len(ds) > 160:
+                ds = random.Random(stable_seed(env.id)).sample(ds, 160)
+            means = [sum(sigmoid(g - d) for d in ds) / len(ds) for g in GRID]
+            c = self.cache[env.id] = (pool, means)
+        return c
+
+    def skill(self, env, p):
+        _, means = self.get(env)
+        p = min(0.998, max(0.002, p))
+        if p <= means[0]:
+            return GRID[0]
+        if p >= means[-1]:
+            return GRID[-1]
+        lo, hi = 0, len(means) - 1
+        while hi - lo > 1:
+            mid = (lo + hi) // 2
+            if means[mid] < p:
+                lo = mid
+            else:
+                hi = mid
+        f = (p - means[lo]) / max(1e-12, means[hi] - means[lo])
+        return GRID[lo] + f * (GRID[hi] - GRID[lo])
+
+
+POOLS = Pools()
+
+
+def p_for(env, m):
+    """Pass probability that makes the environment's mean reward m (judge rewards average 0.125 + 0.75 p)."""
+    if env.judge:
+        return min(0.99, max(0.01, (m - 0.125) / 0.75))
+    return min(0.998, max(0.002, m))
+
+
+def advantages(rew, kind):
+    vals = [v for v in rew if v is not None]
+    if len(vals) < 2:
+        return [None if v is None else 0.0 for v in rew]
+    mu = sum(vals) / len(vals)
+    if kind == "rloo":
+        k = len(vals)
+        return [None if v is None else round((v - mu) * k / (k - 1), 4) for v in rew]
+    sd = (sum((v - mu) ** 2 for v in vals) / len(vals)) ** 0.5
+    return [None if v is None else (round((v - mu) / (sd + 1e-6), 4) if sd > 0 else 0.0) for v in rew]
+
+
+def list_bank(items):
+    def gen(r, i):
+        return items[i][0], items[i][1]
+    return gen
+
+
+# ------------------------------------------------------------------ the RL writer
+
+def simulate_run(w, *, pid, key, name, envs, base_model_id, reward, start, times, group_size, prompts, run,
+                 first_step=1, steps_planned=None, sample_groups=48, store_groups=2, adv="rloo", scale=(0.0, 1.0),
+                 series=None, sim_tags=None, gen=None, exact=None, pass_curve=None, harness="", tok_mult=None,
+                 env_offsets=None, env_series=False, staleness=None, events=(), checkpoints=(), seed=None,
+                 write_rollouts=True, max_tokens=None, binary=True, gaps=None, missing=()):
+    """Write one RL run whose per-step mean reward follows `reward` (0-1 scale, index 0 = first_step).
+
+    `series` are published (or pre-simulated) metrics written as given; `sim_tags` maps aggregates of the simulated
+    groups ('pass_at_k', 'resp_len', 'adv_abs', 'trunc', 'infra', 'reward', 'pass_rate', 'step_time') to tags written
+    where `series` has no value; `gen(step, x)` returns further simulated tags. Rollouts: `store_groups` groups per step
+    sampled at the step's reward level, so tables and charts agree. `exact` pins run_steps fields per step and
+    `pass_curve` pins the pass@k metric (and the all-fail group count) per step."""
+    run_id = rid("run", pid, key)
+    r = random.Random(seed if seed is not None else stable_seed(pid, key))
+    n = len(reward)
+    env_list = [e for e, _ in envs]
+    weights = [wt for _, wt in envs]
+    offs = dict(env_offsets or {})
+    mean_off = sum(offs.get(e.id, 0.0) * wt for e, wt in envs) / max(1e-9, sum(weights))
+    lo, hi = scale
+    sim_tags = dict(sim_tags or {})
+    exact = exact or {}
+    metrics = {}
+    for tag, pts in (series or {}).items():
+        for s, v in pts:
+            if v is None or (isinstance(v, float) and (math.isnan(v) or math.isinf(v))):
+                continue
+            metrics[(tag, int(s))] = float(v)
+    step_rows, roll_rows, times_out = [], [], {}
+    t = start
+    for i in range(n):
+        step = first_step + i
+        x = i / max(1, n - 1)
+        m = reward[i]
+        dur = times[i]
+        t += (gaps or {}).get(step, 0.0)
+        skills = {e.id: POOLS.skill(e, p_for(e, min(0.995, max(0.005, m + offs.get(e.id, 0.0) - mean_off)))) for e in env_list}
+        mult = tok_mult(step) if tok_mult else 1.0
+        saved = {e.id: (e.tokens_out, e.max_tokens) for e in env_list}
+        for e in env_list:
+            e.tokens_out = saved[e.id][0] * mult
+            if max_tokens:
+                e.max_tokens = max_tokens
+        st = dict(n=0, scored=0, passed=0, infra=0, trunc=0, allp=0, allf=0, mixed=0, anyp=0, tok_in=0, tok_out=0,
+                  adv=0.0, advn=0, groups=0)
+        by_env = {e.id: [0, 0, 0.0] for e in env_list}
+        stored = 0
+        for g in range(sample_groups):
+            e = weighted_choice(r, env_list, weights)
+            pool = POOLS.get(e)[0]
+            task = pool[r.randrange(len(pool))]
+            atts = [attempt(r, e, task, skills[e.id]) for _ in range(group_size)]
+            rew = [a["reward"] for a in atts]
+            sc = [v for v in rew if v is not None]
+            st["groups"] += 1
+            be = by_env[e.id]
+            be[0] += 1
+            if sc:
+                if all(v >= 1.0 for v in sc):
+                    st["allp"] += 1
+                elif all(v <= 0.0 for v in sc):
+                    st["allf"] += 1
+                else:
+                    st["mixed"] += 1
+            if any(a["outcome"] == "passed" for a in atts):
+                st["anyp"] += 1
+            scaled = [None if v is None else round(lo + (hi - lo) * v, 4) for v in rew]
+            advs = advantages(scaled, adv)
+            for j, a in enumerate(atts):
+                st["n"] += 1
+                if a["reward"] is None:
+                    st["infra"] += 1
+                else:
+                    st["scored"] += 1
+                    st["passed"] += a["outcome"] == "passed"
+                    be[1] += 1
+                    be[2] += a["reward"]
+                st["trunc"] += a["outcome"] == "truncated"
+                st["tok_in"] += a["tokens_in"]
+                st["tok_out"] += a["tokens_out"]
+                if advs[j] is not None:
+                    st["adv"] += abs(advs[j])
+                    st["advn"] += 1
+                if write_rollouts and g < store_groups:
+                    stored += 1
+                    roll_rows.append({
+                        "id": rid("roll", run_id, step, g, j), "run_id": run_id, "eval_id": None, "step": step,
+                        "phase": "train", "group_id": rid("grp", run_id, step, g), "sample": j, "task_id": task.id,
+                        "env_id": e.id, "harness": harness, "model_id": base_model_id, "reward": scaled[j],
+                        "advantage": advs[j], "scores": None, "outcome": a["outcome"], "stop_reason": a["stop_reason"],
+                        "turns": a["turns"], "tool_calls": a["tool_calls"], "tokens_in": a["tokens_in"],
+                        "tokens_out": a["tokens_out"], "tokens_cached": a["tokens_cached"], "duration_s": a["duration_s"],
+                        "timing": a["timing"], "staleness": (r.choice(staleness) if staleness else 0), "flags": None,
+                        "seed": stable_seed(run_id, step, g, j), "trained": 0 if a["reward"] is None else 1})
+        for e in env_list:
+            e.tokens_out, e.max_tokens = saved[e.id]
+        f = prompts / max(1, st["groups"])
+        allp, allf = st["allp"] * f, st["allf"] * f
+        pass_k = st["anyp"] / max(1, st["groups"])
+        if pass_curve is not None:
+            pass_k = pass_curve[i]
+        pk_exact = exact.get(step, {}).get("pass_at_k")
+        if pk_exact is not None:
+            pass_k = pk_exact
+        if pass_curve is not None or pk_exact is not None:
+            allf = (1 - pass_k) * prompts
+            allp = min(allp, prompts - allf)
+        row = {"run_id": run_id, "step": step, "phase": "train", "started_at": t, "ended_at": t + dur, "prompts": prompts,
+               "rollouts": prompts * group_size, "rollouts_stored": stored, "reward_mean": round(lo + (hi - lo) * m, 5),
+               "pass_rate": round(m if binary else st["passed"] / max(1, st["scored"]), 4),
+               "tokens": int((st["tok_in"] + st["tok_out"]) * f),
+               "groups_all_pass": int(round(allp)), "groups_all_fail": int(round(allf)),
+               "groups_mixed": max(0, prompts - int(round(allp)) - int(round(allf))),
+               "infra_errors": int(round(st["infra"] * f)), "truncated": int(round(st["trunc"] * f))}
+        for k2, v2 in exact.get(step, {}).items():
+            if k2 in row:
+                row[k2] = v2
+        if step in missing:
+            row["reward_mean"] = row["pass_rate"] = None
+        step_rows.append(row)
+        agg = {"reward": lo + (hi - lo) * m, "pass_rate": m, "pass_at_k": pass_k,
+               "resp_len": st["tok_out"] / max(1, st["n"]), "adv_abs": st["adv"] / max(1, st["advn"]),
+               "trunc": st["trunc"] / max(1, st["n"]), "infra": st["infra"] / max(1, st["n"]), "step_time": dur}
+        for a_key, tag in sim_tags.items():
+            if (tag, step) not in metrics and a_key in agg:
+                metrics[(tag, step)] = agg[a_key]
+        if pk_exact is not None and "pass_at_k" in sim_tags:
+            metrics[(sim_tags["pass_at_k"], step)] = pk_exact
+        if gen:
+            for tag, v in gen(step, x).items():
+                if (tag, step) not in metrics and v is not None:
+                    metrics[(tag, step)] = v
+        if env_series:
+            for e in env_list:
+                be = by_env[e.id]
+                if be[1]:
+                    metrics[(f"by_env/{e.name}/pass_rate", step)] = be[2] / be[1]
+        times_out[step] = (t, t + dur)
+        t += dur
+    status = run.get("status", "completed")
+    done = status in ("completed", "failed", "stopped")
+    w.add("runs", {
+        "id": run_id, "project_id": pid, "name": name, "kind": run.get("kind", "rl"), "stage": run.get("stage", "RL"),
+        "algorithm": run["algorithm"], "framework": run["framework"], "status": status,
+        "status_reason": run.get("status_reason", ""), "base_model_id": base_model_id,
+        "output_model_id": run.get("output_model_id"), "started_at": start, "ended_at": t if done else None, "updated_at": t,
+        "steps_planned": steps_planned or (first_step + n - 1), "steps_done": first_step + n - 1,
+        "primary_metric": run["primary_metric"], "gpu": run.get("gpu"), "gpus": run.get("gpus"), "cost_usd": None,
+        "cost_rate": None, "owner": run.get("owner", "Marin"), "tags": list(run.get("tags", [])),
+        "code_ref": run.get("code_ref", ""), "config": run.get("config", ""), "config_format": run.get("config_format", "yaml"),
+        "hyperparams": run.get("hyperparams", {}), "parent_run_id": run.get("parent_run_id"),
+        "group_name": run.get("group_name"), "description": run["description"], "source": run["source"],
+        "provenance": run["provenance"]})
+    for e, wt in envs:
+        w.add("run_inputs", {"run_id": run_id, "kind": "environment", "ref_id": e.id, "weight": wt})
+    for ds_id, wt in run.get("datasets", ()):
+        w.add("run_inputs", {"run_id": run_id, "kind": "dataset", "ref_id": ds_id, "weight": wt})
+    w.add_many("run_steps", step_rows)
+    if roll_rows:
+        w.add_many("rollouts", roll_rows)
+    w.add_many("metrics", [{"run_id": run_id, "tag": tag, "step": s, "value": v} for (tag, s), v in metrics.items()])
+    ev = [{"run_id": run_id, "t": start, "step": first_step - 1, "kind": "start", "severity": "info", "title": "Run started",
+           "body": run.get("start_body") or f"{run['algorithm']}, {prompts} prompts × {group_size} attempts per step."}]
+    for c in checkpoints:
+        s = c["step"]
+        tt = times_out.get(s, (t, t))[1]
+        w.add("checkpoints", {"id": rid("ckpt", run_id, s), "run_id": run_id, "step": s, "model_id": c.get("model_id"),
+                              "path": c.get("path", f"{key}/global_step_{s}"), "size_gb": None, "created_at": tt,
+                              "kept": 1 if c.get("kept", True) else 0})
+        ev.append({"run_id": run_id, "t": tt, "step": s, "kind": "checkpoint", "severity": "info",
+                   "title": c.get("title", f"Checkpoint step {s}"), "body": c.get("body", "")})
+    for e in events:
+        e = dict(e)
+        e.setdefault("severity", "info")
+        e.setdefault("body", "")
+        if "t" not in e:
+            s = e.get("step") or first_step
+            e["t"] = times_out.get(s, (t, t))[1] if s in times_out else (start if s < first_step else t)
+        ev.append(dict(e, run_id=run_id))
+    if done:
+        ev.append({"run_id": run_id, "t": t, "step": first_step + n - 1, "kind": "end",
+                   "severity": "error" if status == "failed" else "info",
+                   "title": {"completed": "Run completed", "failed": "Run failed", "stopped": "Run stopped"}[status],
+                   "body": run.get("status_reason", "")})
+    w.add_many("run_events", ev)
+    return {"run_id": run_id, "start": start, "end": t, "times": times_out}
+
+
+# ------------------------------------------------------------------ records: jobs, metric defs, tasks, evals
+
+def add_jobs(w, pid, run_id, name, status, start, end, parts, restarts=()):
+    """parts: [{"name", "kind", "cluster", "gpu", "gpus", "nodes"}]; the first part is the trainer, split at restarts."""
+    running = status == "running"
+    for pi, p in enumerate(parts):
+        bounds = [start] + (sorted(x for x in restarts if start < x < end) if pi == 0 else []) + [end]
+        for i in range(len(bounds) - 1):
+            last = i == len(bounds) - 2
+            w.add("jobs", {"id": rid("job", run_id, p["name"], i), "project_id": pid, "run_id": run_id, "eval_id": None,
+                           "name": f"{name} · {p['name']}" + (f" (attempt {i + 1})" if len(bounds) > 2 else ""),
+                           "kind": p.get("kind", "train"), "status": status if last else "failed",
+                           "cluster_id": p.get("cluster"), "gpu": p.get("gpu"), "gpus": p.get("gpus"),
+                           "nodes": p.get("nodes"), "started_at": bounds[i], "ended_at": None if (last and running) else bounds[i + 1],
+                           "cost_usd": None, "exit": ("restarted" if not last else status), "log_tail": p.get("log", "")})
+
+
+def add_defs(w, pid, rows):
+    """rows: (tag, label, description, format, group, better, signal)."""
+    have = {r_[0] for r_ in w.conn.execute("SELECT tag FROM metric_defs WHERE project_id=?", (pid,))}
+    out = []
+    for tag, label, desc, fmt, grp, better, signal in rows:
+        if tag in have:
+            continue
+        have.add(tag)
+        unit = sig.SIGNALS[signal][1] if signal in sig.SIGNALS else ""
+        out.append({"project_id": pid, "tag": tag, "label": label, "description": desc, "unit": unit, "format": fmt,
+                    "grp": grp, "better": better, "pinned": 0, "signal": signal})
+    w.add_many("metric_defs", out)
+
+
+def store_tasks(w, env, base=None, latest=None, attempts=0):
+    """Write the environment's tasks; pass rates only where a published number anchors them."""
+    bs = POOLS.skill(env, p_for(env, base)) if base is not None else None
+    ls = POOLS.skill(env, p_for(env, latest)) if latest is not None else None
+    w.add_many("tasks", [{
+        "id": t.id, "env_id": env.id, "name": t.name, "instruction": t.instruction, "difficulty": round(t.difficulty, 3),
+        "tags": t.tags, "status": t.status, "status_reason": t.status_reason, "oracle_score": t.oracle,
+        "noop_score": t.noop, "reruns": t.reruns, "rerun_agree": t.agree,
+        "base_pass": round(pass_prob(t, bs), 3) if bs is not None else None,
+        "latest_pass": round(pass_prob(t, ls), 3) if ls is not None else None, "attempts": attempts} for t in env.tasks])
+
+
+def make_env(w, pid, key, name, domain, *, tasks, task_count, grader_id, harness, tools=(), reward_kind="binary",
+             sandbox=None, description="", version="", source="", provenance="mixed", difficulty=(0.0, 2.0),
+             profile=None, checks=None, created_at=None, statuses=None, reasons=None):
+    """tasks: [(name, instruction, tags)]; task_count: real size or None when not published."""
+    env = kit.environment(w, pid, key, name, domain, n_tasks=len(tasks), task_count=task_count or len(tasks),
+                          bank=list_bank([(a, b) for a, b, _ in tasks]), grader_id=grader_id, harness=harness,
+                          tools=list(tools), reward_kind=reward_kind, sandbox=sandbox, description=description,
+                          version=version, source=source, provenance=provenance, difficulty=difficulty,
+                          statuses=statuses or {}, profile=profile or {}, created_at=created_at, checks=checks)
+    for tk, (_, _, tags) in zip(env.tasks, tasks):
+        tk.tags = list(tags or [])
+    # a simulated validation status must never land on a real, published task: swap it onto a placeholder
+    ok_placeholders = [tk for tk in env.tasks if tk.status == "ok" and not any("published" in g for g in tk.tags)]
+    for tk in env.tasks:
+        if tk.status != "ok" and any("published" in g for g in tk.tags) and ok_placeholders:
+            other = ok_placeholders.pop()
+            other.status, other.status_reason, other.oracle, other.noop, other.agree = tk.status, tk.status_reason, tk.oracle, tk.noop, tk.agree
+            tk.status, tk.status_reason, tk.oracle, tk.noop, tk.agree = "ok", "", 1.0, 0.0, 1.0
+    for tk in env.tasks:
+        if reasons and tk.status in reasons:
+            tk.status_reason = reasons[tk.status]
+    if task_count is None:
+        w.conn.execute("UPDATE environments SET task_count=NULL WHERE id=?", (env.id,))
+    return env
+
+
+class Evals:
+    """Benchmarks and evals. Small benchmarks keep per-task results (simulated to average to the published score);
+    large ones (or continuous metrics) store the published score with an analytic standard error only."""
+
+    def __init__(self, w, pid):
+        self.w, self.pid, self.b = w, pid, {}
+
+    def bench(self, key, name, category, metric, n, k, desc, source, *, harness=None, version="", per_task=True,
+              names=None, difficulty=(0.0, 1.8)):
+        bid = rid("bench", self.pid, key)
+        self.w.add("benchmarks", {"id": bid, "project_id": self.pid, "name": name, "version": version,
+                                  "category": category, "metric": metric, "harness": harness, "n_tasks": n, "k": k,
+                                  "description": desc, "source": source})
+        tasks = []
+        if per_task:
+            bank = list_bank(names) if names else (lambda r, i: (f"{key}-{i:04d}", ""))
+            tasks = make_tasks(bid, n, bank, difficulty)
+        b = Bench(bid, self.pid, name, tasks, k, metric)
+        b.store_tasks = bool(per_task)
+        b.n = n
+        self.b[key] = b
+        return b
+
+    def ev(self, key, model_id, value, *, started, source, ek, run_id=None, step=None, stderr=None, n_infra=None,
+           config=None, command="", provenance="mixed", duration=3 * H, n_tasks=None, k=None):
+        """value on a 0-1 scale (None for not scored)."""
+        b = self.b[key]
+        if b.tasks and value is not None:
+            eid = eval_run(self.w, b, model_id=model_id, score=min(1.0, max(0.0, value)), run_id=run_id, step=step,
+                           started=started, duration=duration, source=source, provenance=provenance, key=ek,
+                           config=config, command=command)
+            upd = {"score": value}
+            if stderr is not None:
+                upd["stderr"] = stderr
+            if n_infra is not None:
+                upd["n_infra"] = n_infra
+            self.w.conn.execute(f"UPDATE evals SET {', '.join(f'{c}=?' for c in upd)} WHERE id=?", (*upd.values(), eid))
+            return eid
+        eid = rid("eval", b.id, ek)
+        nn, kk = n_tasks or b.n, k or b.k
+        se = stderr
+        if se is None and value is not None and 0 <= value <= 1 and nn:
+            se = round(math.sqrt(max(value * (1 - value), 1e-9) / (nn * kk)), 5)
+        self.w.add("evals", {"id": eid, "project_id": self.pid, "benchmark_id": b.id, "model_id": model_id, "run_id": run_id,
+                             "step": step, "status": "completed" if value is not None else "failed",
+                             "score": value, "stderr": se, "n_tasks": nn, "k": kk,
+                             "n_infra": n_infra, "started_at": started,
+                             "ended_at": started + duration if started else None, "cost_usd": None, "config": config,
+                             "command": command, "source": source,
+                             "provenance": "published" if not b.tasks else provenance})
+        return eid
+
+
+# ------------------------------------------------------------------ SkyRL metric definitions shared by projects
+
+def skyrl_defs(pid, g_label="8"):
+    S = sig.SIGNALS
+    rows = [
+        ("reward/avg_raw_reward", "Raw reward", "Mean verifier reward over the step's rollouts (A3 and #7785: 64 prompts × 8). "
+         "Marin's own rule: it rises then plateaus and is not a proxy for held-out performance (Snowball claim VI rejected; "
+         "#8942: holdout improvement is the reliable signal).", "num3", "learning", "up", "reward"),
+        ("reward/avg_pass_at_8", "Pass@8", "Share of the step's prompts with at least one passing attempt out of 8. Its "
+         "EMA-5 through the exported checkpoint is the #7785 arm score. For binary rewards, 1 − pass@8 is the share of "
+         "prompts whose 8 attempts all failed (zero RLOO advantage).", "pct", "learning", "up", None),
+        ("reward/avg_pass_at_16", "Pass@16", "Share of the step's prompts with at least one passing attempt out of 16 "
+         "(Snowball RLVR, 16 samples per prompt). With partial rewards it can sit below the mean raw reward.", "pct",
+         "learning", "up", None),
+        ("loss/avg_final_rewards", "Final reward", "Mean reward after any shaping; equal to the raw reward when shaping is off.",
+         "num3", "learning", "up", None),
+        ("loss/avg_raw_advantages", "Mean advantage", "Mean RLOO advantage over the batch.", "num4", "stability", "none", None),
+        ("loss/avg_raw_advantages_abs", "Mean |advantage|", "Mean absolute advantage; with raw_grad_norm, Marin's "
+         "learning-signal test (#7785 POLICY): stop when it sits near zero and the gradient norm decays.", "num3",
+         "signal", "none", None),
+        ("policy/policy_entropy", S["entropy"][0], "Token entropy of the policy. #7785 POLICY: 3× its step-1 value is a watch "
+         "condition; at 10×, select a checkpoint and stop; entropy freezes when learning stops, so pair it with a liveness check.",
+         "num3", "stability", "none", "entropy"),
+        ("policy/raw_grad_norm", S["grad_norm"][0], "Pre-clip gradient norm (A3 clips at 0.9).", "num3", "stability", "none", "grad_norm"),
+        ("policy/policy_loss", S["pg_loss"][0], "Policy-gradient loss.", "num4", "stability", "none", "pg_loss"),
+        ("policy/ppo_clip_ratio", S["clip_frac"][0], "Share of tokens clipped by the PPO ratio clip. With one update per "
+         "batch it is inert (0.0) except for numerical disagreement (FSDP2 clipped 0.00705 at step 1 in #7785).", "pct",
+         "stability", "none", "clip_frac"),
+        ("policy/policy_lr", S["lr"][0], "Learning rate as logged. The A3 logs show 0.0 at every step although lr is 8e-6 "
+         "(a logging artifact; the column is left out of the A3 copies).", "sci", "stability", "none", "lr"),
+        ("policy/policy_kl", "KL (policy)", "KL term of the KL arms (#7785 X3).", "num4", "stability", "none", "kl_ref"),
+        ("reward/policy_ref_kl", "KL to reference", "KL to the reference model (KL arms only).", "num4", "stability", "none", None),
+        ("generate/avg_num_tokens", S["response_len"][0], "Mean generated tokens per trajectory. Collapse signature in #7785: "
+         "the X10 Megatron arm fell from 11,674 to 1,091 tokens with raw reward 0.016 by step 15.", "compact", "length",
+         "none", "response_len"),
+        ("generate/avg_tokens_non_zero_rewards", "Tokens (rewarded)", "Mean tokens of trajectories with nonzero reward.",
+         "compact", "length", "none", None),
+        ("generate/avg_tokens_zero_rewards", "Tokens (zero reward)", "Mean tokens of trajectories with zero reward.",
+         "compact", "length", "none", None),
+        ("generate/max_num_tokens", "Longest trajectory", "Tokens of the longest trajectory in the step.", "compact", "length",
+         "none", None),
+        ("generate/std_num_tokens", "Token spread", "Standard deviation of trajectory length.", "compact", "length", "none", None),
+        ("generate/failed_trajectory_fraction", "Failed trajectories", "Share of trajectories that failed in the harness. "
+         "Masked exception classes (DaytonaError, EnvironmentStartTimeoutError, NetworkError, ...) are dropped from the "
+         "batch, not scored as zero.", "pct", "infra", "down", "infra_error_rate"),
+        ("async/staleness_mean", S["staleness"][0], "Mean policy-version lag of consumed groups. A3 allowed up to 16 (mean "
+         "1.79 on pymethods2test-large); #8942 warns that a lag of 2 or more adds off-policy pathology.", "num2", "infra",
+         "down", "staleness"),
+        ("timing/step", S["step_time"][0], "Wall-clock seconds per optimizer step. A3 pymethods2test-large: mean 1,445 s, of "
+         "which 1,183 s waiting for the generation buffer and 201 s policy training.", "duration", "throughput", "down",
+         "step_time"),
+        ("trainer/epoch", "Epoch", "Data epoch (A3: two epochs capped at 80 steps).", "int", "trainer", "none", None),
+        # reduced schema of the #7785 X10 / X15 exports
+        ("reward", "Raw reward", "Mean verifier reward per step (reduced-schema export of the #7785 X10 and X15 arms).",
+         "num3", "learning", "up", "reward"),
+        ("avg_pass_at_8", "Pass@8", "Per-step pass@8 (reduced-schema export).", "pct", "learning", "up", None),
+        ("entropy", S["entropy"][0], "Policy entropy (reduced-schema export). X10b: 0.284 → 0.0129 while responses held "
+         "11.9k → 13.5k tokens.", "num3", "stability", "none", "entropy"),
+        ("grad_norm", S["grad_norm"][0], "Gradient norm (reduced-schema export).", "num3", "stability", "none", "grad_norm"),
+        ("tokens", S["response_len"][0], "Mean generated tokens per trajectory (reduced-schema export).", "compact", "length",
+         "none", "response_len"),
+        ("tis_log_ratio_mean", "TIS log-ratio", "Mean log importance ratio between trainer and sampler (truncated importance "
+         "sampling, cap 2.0).", "num4", "consistency", "down", "train_infer_kl"),
+        ("val/pass_at_1", "Holdout pass@1", "Fixed 128-task holdout, pass@1 at temperature 0; step 0 is the untrained base. "
+         "The calendar holdouts overlap their training sources.", "pct", "eval", "up", None),
+        ("val/avg_score", "Holdout mean score", "Mean score on the fixed 128-task holdout.", "num3", "eval", "up", None),
+        ("val/passed", "Holdout tasks passed", "Tasks passed out of 128.", "int", "eval", "up", None),
+        ("val/turn_cap_rate", "Holdout turn-cap rate", "Share of holdout trials that hit the turn cap.", "pct", "eval", "down", None),
+    ]
+    return rows
+
+
+# ------------------------------------------------------------------ build
+
+# SFT/DPO runs whose learning-rate schedule is not published (or whose published schedule the engine cannot draw):
+# exp1237 (schedule not stated), IFBench DPO and GLM53 SFT (lr not stated), Datakit 09.17 (schedule not stated), the July
+# stages (cosine to min_lr_ratio 0.1), #9225 arms A-C (a two-epoch cosine stopped after one epoch).
+NO_LR_SCHEDULE = ("exp1237-sft", "ifbench-dpo-strict", "ifbench-dpo-loose", "ifbench-dpo-soft", "glm53-sft", "dk0917",
+                  "armA", "armB", "armC", "sft-s1", "sft-s2")
+
+def build(w, now):
+    org_id = kit.org(w, "marin", "Marin",
+                     about="Open lab developing foundation models in public (marin-community, primarily developed by Open "
+                           "Athena, a non-profit). Every experiment is a GitHub issue with a preregistered hypothesis; failed "
+                           "experiments stay in the record.", url=MARIN)
+    C = {}
+    for key, name, provider, gpu, region in (
+            ("jupiter", "JSC JUPITER (GH200, 4 per node; reformo reservation)", "Jülich Supercomputing Centre", "GH200", "Jülich, DE"),
+            ("juwels", "JSC JUWELS (CPU nodes for apptainer sandboxes)", "Jülich Supercomputing Centre", None, "Jülich, DE"),
+            ("rno2a", "CoreWeave cw-rno2a (H100 80GB, Iris)", "CoreWeave", "H100", "cw-rno2a"),
+            ("useast", "CoreWeave cw-us-east-02a (H100 80GB)", "CoreWeave", "H100", "cw-us-east-02a"),
+            ("tpu", "Google TPU Research Cloud (TPU v5p-8)", "Google Cloud TPU", "TPU v5p", None),
+            ("daytona", "Daytona (hosted sandboxes)", "Daytona", None, None)):
+        C[key] = kit.cluster(w, org_id, key, name, provider, gpu=gpu, region=region)
+    for pid in (build_instruct(w, org_id, C), build_agentic(w, org_id, C), build_snowball(w, org_id, C)):
+        # the engine's SFT/DPO writer adds a simulated validation loss; no Marin run publishes one, so leave it out
+        w.conn.execute("DELETE FROM metrics WHERE tag='eval/loss' AND run_id IN (SELECT id FROM runs WHERE project_id=?)", (pid,))
+        w.conn.execute("DELETE FROM metric_defs WHERE tag='eval/loss' AND project_id=?", (pid,))
+        # learning-rate curves only where the schedule is published
+        for key in NO_LR_SCHEDULE:
+            w.conn.execute("DELETE FROM metrics WHERE tag='train/learning_rate' AND run_id=?", (rid("run", pid, key),))
+        # no dollar figure is published for any Marin run (compute is donated or granted)
+        w.conn.execute("UPDATE runs SET cost_usd=NULL, cost_rate=NULL WHERE project_id=?", (pid,))
+    return {"org_id": org_id}
+
+
+# ================================================================== (a) Marin 8B Instruct
+
+RETRO_COLS = ["OLMo 2 SFT", "OLMo 2 Instruct", "Llama 3.1 Instruct", "Llama 3.1 Tulu", "Marin 8B SFT"]
+RETRO = [  # key, name, n (assumed standard size), note, values in RETRO_COLS order
+    ("alpacaeval", "AlpacaEval", 805, "AlpacaEval's 805 prompts (standard size, assumed)", (10.2, 29.1, 23.6, 34.9, 18.3)),
+    ("ifeval", "IFEval", 541, "IFEval's 541 prompts (standard size, assumed)", (63.6, 69.5, 84.5, 87.5, 78.3)),
+    ("gsm8k-cot", "GSM8K-CoT", 1319, "the GSM8K test split's 1,319 problems (assumed)", (69.4, 79.0, 82.6, 88.1, 68.9)),
+    ("bbh", "BigBenchHard", 6511, "BBH's 6,511 examples over 27 tasks (assumed)", (42.0, 42.6, 36.9, 43.9, 46.0)),
+    ("mmlu", "MMLU", 14042, "MMLU's 14,042 test questions (assumed)", (59.6, 59.7, 63.2, 60.7, 61.6)),
+    ("gpqa", "GPQA", 448, "GPQA main's 448 questions (the retro does not say which GPQA split; assumed)", (25.8, 24.2, 29.2, 28.7, 29.5)),
+    ("mmlu-pro", "MMLU-Pro", 12032, "MMLU-Pro's 12,032 questions (assumed)", (22.7, 17.6, 15.9, 29.4, 31.2)),
+    ("musr", "MuSR", 756, "MuSR's 756 problems (assumed)", (37.7, 34.7, 38.1, 42.2, 35.9)),
+    ("math-hard", "MATH Hard", 1324, "the 1,324 level-5 MATH problems (assumed)", (7.2, 14.0, 23.1, 24.7, 21.2)),
+    ("humaneval", "HumanEval", 164, "HumanEval's 164 problems (assumed)", (38.4, 17.1, 0.6, 60.4, 47.0)),
+]
+RETRO_AVG = [("avg", "Average (10 tasks)", (37.7, 38.7, 39.8, 50.0, 43.8)),
+             ("avg-no-outliers", "Average without outliers", (41.4, 44.6, 46.8, 51.9, 46.2))]
+EXP808 = [  # exp808 key, documents, category
+    ("facebook/natural_reasoning", 1145824, "science"), ("HuggingFaceTB/smoltalk", 1043917, "chat"),
+    ("allenai/tulu-3-sft-mixture", 939343, "chat"), ("PrimeIntellect/verifiable-math-problems", 777457, "math"),
+    ("cognitivecomputations/dolphin-r1-reasoning", 585418, "chat"),
+    ("cognitivecomputations/dolphin-r1-nonreasoning", 214318, "chat"), ("open-r1/OpenThoughts-114k-math", 89120, "math"),
+    ("TIGER-Lab/AceCode-89K", 87149, "code"), ("bespokelabs/Bespoke-Stratos-17k", 16710, "math")]
+DPO_LRS = [1e-06, 2.5e-06, 3.75e-06, 4.5e-06, 5e-06, 6.25e-06, 7.5e-06, 8.75e-06, 1e-05]
+
+
+def build_instruct(w, org_id, C):
+    pid = kit.project(
+        w, org_id, "marin-8b-instruct", "Marin 8B Instruct and preference tuning",
+        "Marin's only released instruct model before Snowball: Marin 8B Instruct, SFT-only, trained for 10,228 steps on the "
+        "4.9M-document, 9-dataset exp808 mixture from Marin 8B Base (deeper-starling). Beside it, two 2026 preference-tuning "
+        "experiments: an 18-run LoRA-DPO learning-rate sweep on Marin 8B Instruct (#4556) and IFBench-targeted DPO on Tulu 3 "
+        "8B (#5244).",
+        [{"title": "Marin 8B retrospective (SFT section)", "url": RETRO}, {"title": "Marin 8B Instruct model card", "url": CARD_8B},
+         {"title": "exp808 SFT mixture", "url": EXP808}, {"title": "exp1237 Starling SFT", "url": EXP1237},
+         {"title": "Issue #1237: release SFT", "url": I1237}, {"title": "Issue #4556: LoRA-DPO sweep", "url": I4556},
+         {"title": "Issue #4556: A=0 vs B=0 follow-up", "url": I4556B}, {"title": "Issue #5244: IFBench DPO", "url": I5244},
+         {"title": "Released LoRA-DPO checkpoint", "url": DPO_CKPT}],
+        "Published: the SFT mixture (documents per dataset), steps, batch and sequence length, the 5.3B trained tokens and the "
+        "retro's 10-task evaluation of Marin 8B SFT and four baselines; the LoRA-DPO sweep design (9 learning rates × 2 "
+        "seeds, beta 0.1, LoRA r 64, one epoch of 1,700 steps) and its A=0 finding with the best DPO eval accuracy "
+        "(0.99314); the IFBench DPO arms' IFBench and IFEval scores. The learning rate conflicts between sources (script 1e-4, "
+        "retro 1.7e-4); runs keep the script's value and say so. Simulated: all training curves, dates and step times (no "
+        "loss curve, hardware or wall-clock is published), per-task eval results pinned to each published score, and the "
+        "IFBench DPO step counts.",
+        at("2025-05-01 00:00"), pins=["train/loss", "train/rewards/accuracies"])
+    M = {}
+
+    def model(key, name, kind="checkpoint", **kw):
+        M[key] = kit.model(w, pid, key, name, kind, **kw)
+        return M[key]
+
+    model("base", "Marin 8B Base (deeper-starling)", "base", hf_repo="marin-community/marin-8b-base",
+          arch="Dense, Llama 3 8B architecture (hidden 4096, 32 layers, 32 heads, 8 KV heads)", params_total=8.0,
+          params_active=8.0, stage="Pretrained", created_at=at("2025-05-10 00:00"), status="released", source=CARD_8B_BASE,
+          notes="Nominal 8B. deeper-starling, 13.7T training tokens per the model card; released 2025-05-15.")
+    for key, name in (("olmo2-sft", "OLMo 2 SFT"), ("olmo2-instruct", "OLMo 2 Instruct"),
+                      ("llama31-instruct", "Llama 3.1 Instruct"), ("llama31-tulu", "Llama 3.1 Tulu")):
+        model(key, name, "external", created_at=at("2025-05-14 00:00"), status="external", source=RETRO,
+              notes="Baseline in the Marin 8B retrospective's SFT evaluation table.")
+    model("tulu3-dpo", "Llama-3.1-Tulu-3-8B-DPO", "external", hf_repo="allenai/Llama-3.1-Tulu-3-8B-DPO",
+          created_at=at("2026-04-01 00:00"), status="external", source=I5244, params_total=8.0, params_active=8.0,
+          notes="Start point of the IFBench-targeted DPO experiment (#5244).")
+
+    # datasets
+    total = sum(n for _, n, _ in EXP808)
+    ds_sft = kit.dataset(
+        w, pid, "exp808", "exp808 SFT mixture (Marin 8B Instruct)", "sft", rows=total,
+        sources=[{"name": nm, "category": cat, "rows": n, "url": f"https://huggingface.co/datasets/{nm.replace('-reasoning', '').replace('-nonreasoning', '') if 'dolphin' in nm else nm}"}
+                 for nm, n, cat in EXP808],
+        processing=[{"step": "Mixture weights", "rows_in": None, "rows_out": total,
+                     "note": "Weight = documents per dataset, 'the naive baseline of the number of documents per dataset'; "
+                             "4,899,256 documents in all (sum of the nine counts)."},
+                    {"step": "Train", "rows_in": None, "rows_out": None,
+                     "note": "10,228 steps × 128 sequences × 4,096 tokens (exp1237); the model card reports one SFT phase of "
+                             "5.3B tokens, the retro 'about 5Gi tokens'."}],
+        description="The '808 mix' applied to the last Deeper Starling checkpoint for the release SFT (#1237): nine public "
+                    "SFT sets weighted by raw document count, max sequence length 4,096. The card lists TIGER-Lab/AceCode-89K, "
+                    "Bespoke-Stratos-17k, dolphin-r1 (reasoning and nonreasoning), natural_reasoning, OpenThoughts-114k-math, "
+                    "smoltalk, tulu-3-sft-mixture and verifiable-math-problems. Rows are documents; no rows are stored.",
+        created_at=at("2025-05-08 00:00"), source=EXP808, provenance="published")
+    ds_bloom = kit.dataset(
+        w, pid, "bloom-speceval-v2", "Bloom SpecEval v2 preference data", "preference",
+        description="Preference pairs used by the canonical train_dpo LoRA path in #4556. The row count is not published; "
+                    "one epoch is 1,700 steps at batch 64 (about 108,800 pairs, my arithmetic).",
+        created_at=at("2026-04-01 00:00"), source=I4556, provenance="published")
+    ds_ifb = kit.dataset(
+        w, pid, "ifbench-dpo", "IFBench-targeted DPO pairs (#5244 arms)", "preference",
+        sources=[{"name": "strict arm pairs", "category": "if"}, {"name": "loose arm pairs", "category": "if"},
+                 {"name": "soft arm pairs", "category": "if"}],
+        description="IFBench-derived preference pairs in three arms (strict, loose, soft verifier variants). Sizes are not "
+                    "published.", created_at=at("2026-04-10 00:00"), source=I5244, provenance="published")
+    kit.dataset(
+        w, pid, "ifbench-paper-strict", "IFBench paper-style strict pairs (24,153)", "preference", rows=24153,
+        parent_key="ifbench-dpo",
+        sources=[{"name": "Gemini-vs-Llama-8B rollouts, filtered to max length 4096", "category": "if", "rows": 24153,
+                  "synthetic": True}],
+        description="A full-train, paper-style strict set launched as the next #5244 step together with an LR sweep (3e-6, "
+                    "5e-6, 2e-5); results were not recorded, so no run uses it here.",
+        created_at=at("2026-04-20 00:00"), source=I5244, provenance="published")
+
+    # the release SFT (exp1237)
+    sft_cfg = "\n".join([
+        "# exp1237 Starling SFT (published values; exp1237_starling_sft.py at the merge commit)",
+        "base: marin-8b-base (deeper-starling, last checkpoint)", "data: exp808 mixture   # weights = document counts",
+        "learning_rate: 1e-4          # retro says 1.7e-4; W&B run deeper_mixture_sft_starling_1e-4-longer-2 supports 1e-4",
+        "num_train_steps: 10228       # retro: 10,227", "train_batch_size: 128        # 128 × 4,096 = 512Ki tokens per step",
+        "max_seq_len: 4096", "framework: Levanter / Marin executor",
+        "# not published: hardware, schedule, warmup, loss curve (simulated here)"])
+    start = at("2025-05-11 00:00")
+    res = sft_run(w, project_id=pid, key="exp1237-sft", name="exp1237-starling-sft", framework="trl_sft", datasets=[(ds_sft, 1.0)],
+                  base_model_id=M["base"], steps=10228, start=start, step_seconds=17.0, loss=(1.30, 0.92), lr=1e-4,
+                  warmup=0.01, schedule="linear", global_batch=128, seq_len=4096, gpu=None, gpus=None, cost_rate=0.0,
+                  tags=["sft", "release"], config=sft_cfg, stage="SFT", log_every=51, tokens_per_step=524288,
+                  hyperparams={"lr_conflict": "retro: 1.7e-4 and 10,227 steps; script: 1e-4 and 10,228 steps",
+                               "trained_tokens": "5.3B (model card)", "schedule": "not published (placeholder)",
+                               "warmup_ratio": "not published (placeholder)"},
+                  description="The release SFT of Marin 8B Instruct: the exp808 mixture on the last Deeper Starling "
+                              "checkpoint, 10,228 steps × 128 × 4,096 tokens (#1237, exp1237). Steps, batch, sequence length "
+                              "and learning rate are published; the loss curve, schedule, dates and step time are simulated.",
+                  source=EXP1237, provenance="simulated", ckpt_every=2557)
+    out = model("instruct", "Marin 8B Instruct (deeper-starling-05-15)", hf_repo="marin-community/marin-8b-instruct",
+                arch="Dense, Llama 3 8B architecture", params_total=8.0, params_active=8.0, parent_id=M["base"],
+                run_key="exp1237-sft", step=10228, stage="SFT", created_at=res["end"], status="released", source=CARD_8B,
+                notes="'Currently an SFT-only model': one SFT phase of 5.3B tokens from Deeper Starling. Released 2025-05-14.")
+    w.conn.execute("UPDATE runs SET output_model_id=?, framework='Levanter (Marin executor)' WHERE id=?", (out, res["run_id"]))
+    add_jobs(w, pid, res["run_id"], "exp1237-starling-sft", "completed", start, res["end"],
+             [{"name": "trainer", "kind": "train", "cluster": None, "gpu": None, "gpus": None,
+               "log": "Hardware for the SFT is not stated in the sources."}])
+
+    # LoRA-DPO sweep (#4556): 9 learning rates × 2 seeds with the default B=0 LoRA init, plus the A=0 best arm
+    dpo_cfg = lambda lr, seed, init: "\n".join([  # noqa: E731
+        "# LoRA-DPO on the canonical train_dpo path (#4556)", "base: marin-community/marin-8b-instruct",
+        "data: Bloom SpecEval v2 preference pairs", "beta: 0.1", f"learning_rate: {lr:g}", f"seed: {seed}",
+        "lora: {r: 64, alpha: 64, dropout: 0.0, init: " + init + "}", "train_batch_size: 64", "epochs: 1   # 1,700 steps",
+        "max_seq_len: 4096", "schedule: cosine, warmup 0.1",
+        "reference: AdapterBaseReferenceConfig   # the base view of the policy", "hardware: TPU v5p-8"])
+    sweep = []
+    for li, lr in enumerate(DPO_LRS):
+        for seed in (0, 2):
+            key = f"lora-dpo-b0-lr{lr:g}-s{seed}"
+            st = at("2026-04-06 00:00") + (li * 2 + (seed // 2)) * 5 * H
+            acc = 0.93 + 0.05 * (1 - abs(li - 2) / 8) + (0.002 if seed == 2 else 0.0)
+            res = dpo_run(w, project_id=pid, key=key, name=f"lora-dpo-lr{lr:g}-seed{seed}", datasets=[(ds_bloom, 1.0)],
+                          base_model_id=M["instruct"], steps=1700, start=st, step_seconds=9.0, lr=lr, warmup=0.1,
+                          schedule="cosine", global_batch=64, seq_len=4096, gpu="TPU v5p-8", gpus=None, cost_rate=0.0,
+                          tags=["dpo", "lora", "lr-sweep"], config=dpo_cfg(lr, seed, "B=0 (default)"), log_every=17,
+                          accuracy=min(0.985, acc), margin=4.0 + 3.0 * (1 - abs(li - 2) / 8),
+                          hyperparams={"beta": 0.1, "lora_r": 64, "lora_alpha": 64, "lora_init": "B=0 (default)", "seed": seed},
+                          group_name="lora-dpo-lr-sweep (#4556)",
+                          description=f"One of the 18 runs of the LoRA-DPO learning-rate sweep (9 learning rates × 2 seeds) "
+                                      f"on Marin 8B Instruct with the default B=0 LoRA initialization: lr {lr:g}, seed {seed}. The "
+                                      f"design is published; per-run curves, dates and step times are simulated (per-run "
+                                      f"results are not published).",
+                          source=I4556, provenance="simulated", ckpt_every=1699 if (lr == 1e-05 and seed == 0) else None)
+            sweep.append(res["run_id"])
+            w.conn.execute("UPDATE runs SET framework='Levanter train_dpo (LoRA)' WHERE id=?", (res["run_id"],))
+            add_jobs(w, pid, res["run_id"], f"lora-dpo-lr{lr:g}-seed{seed}", "completed", st, res["end"],
+                     [{"name": "trainer", "cluster": C["tpu"], "gpu": "TPU v5p-8", "gpus": None}])
+            if lr == 1e-05 and seed == 0:
+                rel = model("dpo-lr1e5-s0", "marin-8b-dpo-lora-lr1e5-seed0-step1699",
+                            hf_repo="marin-community/marin-8b-dpo-lora-lr1e5-seed0-step1699", arch="Dense + LoRA r=64 (merged export)",
+                            params_total=8.0, params_active=8.0, parent_id=M["instruct"], run_key=key, step=1699, stage="DPO",
+                            created_at=at("2026-04-13 00:00"), status="released", source=DPO_CKPT,
+                            notes="Released sweep checkpoint (lr 1e-5, seed 0, final step); the Hugging Face card is empty.")
+                w.conn.execute("UPDATE runs SET output_model_id=? WHERE id=?", (rel, res["run_id"]))
+                w.conn.execute("UPDATE checkpoints SET model_id=? WHERE run_id=? AND step=1699", (rel, res["run_id"]))
+    st = at("2026-04-15 00:00")
+    res = dpo_run(w, project_id=pid, key="lora-dpo-a0-lr1e-6", name="lora-dpo-A0-init-lr1e-6", datasets=[(ds_bloom, 1.0)],
+                  base_model_id=M["instruct"], steps=1700, start=st, step_seconds=9.0, lr=1e-6, warmup=0.1, schedule="cosine",
+                  global_batch=64, seq_len=4096, gpu="TPU v5p-8", gpus=None, cost_rate=0.0, tags=["dpo", "lora", "a0-init"],
+                  config=dpo_cfg(1e-6, 0, "A=0"), log_every=17, accuracy=0.99, margin=7.0,
+                  hyperparams={"beta": 0.1, "lora_r": 64, "lora_alpha": 64, "lora_init": "A=0"},
+                  group_name="lora-dpo-lr-sweep (#4556)",
+                  description="Follow-up arm of #4556: the same LoRA-DPO recipe with LoRA A initialized to 0 instead of B. "
+                              "Marin: A=0 'ties or beats B=0 on every metric at every LR'; this lr 1e-6 arm has the best A=0 "
+                              "DPO eval accuracy, 0.99314 (published, stored as an eval). The curves are simulated; the seed "
+                              "count of the follow-up is not stated, so one arm is shown.",
+                  source=I4556B, provenance="simulated")
+    a0 = model("dpo-a0-lr1e-6", "Marin 8B LoRA-DPO, A=0 init, lr 1e-6", arch="Dense + LoRA r=64", params_total=8.0,
+               params_active=8.0, parent_id=M["instruct"], run_key="lora-dpo-a0-lr1e-6", step=1700, stage="DPO",
+               created_at=res["end"], status="not released", source=I4556B,
+               notes="Best A=0 arm by DPO eval accuracy (0.99314). Not released.")
+    w.conn.execute("UPDATE runs SET output_model_id=?, framework='Levanter train_dpo (LoRA)' WHERE id=?", (a0, res["run_id"]))
+    add_jobs(w, pid, res["run_id"], "lora-dpo-A0-init-lr1e-6", "completed", st, res["end"],
+             [{"name": "trainer", "cluster": C["tpu"], "gpu": "TPU v5p-8", "gpus": None}])
+    a0_run = res["run_id"]
+
+    # IFBench-targeted DPO on Tulu 3 8B (#5244)
+    ifb = {}
+    for i, arm in enumerate(("strict", "loose", "soft")):
+        key = f"ifbench-dpo-{arm}"
+        st = at("2026-04-20 00:00") + i * 8 * H
+        res = dpo_run(w, project_id=pid, key=key, name=f"ifbench-dpo-{arm}", datasets=[(ds_ifb, 1.0)],
+                      base_model_id=M["tulu3-dpo"], steps=300, start=st, step_seconds=12.0, lr=5e-6, warmup=0.1,
+                      schedule="cosine", global_batch=64, seq_len=4096, gpu="TPU v5p-8", gpus=None, cost_rate=0.0,
+                      tags=["dpo", "ifbench"], log_every=3, accuracy=0.8, margin=2.0, group_name="ifbench-dpo (#5244)",
+                      config="\n".join(["# IFBench-targeted DPO arm (#5244); training hyperparameters are not published",
+                                        "base: allenai/Llama-3.1-Tulu-3-8B-DPO", f"pairs: {arm} arm", "framework: Levanter train_dpo",
+                                        "hardware: TPU v5p-8", "# steps, lr and batch below are simulation placeholders"]),
+                      hyperparams={"note": "lr, batch and steps not published; 300 steps at 5e-6 are placeholders", "arm": arm},
+                      description=f"IFBench-targeted DPO on Tulu 3 8B DPO with the {arm} pair construction (#5244). The IFBench "
+                                  f"and IFEval results are published; training hyperparameters are not, so steps, curves and "
+                                  f"dates are simulation placeholders.",
+                      source=I5244, provenance="simulated")
+        mid = model(f"ifbench-{arm}", f"Tulu 3 8B + IFBench DPO ({arm})", arch="Dense (Llama 3.1 8B)", params_total=8.0,
+                    params_active=8.0, parent_id=M["tulu3-dpo"], run_key=key, step=300, stage="DPO", created_at=res["end"],
+                    status="not released", source=I5244, notes=f"Output of the {arm} arm; not released.")
+        w.conn.execute("UPDATE runs SET output_model_id=?, framework='Levanter train_dpo' WHERE id=?", (mid, res["run_id"]))
+        add_jobs(w, pid, res["run_id"], f"ifbench-dpo-{arm}", "completed", st, res["end"],
+                 [{"name": "trainer", "cluster": C["tpu"], "gpu": "TPU v5p-8", "gpus": None}])
+        ifb[arm] = (res, mid)
+    kit.metric_defs(w, pid, "trl_sft")
+    kit.metric_defs(w, pid, "trl_dpo")
+
+    # evals
+    E = Evals(w, pid)
+    retro_models = [M["olmo2-sft"], M["olmo2-instruct"], M["llama31-instruct"], M["llama31-tulu"], M["instruct"]]
+    sft_run_id = rid("run", pid, "exp1237-sft")
+    for key, name, n, note, vals in RETRO:
+        per_task = n <= 550
+        E.bench(key, name, "Instruct (retro)", "accuracy", n, 1,
+                f"{name} as run for the Marin 8B retrospective's SFT table: lm-eval-harness with chat templates"
+                + (" (AlpacaEval through its own harness)" if key == "alpacaeval" else "") +
+                f". The task count is not stated; {note}." + ("" if per_task else " Only the score is stored (no per-task results)."),
+                RETRO, per_task=per_task)
+        for ci, (mid, v) in enumerate(zip(retro_models, vals)):
+            ours = ci == 4
+            E.ev(key, mid, pc(v), started=at("2025-05-14 00:00") + ci * 600, source=RETRO, ek=f"retro|{ci}",
+                 run_id=sft_run_id if ours else None, step=10228 if ours else None,
+                 config={"source": "Marin 8B retrospective, SFT evaluation table"})
+    for key, name, vals in RETRO_AVG:
+        E.bench(key, name, "Instruct (retro)", "average", 10, 1,
+                f"{name} over the retro's ten tasks (AlpacaEval, IFEval, GSM8K-CoT, BBH, MMLU, GPQA, MMLU-Pro, MuSR, MATH Hard, "
+                f"HumanEval). Average rank: Marin 8B SFT 2.6, second to Llama 3.1 Tulu's 1.6. Only the average is stored.",
+                RETRO, per_task=False)
+        for ci, (mid, v) in enumerate(zip(retro_models, vals)):
+            ours = ci == 4
+            E.ev(key, mid, pc(v), started=at("2025-05-14 02:00") + ci * 600, source=RETRO, ek=f"retro|{ci}",
+                 run_id=sft_run_id if ours else None, step=10228 if ours else None, stderr=None)
+            w.conn.execute("UPDATE evals SET stderr=NULL WHERE id=?", (rid("eval", E.b[key].id, f"retro|{ci}"),))
+    E.bench("dpo-eval-acc", "Bloom SpecEval v2 DPO eval accuracy", "Preference", "accuracy", 1000, 1,
+            "Held-out preference accuracy of the LoRA-DPO policy on Bloom SpecEval v2 (#4556 follow-up). Only the best A=0 "
+            "value (0.99314 at lr 1e-6) is published. The eval set size is not published; 1,000 pairs is an assumption. Only "
+            "the score is stored.", I4556B, per_task=False)
+    E.ev("dpo-eval-acc", a0, 0.99314, started=w.conn.execute("SELECT ended_at FROM runs WHERE id=?", (a0_run,)).fetchone()[0] + 600,
+         source=I4556B, ek="a0-lr1e-6", run_id=a0_run, step=1700)
+    E.bench("ifbench-test", "IFBench_test strict", "Instruction following", "strict pass-all", 300, 1,
+            "IFBench_test, 300 prompts, strict pass-all rate with the vendored IFBench verifiers (#5244).", I5244)
+    E.bench("ifeval-strict", "IFEval strict (IFEvalG)", "Instruction following", "strict pass-all", 541, 1,
+            "IFEval, 541 prompts, strict pass-all with the vendored IFEvalG verifiers (#5244). Not the same harness as the "
+            "retro's IFEval column.", I5244)
+    t0 = at("2026-04-19 00:00")
+    E.ev("ifbench-test", M["tulu3-dpo"], 60 / 300, started=t0, source=I5244, ek="base")
+    E.ev("ifeval-strict", M["tulu3-dpo"], 414 / 541, started=t0, source=I5244, ek="base")
+    for arm, ifb_v, ife_v in (("strict", 75, 433), ("loose", 88, 427), ("soft", 81, 417)):
+        res, mid = ifb[arm]
+        E.ev("ifbench-test", mid, ifb_v / 300, started=res["end"] + 600, source=I5244, ek=arm, run_id=res["run_id"], step=300)
+        E.ev("ifeval-strict", mid, ife_v / 541, started=res["end"] + 900, source=I5244, ek=arm, run_id=res["run_id"], step=300)
+
+    kit.report(w, pid, "8b-instruct", "Marin 8B Instruct: SFT results and preference-tuning experiments",
+               "Marin (8B retrospective, #4556, #5244)", at("2026-04-25 00:00"),
+               "What the retro and two DPO issues found. Marin 8B Instruct is SFT-only; the preference-tuning work is "
+               "experimental and not part of the released instruct model.",
+               [{"claim": "Marin 8B SFT averages higher than OLMo 2 SFT, OLMo 2 Instruct and Llama 3.1 Instruct.", "verdict": "upheld",
+                 "evidence": "Retro, 10-task average: 43.8 vs 37.7, 38.7 and 39.8 (46.2 vs 41.4, 44.6, 46.8 without outliers)."},
+                {"claim": "Marin 8B SFT matches Llama 3.1 Tulu.", "verdict": "rejected",
+                 "evidence": "43.8 vs 50.0 (46.2 vs 51.9 without outliers); average rank 2.6 vs Tulu's 1.6."},
+                {"claim": "It is the best of the five on BBH, GPQA and MMLU-Pro.", "verdict": "upheld",
+                 "evidence": "BBH 46.0, GPQA 29.5, MMLU-Pro 31.2, each the highest in the retro table."},
+                {"claim": "SFT preserved base-model knowledge tasks.", "verdict": "rejected",
+                 "evidence": "Retro: 'We see an unfortunate degradation in \"base model\" tasks like MMLU'."},
+                {"claim": "Initializing LoRA A=0 instead of the default B=0 is at least as good for DPO.", "verdict": "upheld",
+                 "evidence": "#4556: A=0 'ties or beats B=0 on every metric at every LR'; best A=0 DPO eval accuracy 0.99314 at lr 1e-6."},
+                {"claim": "IFBench-targeted DPO raises IFBench without hurting IFEval.", "verdict": "upheld",
+                 "evidence": "#5244: IFBench strict 20.00% → 25.00 / 29.33 / 27.00 (strict / loose / soft arms); IFEval strict "
+                             "76.52% → 80.04 / 78.93 / 77.08."},
+                {"claim": "The paper-style 24,153-pair set and LR sweep improve further.", "verdict": "open",
+                 "evidence": "Launched (lr 3e-6, 5e-6, 2e-5); results not recorded in #5244."}],
+               run_keys=("exp1237-sft", "lora-dpo-a0-lr1e-6", "ifbench-dpo-strict", "ifbench-dpo-loose", "ifbench-dpo-soft"))
+    return pid
+
+
+
+# ================================================================== (b) Agentic RL data: A3, TaskTrove, follow-ups
+
+# The 35 A3 entries of #6187: 20 finished runs, 13 without a winner checkpoint, 2 extra HF exports. `tt` is the same-name
+# source in TaskTrove (name, same version as A3?). Anchors are published values; `sim` marks anchors I chose where #6187
+# reports no reward (the run description says so).
+A3 = [
+    dict(key="inferredbugs", ds="DCAgent/inferredbugs-sandboxes-verifier", real="marin-a3-inferredbugs", end="2026-05-25 03:03",
+         best=55, reported="0.602", model="laion/a3-rl-DCAgent_inferredbugs-sandboxes-verifier-55-8B", domain="swe",
+         maxgen=8192, segments=7, tt=("DCAgent__inferredbugs-sandboxes-verifier", True), count=9659, grader="regex", tok=3800,
+         example=("inferredbugs-6581", "# InferredBugs Task - Java ## Project Information **Project:** jackson-core **Bug ID:** 30 "
+                  "**Language:** java ## Bug Information ### File-Level Changes: **Before (Buggy File):** …")),
+    dict(key="code-contests-noblock", ds="DCAgent/code-contests-noblock", best=5, reported="0.147 (peak 0.242 @ s27)", steps=80,
+         anchors={1: 0.17, 5: 0.147, 27: 0.242, 80: 0.09}, start="2026-05-22 12:00", med=1100,
+         model="laion/a3-rl-DCAgent_code-contests-noblock-5-8B", domain="code", tt=("DCAgent__code-contests-noblock", True),
+         count=8728, tok=3600),
+    dict(key="nemotron-code-oracle-filtered", ds="SankalpKJ/nemotron-code-oracle-filtered", best=60,
+         reported="0.465 (peak 0.512 @ s41)", steps=80, anchors={1: 0.36, 41: 0.512, 60: 0.465, 80: 0.44},
+         start="2026-05-22 13:00", med=1300, model="laion/a3-rl-SankalpKJ_nemotron-code-oracle-filtered-60-8B", domain="code",
+         tt=("SankalpKJ__nemotron-code-oracle-filtered", True), count=15165, tok=3400),
+    dict(key="llm-verifier-freelancer", ds="DCAgent/llm-verifier-freelancer", real="marin-a3-llm-verifier-freelancer",
+         end="2026-05-25 08:49", best=70, reported="0.718 (peak a3 reward)",
+         model="laion/a3-rl-DCAgent_llm-verifier-freelancer-70-8B", domain="agentic", maxgen=8192, segments=11, grader="llm",
+         tok=8500, example=("llm_verifier-7175", "Design a Modern Tennis Academy at a tropical location … I am planning to develop "
+                            "a modern tennis academy that includes tennis courts, paddle courts, a gym, a canteen, a kids play "
+                            "area, and car parking.")),
+    dict(key="nl2bash", ds="DCAgent2/nl2bash-tasks-cleaned-oracle", real="marin-a3-nl2bash", end="2026-05-26 13:46", best=40,
+         reported="0.418 (peak 0.449 @ s46)", model="laion/a3-rl-DCAgent2_nl2bash-tasks-cleaned-oracle-40-8B",
+         domain="terminal", segments=3, tt=("DCAgent2__nl2bash-tasks-cleaned-oracle-v2", False), tok=3400),
+    dict(key="curriculum-easy", ds="DCAgent/exp_rpt_curriculum-easy", best=21, reported="0.680 (peak @ s13)", steps=24,
+         anchors={1: 0.52, 13: 0.680, 24: 0.63}, start="2026-05-23 13:00", med=900,
+         model="laion/a3-rl-DCAgent_exp_rpt_curriculum-easy-21-8B", domain="code", tt=("DCAgent__exp_rpt_curriculum-easy", True),
+         count=509, tok=3000, why_steps="the checkpoint is step 21; 24 steps is an assumption"),
+    dict(key="e2egit-v2", ds="DCAgent/exp_rpt_e2egit-v2", best=10, reported="0.679 (EMA)", steps=16, anchors={1: 0.60, 16: 0.66},
+         ema={10: 0.679}, start="2026-05-23 20:00", med=900, model="laion/a3-rl-DCAgent_exp_rpt_e2egit-v2-10-8B", domain="code",
+         tt=("DCAgent__exp_rpt_e2egit-v2", True), count=487, tok=3000,
+         why_steps="two epochs of the 487-task same-name TaskTrove source is about 16 steps"),
+    dict(key="e2egit-large", ds="DCAgent/exp_rpt_e2egit-large", best=15, reported="0.842 (EMA 0.864)", steps=80,
+         anchors={1: 0.80, 15: 0.842, 80: 0.82}, ema={15: 0.864}, start="2026-05-24 03:00", med=1000,
+         model="laion/a3-rl-DCAgent_exp_rpt_e2egit-large-15-8B", domain="code", tt=("DCAgent__exp_rpt_e2egit-large", True),
+         count=4998, tok=3000),
+    dict(key="if-structured", ds="laion/nemotron-gym-instruction-following-structured", best=75,
+         reported="0.92 / 0.95 (EMA 0.99)", steps=80, anchors={1: 0.55, 75: 0.92, 80: 0.91}, pass8={75: 0.95},
+         start="2026-05-24 12:00", med=650, model="laion/a3-rl-laion_nemotron-gym-instruction-following-structured-75-8B",
+         domain="if", tt=("laion__nemotron-gym-instruction-following-structured-v3", False), tok=1600,
+         note="The reported EMA 0.99 cannot be a trailing EMA (alpha 1/3) ending at a raw 0.92 over rewards ≤ 1; it is kept as reported."),
+    dict(key="agent-calendar", ds="laion/nemotron-gym-agent-calendar", real="marin-a3-nemotron-agent-calendar",
+         end="2026-06-02 17:42", best=80, reported="0.973 / 1.0 (EMA 0.979)",
+         model="laion/a3-rl-laion_nemotron-gym-agent-calendar-80-8B", domain="tool_use", segments=3,
+         tt=("laion__nemotron-gym-agent-calendar-v2", False), tok=2200),
+    dict(key="crosscodeeval-csharp-v4", ds="laion/exp_rpt_crosscodeeval-csharp-v4", best=50, reported="0.448 (max 0.570)",
+         steps=55, anchors={1: 0.30, 47: 0.570, 50: 0.448, 55: 0.44}, start="2026-05-25 04:00", med=900,
+         model="laion/a3-rl-laion_exp_rpt_crosscodeeval-csharp-v4-50-8B", domain="code",
+         tt=("laion__exp_rpt_crosscodeeval-csharp-v4", True), count=1768, tok=1800,
+         why_steps="two epochs of the 1,768-task same-name TaskTrove source is about 55 steps; the step of the 0.570 maximum "
+                   "is not published and is placed at 47"),
+    dict(key="web-search-mcqa", ds="laion/nemotron-gym-knowledge-web-search-mcqa", best=25, reported="0.59 / 0.86", steps=80,
+         anchors={1: 0.50, 25: 0.59, 80: 0.55}, pass8={25: 0.86}, start="2026-05-25 09:30", med=800,
+         model="laion/a3-rl-laion_nemotron-gym-knowledge-web-search-mcqa-25-8B", domain="search",
+         tt=("laion__nemotron-gym-knowledge-web-search-mcqa-v2", False), tok=2200),
+    dict(key="agent-workplace-v2", ds="laion/nemotron-gym-agent-workplace-v2", best=5, reported="data-limited, reward flat",
+         steps=10, anchors={1: 0.25, 10: 0.25}, sim=True, start="2026-05-26 14:30", med=900,
+         model="laion/a3-rl-laion_nemotron-gym-agent-workplace-v2-5-8B", domain="tool_use", tok=2600,
+         why_steps="#6187 calls the run data-limited; 10 steps is an assumption"),
+    dict(key="identity-following-v2", ds="laion/nemotron-gym-identity-following-v2", best=65,
+         reported="0.999 / 1.0 (strongest a3 reward)", steps=80, anchors={1: 0.86, 20: 0.985, 65: 0.999, 80: 0.998},
+         pass8={65: 1.0}, start="2026-05-26 18:00", med=500, model="laion/a3-rl-laion_nemotron-gym-identity-following-v2-65-8B",
+         domain="if", tt=("laion__nemotron-gym-identity-following-v4", False), tok=1200),
+    dict(key="math-advanced-calculations-v3", ds="laion/nemotron-gym-math-advanced-calculations-v3", best=60, reported="0.95",
+         steps=80, anchors={1: 0.72, 60: 0.95, 80: 0.94}, start="2026-05-27 00:00", med=600,
+         model="laion/a3-rl-laion_nemotron-gym-math-advanced-calculations-v3-60-8B", domain="math",
+         tt=("laion__nemotron-gym-math-advanced-calculations-v4", False), tok=1800),
+    dict(key="selfinstruct-naive", ds="DCAgent/selfinstruct-naive-sandboxes-2-verified", best=70,
+         reported="0.377 (EMA 0.393, succ 43.7%)", steps=80, anchors={1: 0.30, 70: 0.377, 80: 0.37}, ema={70: 0.393},
+         start="2026-05-27 06:00", med=1500, model="laion/a3-rl-DCAgent_selfinstruct-naive-sandboxes-2-verified-70-8B",
+         domain="terminal", tt=("DCAgent__selfinstruct-naive-sandboxes-2-verified-v3", False), tok=3600),
+    dict(key="mix-h2-language-proportional", ds="DCAgent/mix_h2_language_proportional", best=65, reported="reached max_steps 80",
+         steps=80, anchors={1: 0.36, 65: 0.45, 80: 0.44}, sim=True, start="2026-05-27 14:00", med=1400,
+         model="laion/a3-rl-DCAgent_mix_h2_language_proportional-65-8B", domain="code", tok=3400),
+    dict(key="mix-h4-binary-easy", ds="DCAgent/mix_h4_binary_easy", best=50, reported="2-epoch data-complete @ s67", steps=67,
+         anchors={1: 0.40, 50: 0.50, 67: 0.48}, sim=True, start="2026-05-28 08:00", med=1400,
+         model="laion/a3-rl-DCAgent_mix_h4_binary_easy-50-8B", domain="code", tt=("DCAgent__mix_h4_binary_easy", True),
+         count=1996, tok=3200, why_steps="#6187: two epochs were data-complete at step 67"),
+    dict(key="pymethods2test-large", ds="DCAgent/exp_rpt_pymethods2test-large", real="marin-a3-pymethods2test-large",
+         end="2026-06-05 08:35", best=80, reported="0.74 / 0.83 (paper hero dataset)",
+         model="laion/a3-rl-DCAgent_exp_rpt_pymethods2test-large-80-8B", domain="code", segments=7,
+         tt=("DCAgent__exp_rpt_pymethods2test-large-v2", False), tok=4500),
+    dict(key="curriculum-medium", ds="DCAgent/exp_rpt_curriculum-medium", best=10, reported="0.281 (EMA 0.311)", steps=16,
+         anchors={1: 0.33, 10: 0.281, 16: 0.27}, ema={10: 0.311}, start="2026-05-28 16:00", med=950,
+         model="laion/a3-rl-DCAgent_exp_rpt_curriculum-medium-10-8B", domain="code",
+         tt=("DCAgent__exp_rpt_curriculum-medium-v2", False), tok=3200,
+         why_steps="the same-family TaskTrove source has 492 tasks (about 16 steps for two epochs); an assumption"),
+    # no winner checkpoint (#6187)
+    dict(key="unitsyn-python-large", ds="DCAgent/exp_rpt_unitsyn-python-large", status="failed", steps=14,
+         anchors={1: 0.30, 10: 0.08, 14: 0.0}, sim=True, start="2026-05-29 00:00", med=1100,
+         reason="Zero-reward collapse (#6187); no winner checkpoint. Hugging Face nonetheless holds a step-10 export.",
+         export=(10, "laion/a3-rl-DCAgent_exp_rpt_unitsyn-python-large-10-8B"), domain="code",
+         tt=("DCAgent__exp_rpt_unitsyn-python-large-v2", False), tok=3000),
+    dict(key="ghactions-v3", ds="laion/exp_rpt_ghactions-v3", status="failed", steps=24, anchors={1: 0.45, 20: 0.12, 24: 0.0},
+         sim=True, start="2026-05-29 06:00", med=900,
+         reason="Zero-reward collapse (#6187); no winner checkpoint. Hugging Face nonetheless holds a step-20 export.",
+         export=(20, "laion/a3-rl-laion_exp_rpt_ghactions-v3-20-8B"), domain="terminal", tt=("laion__exp_rpt_ghactions-v3", True),
+         count=9930, tok=2600),
+    dict(key="swegym-tasks-patched-validated-v2", ds="swegym-tasks-patched-validated-v2", status="failed", steps=10,
+         anchors={1: 0.04, 10: 0.0}, sim=True, start="2026-05-29 12:00", med=1600,
+         reason="Zero-reward collapse (#6187); no model.", domain="swe",
+         tt=("laion__swegym-tasks-patched-validated-v5", False), tok=4200),
+    dict(key="nemotron-gym-knowledge-mcqa", ds="nemotron-gym-knowledge-mcqa", notrun=True, domain="other",
+         tt=("laion__nemotron-gym-knowledge-mcqa-v2", False)),
+    dict(key="nemotron-gym-knowledge-openqa-v2", ds="nemotron-gym-knowledge-openqa-v2", notrun=True, domain="other",
+         tt=("laion__nemotron-gym-knowledge-openqa-v4", False)),
+    dict(key="nemotron-gym-safety-v2", ds="nemotron-gym-safety-v2", notrun=True, domain="chat",
+         tt=("laion__nemotron-gym-safety-v3", False)),
+    dict(key="nemotron-math-oracle-filtered", ds="SankalpKJ/nemotron-math-oracle-filtered", notrun=True, domain="math",
+         tt=("SankalpKJ__nemotron-math-oracle-filtered-v2", False)),
+    dict(key="methods2test-large-v3", ds="methods2test-large-v3", status="stopped", steps=5, anchors={1: 0.2, 5: 0.2}, sim=True,
+         start="2026-05-30 08:00", med=1300, reason="Stopped early: pre-fanout orchestration confound (#6187); no model.",
+         domain="code", tt=("laion__exp_rpt_methods2test-large-v4", False), tok=3600,
+         why_steps="#6187 says only 'stopped early'; 5 steps is an assumption"),
+    dict(key="stack-junit-v6", ds="stack-junit-v6", status="stopped", steps=5, anchors={1: 0.15, 5: 0.15}, sim=True,
+         start="2026-05-30 12:00", med=1300, reason="Stopped early: pre-fanout orchestration confound (#6187); no model.",
+         domain="code", tt=("laion__exp_rpt_stack-junit-v6", True), count=843, tok=3600,
+         why_steps="#6187 says only 'stopped early'; 5 steps is an assumption"),
+    dict(key="nemotron-junit", ds="nemotron-junit", status="stopped", steps=5, anchors={1: 0.2, 5: 0.2}, sim=True,
+         start="2026-05-30 16:00", med=1300, reason="Stopped early: pre-fanout orchestration confound (#6187); no model.",
+         domain="code", tt=("laion__exp_rpt_nemotron-junit-v6", False), tok=3600,
+         why_steps="#6187 says only 'stopped early'; 5 steps is an assumption"),
+    dict(key="stack-bash-v3", ds="laion/exp_rpt_stack-bash-v3", status="stopped", cancel=True, start="2026-06-04 22:00",
+         med=1850, anchors={1: 0.35, 74: 0.42}, sim=True, domain="terminal",
+         reason="Still running when the sweep concluded; cancelled mid-run with no winner registered (#6187). Hugging Face "
+                "nonetheless holds a step-70 export.", export=(70, "laion/a3-rl-laion_exp_rpt_stack-bash-v3-70-8B"), tok=3000),
+    dict(key="methods2test-large-v2", ds="methods2test-large-v2", status="stopped", cancel=True, start="2026-06-05 14:00",
+         med=1600, anchors={1: 0.25, 49: 0.28}, sim=True, domain="code",
+         reason="Still running when the sweep concluded; cancelled mid-run with no winner registered (#6187).",
+         tt=("laion__exp_rpt_methods2test-large-v4", False), tok=3600),
+    dict(key="codenet-python-v2", ds="codenet-python-v2", status="stopped", cancel=True, start="2026-06-05 20:00", med=1200,
+         anchors={1: 0.40, 48: 0.44}, sim=True, domain="code",
+         reason="Still running when the sweep concluded; cancelled mid-run with no winner registered (#6187).",
+         tt=("laion__exp_rpt_codenet-python-v4", False), tok=2600),
+    # HF exports not in the #6187 table
+    dict(key="pymethods2test-v3", ds="DCAgent/exp_rpt_pymethods2test-v3", status="stopped", steps=10, anchors={1: 0.55, 10: 0.6},
+         sim=True, start="2026-05-31 10:00", med=1000,
+         reason="Not in the #6187 table and its outcome is not reported; Hugging Face holds a step-10 export created 2026-06-01.",
+         export=(10, "laion/a3-rl-DCAgent_exp_rpt_pymethods2test-v3-10-8B"), domain="code",
+         tt=("DCAgent__exp_rpt_pymethods2test-v3", True), count=500, tok=3800,
+         why_steps="only the step-10 export is known; 10 steps is an assumption"),
+    dict(key="unitsyn-python-v3", ds="DCAgent/exp_rpt_unitsyn-python-v3", status="stopped", steps=10, anchors={1: 0.5, 10: 0.55},
+         sim=True, start="2026-05-31 16:00", med=1000,
+         reason="Not in the #6187 table and its outcome is not reported; Hugging Face holds a step-10 export created 2026-06-01.",
+         export=(10, "laion/a3-rl-DCAgent_exp_rpt_unitsyn-python-v3-10-8B"), domain="code",
+         tt=("DCAgent__exp_rpt_unitsyn-python-v4", False), tok=3600,
+         why_steps="only the step-10 export is known; 10 steps is an assumption"),
+]
+A3_CONCLUSION = ("\"The a3 config (binary reward + RLOO-n + `loss_reduction: token_mean`, terminal_bench agentic) is now known to be "
+                 "uninformative about the underlying datasets' utility: binary reward leaves the majority of tasks with zero GRPO "
+                 "gradient and launders a spurious brevity-success correlation into the policy, so clean optimization collapses "
+                 "to concision / overconfident early-termination.\" (#6187)")
+A3_END = "2026-06-06 12:00"
+A3_MASKED = ["DaytonaError", "EnvironmentStartTimeoutError", "NetworkError", "ConnectionError", "RewardFileNotFoundError",
+             "RewardFileEmptyError", "AgentEnvironmentTimeoutError", "ContextLengthExceededError"]
+
+TT_MODES = {  # mode: (grader kind, reward kind, contract from the tasktrove-verify README, tasks in the release)
+    "judge-reference": ("llm_judge", "scalar", "Exact-match gate, then a configured judge model scores 0–1 against the reference answer(s).", None),
+    "judge-checklist": ("rubric", "partial", "A configured judge model answers each yes/no criterion; the reward is the fraction answered yes.", None),
+    "math": ("math_verify", "binary", "Expression equality through math-verify.", 219315),
+    "ifeval": ("rule_checks", "binary", "Deterministic instruction-following constraints; every constraint must hold.", 46391),
+    "json-schema": ("schema", "binary", "JSON, YAML or TOML checked against a JSON Schema.", 42798),
+    "pytest": ("unit_tests", "binary", "pytest JSON report with required and protected tests.", 40975),
+    "stdio": ("execution", "binary", "Program stdout over hidden cases; every case must pass, all or nothing.", 37008),
+    "script": ("execution", "binary", "Legacy test.sh fallback with normalized reward files and fail-closed errors.", 27956),
+    "mcq": ("exact_match", "binary", "The expected option letter.", 23860),
+    "xml-elements": ("schema", "binary", "Required XML elements and attributes.", 14013),
+    "reasoning-gym": ("execution", "partial", "The named reasoning-gym scorer and entry; several reasoning-gym datasets award partial credit.", 13712),
+    "exact": ("exact_match", "binary", "Normalized string equality.", 13663),
+    "csv-columns": ("schema", "binary", "Required CSV header columns.", 2802),
+}
+TT_STATUSES = ("Statuses are `scored`, `invalid_task` and `infra_error`. A scored result writes Harbor's reward.json and "
+               "reward.txt; invalid tasks and infrastructure failures omit those files, so the trial can be masked instead of "
+               "recorded as a zero.")
+
+
+def tt_mode(env_rec):
+    d = env_rec["grader"]["details"]
+    if d.startswith("judge mode, reference"):
+        return "judge-reference"
+    if d.startswith("judge mode, checklist"):
+        return "judge-checklist"
+    return re.search(r"mode ([\w-]+)", d).group(1)
+
+
+def tt_parse(env_rec):
+    v = env_rec["validation"]
+    m = re.match(r"Source verdict keep \(([^)]*)\): (.*) Rejected rows in this source: (.*)\.$", v)
+    fam, verdict, rej = m.group(1), m.group(2).strip(), m.group(3)
+    rej = {} if rej == "none" else ast.literal_eval(rej)
+    return fam, verdict, rej
+
+
+def delta_check(name, note=""):
+    d = DELTA_BY.get(name)
+    if not d:
+        return None
+    src, dom, q, qb, g = d
+    return {"name": "Reward gap across models (2026-08-20)", "status": "pass", "source": TT_DELTAS,
+            "detail": f"Mean verifier reward on {src} ({dom}, ≤ 300 trials): Qwen3-Coder-30B-A3B {q:.2f}, Qwen3.5-122B-A10B "
+                      f"{qb:.2f}, GLM 5.2 {g:.2f} (gap {g - q:+.2f}). Marin kept sources for RL only when the gap was ≥ 0.10 "
+                      f"and monotonic; 24 sources qualified, with a mean GLM 5.2 − Qwen3-Coder gap of 0.22." + note}
+
+
+def build_agentic(w, org_id, C):
+    recipe = load_json("recipe.json.gz")
+    pid = kit.project(
+        w, org_id, "agentic-rl-data", "Agentic RL data: A3 sweep, TaskTrove and follow-ups",
+        "Which data makes agentic RL work? The A3 sweep (#6187) trained one RLOO-N run per dataset from a fixed Qwen3-8B "
+        "agent on 56 GH200s (35 documented datasets, 20 finished runs) and concluded that the design was uninformative about "
+        "dataset utility. The follow-ups on Qwen3-Coder-30B-A3B repaired the task corpus (#7784), tuned the recipe one knob at "
+        "a time (#7785, 22 models, ~53k GPU-hours) and swept data sources against a fixed holdout (#8942). TaskTrove Clean "
+        "released 861,848 validated Harbor tasks from 1,739,326 rows (43 of 93 sources), with a written reason for every "
+        "rejection.",
+        [{"title": "Issue #6187: A3 single-dataset RL ablations", "url": I6187},
+         {"title": "#6187 comment: why the sweep stopped", "url": I6187C},
+         {"title": "A3 reward-vs-steps report", "url": A3_REPORT}, {"title": "A3 rl_config.json (pymethods2test-large)", "url": A3_CFG},
+         {"title": "A3 SFT base model card", "url": A3_BASE}, {"title": "A3 training traces", "url": A3_TRACES},
+         {"title": "TaskTrove Clean dataset card, manifest and ledger", "url": TT},
+         {"title": "TaskTrove conversion README", "url": TT_README}, {"title": "tasktrove-verify README", "url": TT_VERIFY},
+         {"title": "TaskTrove Clean project logbook", "url": TT_LOG}, {"title": "Reward deltas report (2026-08-20)", "url": TT_DELTAS},
+         {"title": "Issue #7784: TaskTrove data-quality sweep", "url": I7784}, {"title": "Issue #7785: TaskTrove HPO", "url": I7785},
+         {"title": "#7785 report (2026-08-18)", "url": HPO_REPORT}, {"title": "Issue #8942: data-source sweep", "url": I8942},
+         {"title": "Best Qwen3-Coder RL configurations (gist)", "url": Q3C_GIST}],
+        "Published: the metrics of five A3 runs, four #7785 arms and three #8942 runs (every logged step, from the SkyRL tables "
+        "and logs shipped with the checkpoints); the A3 recipe, dataset list, statuses, checkpoint steps and rewards; TaskTrove "
+        "Clean's counts, rejection statuses, grader modes, per-source verdicts, example tasks and validation results; the #7785 "
+        "and #8942 configurations, holdout scores and claims. Simulated to agree with them: the curves of the 26 A3 runs "
+        "without public logs (anchored on each published checkpoint reward, peak and EMA; where #6187 reports no reward the "
+        "run says so), dates and step times where not logged, all rollouts, task difficulty and placeholder tasks beside the "
+        "one real example per source. A3 runs have no held-out evals: Marin never summarized them. Dataset names are "
+        "Marin's; the no-winner A3 entries keep the short names #6187 uses.",
+        at("2026-05-20 00:00"), pins=["reward/avg_raw_reward", "reward/avg_pass_at_8", "policy/policy_entropy"])
+    M = {}
+
+    def model(key, name, kind="checkpoint", **kw):
+        M[key] = kit.model(w, pid, key, name, kind, **kw)
+        return M[key]
+
+    model("qwen3-8b", "Qwen3-8B", "base", hf_repo="Qwen/Qwen3-8B", arch="Dense (Qwen3)", params_total=8.0, params_active=8.0,
+          stage="Pretrained", created_at=at("2026-02-01 00:00"), status="available", source=A3_BASE,
+          notes="Nominal size from the model name; base of the A3 agent SFT.")
+    model("q3c", "Qwen3-Coder-30B-A3B-Instruct", "base", hf_repo="Qwen/Qwen3-Coder-30B-A3B-Instruct", arch="MoE",
+          params_total=30.0, params_active=3.0, stage="Instruct", created_at=at("2026-07-01 00:00"), status="available",
+          source=I7785, notes="Nominal sizes from the name. Base of #7784, #7785 and #8942; RL window 32,768 / 4,096 tokens.")
+    model("qwen35-122b", "Qwen3.5-122B-A10B-FP8", "teacher", hf_repo="Qwen/Qwen3.5-122B-A10B-FP8", arch="MoE",
+          params_total=122.0, params_active=10.0, created_at=at("2026-07-15 00:00"), status="external", source=HPO_REPORT,
+          notes="Teacher reference: mean verifier reward 0.208 on DCAgent/exp_rpt_multifile (terminus-2, 32k window).")
+    model("glm52", "GLM 5.2", "teacher", created_at=at("2026-07-15 00:00"), status="external", source=HPO_REPORT,
+          notes="Teacher reference: mean verifier reward 0.351 on DCAgent/exp_rpt_multifile; third model of the reward-delta study.")
+    model("glm53", "GLM-5.3 (MCQA router)", "judge", created_at=at("2026-09-01 00:00"), status="external", source=TT_README,
+          notes="Routes mechanically valid TaskTrove MCQA rows to rl, sft or garbage through the GLM Batch API with a strict "
+                "JSON schema.")
+
+    # graders ------------------------------------------------------------------------------------------
+    G = {}
+    for mode, (kind, reward, contract, n) in TT_MODES.items():
+        base_mode = "judge" if mode.startswith("judge") else mode
+        comps = [{"name": mode, "weight": 1.0, "rule": contract}]
+        formula = {"binary": "reward = 1 if every check passes, else 0", "partial": "reward = share of checks passed",
+                   "scalar": "reward = judge score in [0, 1] after an exact-match gate"}[reward]
+        G[mode] = kit.grader(w, pid, f"tt|{mode}", f"tasktrove-verify {mode}", kind,
+                             f"TaskTrove grader mode '{base_mode}' (tasktrove-verify @ b76d03131c). {contract} "
+                             + (f"{n:,} tasks in the release use it. " if n else "379,355 tasks in the release use judge mode. ")
+                             + TT_STATUSES, comps, formula)
+    G["a3"] = kit.grader(w, pid, "a3|tests", "A3 task verifier (binary)", "unit_tests",
+                         "Each A3 dataset's own Harbor verifier (tests/test.sh) run after the Terminus-2 agent finishes, with "
+                         "reward shaping off. Failure classes: " + ", ".join(A3_MASKED) + " are masked (dropped from the "
+                         "batch); AgentTimeoutError passes through (graded as it stands); any other exception scores zero.",
+                         [{"name": "task verifier", "weight": 1.0, "rule": "Reward from tests/test.sh; binary for most sources."}],
+                         "reward = verifier result (masked on infrastructure errors)")
+    G["a3-llm"] = kit.grader(w, pid, "a3|llm", "A3 LLM verifier", "llm_judge",
+                             "An LLM verifier grades the deliverable. Although A3 is labeled binary, the public traces of this "
+                             "source show fractional trial rewards (0.45, 0.85).",
+                             [{"name": "LLM verifier", "weight": 1.0, "rule": "Score from the LLM verifier in [0, 1]."}])
+    G["a3-regex"] = kit.grader(w, pid, "a3|regex", "A3 regex method check", "regex",
+                               "TaskTrove's verdict on this source: it 'never compiles or runs; regex on the rewritten method "
+                               "body with guards that accept either polarity'.",
+                               [{"name": "regex check", "weight": 1.0, "rule": "Pattern match on the rewritten method body."}])
+    G["q3c"] = kit.grader(w, pid, "q3c|tests", "TaskTrove task verifier (#7785, #8942)", "unit_tests",
+                          "The source's task verifier under Harbor terminus-2. #7785 POLICY: binary rewards; the arms' model "
+                          "cards say 'campaign verifier is pass_ratio shaping', while the launch configs set advantage_estimator "
+                          "rloo_n and enable_reward_shaping false. Which reward the verifier returned is unresolved. #7785's "
+                          "rule for telling: trial verifier rewards are always binary; check a shaper by the integrality of "
+                          "reward/avg_raw_reward × rollouts per step.",
+                          [{"name": "task verifier", "weight": 1.0, "rule": "Binary per the #7785 POLICY."}])
+
+    # datasets -------------------------------------------------------------------------------------------
+    envs_rec = recipe["environments"][:43]
+    kept = []
+    for e in envs_rec:
+        fam, verdict, rej = tt_parse(e)
+        src = e["name"].split(": ", 1)[1]
+        kept.append(dict(rec=e, src=src, fam=fam, verdict=verdict, rej=rej, kept=e["task_count"],
+                         inp=e["task_count"] + sum(rej.values()), mode=tt_mode(e)))
+    KEPT_BY = {k["src"]: k for k in kept}
+    cat = {"science": "science", "other": "other", "math": "math", "chat": "chat", "if": "if", "code": "code", "swe": "swe",
+           "tool_use": "tool_use", "terminal": "terminal"}
+    dropped_rows = []
+    for name, fam, rows, reason in DROPPED:
+        dropped_rows.append({"source": name, "category": "dropped source",
+                             "data": {"source": name, "family": fam, "rows": rows, "verdict": "drop", "reason": reason}})
+    kit.dataset(
+        w, pid, "tasktrove-input", "TaskTrove (open-thoughts/TaskTrove @ 0292300)", "rl", rows=1739326,
+        hf_repo="open-thoughts/TaskTrove", license="apache-2.0 (upstream declaration)",
+        sources=[{"name": k["src"], "category": cat.get(k["rec"]["domain"], "other"), "rows": k["inp"],
+                  "url": TT_MANIFEST} for k in kept] +
+                [{"name": f"{name} (dropped)", "category": fam, "rows": rows, "url": TT} for name, fam, rows, _ in DROPPED],
+        samples=dropped_rows,
+        description="The input to TaskTrove Clean: 1,739,326 rows from 93 sources at revision 0292300. 43 sources were kept "
+                    "(1,526,908 input rows) and 50 were dropped whole (212,418 rows), each with a written reason in "
+                    "source_verdicts.json. The rows shown here are those 50 per-source verdicts, not task rows.",
+        created_at=at("2026-09-09 00:00"), source=TT_UPSTREAM, provenance="published")
+    samples = []
+    for k in kept:
+        ex = k["rec"]["example_task"]
+        if "withheld" in (ex.get("instruction") or ""):
+            continue
+        samples.append({"source": k["src"], "category": cat.get(k["rec"]["domain"], "other"),
+                        "data": {"messages": [{"role": "user", "content": ex["instruction"]}], "task_id": ex["id"],
+                                 "grader_mode": k["mode"], "reward": k["rec"]["reward"]}})
+    kit.dataset(
+        w, pid, "tasktrove-clean", "TaskTrove Clean (open-athena/task-trove)", "rl", rows=861848, parent_key="tasktrove-input",
+        hf_repo="open-athena/task-trove", license="apache-2.0 (upstream TaskTrove declaration; per-source terms retained)",
+        version="graders @ b76d03131c",
+        sources=[{"name": k["src"], "category": cat.get(k["rec"]["domain"], "other"), "rows": k["kept"], "url": TT_MANIFEST}
+                 for k in kept],
+        processing=[
+            {"step": "Drop whole sources", "rows_in": 1739326, "rows_out": 1526908,
+             "note": "50 of 93 sources rejected in source_verdicts.json with a written reason (212,418 rows, status dropped_source)."},
+            {"step": "Exact instruction dedup within each source", "rows_in": 1526908, "rows_out": 1472602,
+             "note": "duplicate 54,306 (largest: 44,182 safety, 9,003 tezos)."},
+            {"step": "Contract checks", "rows_in": 1472602, "rows_out": 1453109,
+             "note": "unsupported_variant 11,929 (the converter has no grading for the task shape); gold_in_instruction 4,850 "
+                     "(every hidden stdio case is a sample printed in the prompt); null_grader 2,703 (no stdio cases, or a "
+                     "schema any output satisfies); reviewed_defect 11 (manual review found a broken contract, golden or grader)."},
+            {"step": "Verifier probes", "rows_in": 1453109, "rows_out": 1449686,
+             "note": "verified:empty 2,433 (the grader cannot score an empty answer as 0); verified:gold_leak 990 (expected value "
+                     "visible in the instruction). For modes with safe probes: reject a nonzero score for an empty answer, a "
+                     "non-unit score for the oracle answer, or a positive score for a negative perturbation."},
+            {"step": "MCQA routing (GLM-5.3)", "rows_in": 1449686, "rows_out": 861848,
+             "note": "Mechanically valid MCQA rows routed to rl 23,860, sft 458,562 (kept out of the RL corpus), garbage 120,868 "
+                     "(defect, tie, answer mismatch, key conflict); 8,408 had no route mapping. An RL route requires high "
+                     "confidence, a matching derived choice, chained reasoning, prompt-contained evidence and no defect."}],
+        samples=samples,
+        description="861,848 retained Harbor tasks from 1,739,326 input rows (open-thoughts/TaskTrove @ 0292300): 43 of 93 "
+                    "sources, 19 converters, 12 grader modes, 39 distinct Dockerfiles. Each task ships instruction.md, "
+                    "task.toml, an environment Dockerfile with the pinned verifier, tests/test.sh calling tasktrove-verify and "
+                    "tests/verifier.toml declaring one grader mode; the oracle is kept outside the archive. Every rejected row "
+                    "(877,478) is in ledger.parquet with its status and error. Each rejected row has one status; the funnel "
+                    "orders the statuses as the README lists the checks. Rows shown are each kept source's real example task "
+                    "(the safety source's example is not reproduced).",
+        created_at=at("2026-09-18 00:00"), source=TT, provenance="published")
+    ds_a3sft = kit.dataset(
+        w, pid, "a3-sft-traces", "GLM-4.7 swesmith sandbox traces (A3 SFT data)", "sft", rows=9437,
+        hf_repo="DCAgent2/GLM-4.7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k",
+        sources=[{"name": "GLM-4.7 terminal-agent traces on swesmith sandboxes (oracle-verified, 120 s)", "category": "swe",
+                  "rows": 9437, "synthetic": True, "generator": "GLM-4.7", "url": A3_SFT_DATA}],
+        description="9,437 GLM-4.7 agent traces on swesmith sandboxes with tests, used to fine-tune Qwen3-8B into the fixed A3 "
+                    "start point.", created_at=at("2026-02-01 00:00"), source=A3_SFT_DATA, provenance="published")
+
+    # TaskTrove Clean environments (one per kept source) -------------------------------------------------------
+    TT_ENV = {}
+    validity = {"name": "Validity sample (release 2026.09.10.4)", "status": "pass", "source": TT_LOG,
+                "detail": "10 tasks per converter, 190 tasks: 190 of 190 empty workspaces scored 0; 90 of 94 oracles scored 1; "
+                          "of the 155 scorable candidates (Claude Sonnet solve scripts, $20.30 for 185 replies) 117 scored 1 and "
+                          "38 scored 0. The sample describes release 2026.09.10.x, not the published build."}
+    statuses = {"name": "Verifier statuses", "status": "pass", "source": TT_VERIFY, "detail": TT_STATUSES}
+    probes = {"name": "Probe rules", "status": "pass", "source": TT,
+              "detail": "Exact instruction dedup within the source; reject malformed contracts, missing verifier files, legacy "
+                        "grader dependencies, exposed solutions or long gold answers and invalid mode shapes; for modes with safe "
+                        "probes, reject a nonzero score for an empty answer, a non-unit score for the oracle answer, or a positive "
+                        "score for a negative perturbation; every rejected row goes to ledger.parquet."}
+    for k in kept:
+        rec, src = k["rec"], k["src"]
+        ex = rec["example_task"]
+        withheld = "withheld" in (ex.get("instruction") or "")
+        n_store = min(k["kept"], 40)
+        tasks = [(ex["id"], "Safety prompt (refuse harmful requests, help with benign ones); the text is not reproduced here."
+                  if withheld else ex["instruction"], ["published example"])]
+        for i in range(1, n_store):
+            tasks.append((f"{src}/task-{i:05d}", f"One of the {k['kept']:,} tasks of {src} in TaskTrove Clean; only the source's "
+                                                  f"real example task is stored, the rest are placeholders.", ["placeholder"]))
+        rej_txt = ", ".join(f"{s} {n:,}" for s, n in sorted(k["rej"].items(), key=lambda kv: -kv[1])) or "none"
+        checks = [{"name": "Source verdict: keep", "status": "pass", "source": TT, "detail": f"{k['fam']}: {k['verdict']}"},
+                  {"name": "Rejected rows in this source", "status": "pass" if sum(k["rej"].values()) < 0.2 * k["inp"] else "warn",
+                   "source": TT_MANIFEST,
+                   "detail": f"{k['kept']:,} of {k['inp']:,} input rows kept; rejected by status: {rej_txt}."},
+                  probes, statuses, validity]
+        if k["mode"].startswith("judge"):
+            checks.append({"name": "Judge endpoint required", "status": "warn", "source": TT_LOG,
+                           "detail": "Judge-graded tasks need a configured model endpoint: the 30 judge tasks of the validity "
+                                     "sample returned infra_error because none was configured."})
+        if "safety" in src:
+            checks.append({"name": "Judge audit (M5)", "status": "warn", "source": TT_LOG,
+                           "detail": "20 tasks rated by a judge audit: 15 good, 3 weak, 2 garbage. Kept as rubric-only "
+                                     "(no reference): refuse the harmful prompts, help with the benign ones."})
+        base_name = src.replace("__", "/")
+        dc = delta_check(re.sub(r"-v\d+$", "", base_name)) or delta_check(base_name) or delta_check(re.sub(r"-v\d+$", "-v2", base_name))
+        base_p = None
+        if dc:
+            nm = next(d for d in DELTAS if d[0] in dc["detail"])
+            if nm[0] != base_name:
+                dc = dict(dc, detail=dc["detail"] + f" Measured on the TaskTrove copy named {nm[0]}.")
+            checks.append(dc)
+            base_p = nm[2]
+        mode = k["mode"]
+        env = make_env(
+            w, pid, f"tt|{src}", f"TaskTrove: {src}", rec["domain"], tasks=tasks, task_count=k["kept"], grader_id=G[mode],
+            harness="Harbor task (instruction.md, task.toml, Dockerfile, tests/verifier.toml) graded by tasktrove-verify",
+            tools=["terminal (Harbor agent)"], reward_kind=TT_MODES[mode][1],
+            sandbox={"image": rec["sandbox"].split(";")[0], "runtime": "Daytona in Marin RL and validity runs"},
+            description=f"TaskTrove Clean source {src} ({k['fam']}): {k['kept']:,} tasks kept of {k['inp']:,} input rows, graded "
+                        f"by tasktrove-verify ({rec['grader']['details'].replace('tasktrove-verify mode ', 'mode ')}). "
+                        f"{'The stored example is withheld (safety prompt). ' if withheld else 'The first stored task is the source' + chr(39) + 's real example; the others are placeholders. '}"
+                        + (f"Task pass rates are Qwen3-Coder-30B-A3B's published mean reward on this source ({base_p:.2f})." if base_p is not None else "No pass rate is published for this source."),
+            version="TaskTrove Clean @ b76d03131c", source=TT_MANIFEST, provenance="mixed", difficulty=(0.0, 1.8),
+            profile={"turns": (4, 30), "tokens_out": 2500, "tokens_in": 1500, "seconds": 240, "infra_rate": 0.01,
+                     "judge": TT_MODES[mode][1] != "binary"},
+            checks=checks, created_at=at("2026-09-18 00:00"))
+        store_tasks(w, env, base=base_p)
+        TT_ENV[src] = env
+
+    # A3 environments (one per documented dataset) -------------------------------------------------------------
+    A3_ENV = {}
+    prof = {"code": (3200, (9, 60)), "swe": (3800, (11, 60)), "terminal": (3000, (9, 60)), "tool_use": (2200, (6, 40)),
+            "if": (1500, (4, 30)), "math": (1800, (5, 30)), "search": (2200, (6, 40)), "agentic": (8500, (12, 60)),
+            "other": (1500, (4, 30)), "chat": (1500, (4, 30))}
+    for a in A3:
+        tt_name, same = a.get("tt") or (None, False)
+        k = KEPT_BY.get(tt_name) if tt_name else None
+        drop = DROPPED_BY.get(tt_name) if tt_name else None
+        count = a.get("count")
+        n_store = min(count or 64, 64)
+        short = a["ds"].split("/")[-1]
+        tasks = []
+        if a.get("example"):
+            tasks.append((a["example"][0], a["example"][1], ["published example (A3 traces)"]))
+        elif k and "withheld" not in (k["rec"]["example_task"].get("instruction") or ""):
+            tasks.append((k["rec"]["example_task"]["id"], k["rec"]["example_task"]["instruction"],
+                          ["published example" + ("" if same else f" (from the later TaskTrove version {tt_name})")]))
+        while len(tasks) < n_store:
+            tasks.append((f"{short}-{len(tasks):04d}", f"Task from {a['ds']} as used in A3; its text is not reproduced in the "
+                                                       f"sources used here.", ["placeholder"]))
+        checks = []
+        if drop:
+            checks.append({"name": "Later TaskTrove verdict: dropped", "status": "fail", "source": TT,
+                           "detail": ("The same-name source" if same else f"A later version of this source ({tt_name})")
+                                     + f" was dropped whole from TaskTrove Clean: \"{drop[3]}\""})
+        elif k:
+            checks.append({"name": "Later TaskTrove verdict: kept", "status": "pass", "source": TT,
+                           "detail": ("The same-name source" if same else f"A later version of this source ({tt_name})")
+                                     + f" is in TaskTrove Clean ({k['kept']:,} of {k['inp']:,} rows kept): {k['verdict']}"})
+        dc = delta_check(a["ds"]) or delta_check(a["ds"].replace("-v3", "-v2"))
+        base_p = None
+        if dc:
+            checks.append(dc)
+        if a.get("notrun"):
+            checks.append({"name": "A3 status: not run", "status": "warn", "source": I6187,
+                           "detail": "Listed in #6187 among the datasets with no model: 'oversized, extraction infeasible'."})
+        a3_status = (f"A3 outcome: winner, EMA-best checkpoint at step {a['best']}; #6187 reports {a['reported']}."
+                     if a.get("best") else "A3 outcome: not run (#6187: 'oversized, extraction infeasible')."
+                     if a.get("notrun") else f"A3 outcome: {a.get('reason', '')}")
+        tok, turns = prof.get(a["domain"], (3000, (9, 60)))
+        env = make_env(
+            w, pid, f"a3|{a['key']}", f"A3: {a['ds']}", a["domain"], tasks=tasks, task_count=count,
+            grader_id=G["a3-llm" if a.get("grader") == "llm" else "a3-regex" if a.get("grader") == "regex" else "a3"],
+            harness="Terminus-2 (Harbor) on Daytona, SkyRL terminal_bench entrypoint",
+            tools=["terminal keystrokes (tmux)"], reward_kind="partial" if a.get("grader") == "llm" else "binary",
+            sandbox={"backend": "Daytona", "resources": "1 CPU, 2,048 MB RAM, 2,048 MB storage per sandbox",
+                     "concurrency": "675 trials", "agent_timeout_s": 900, "verifier_timeout_s": 120},
+            description=f"A3 training dataset {a['ds']}. {a3_status} "
+                        + (f"Task count: {count:,} rows in the same-name TaskTrove @0292300 source; " if count else
+                           "Task count of the A3 version not published; ")
+                        + "the stored tasks are placeholders apart from a real example where one is published.",
+            version="A3 (May–June 2026)", source=I6187, provenance="mixed", difficulty=(0.0, 1.8),
+            profile={"turns": turns, "tokens_out": a.get("tok", tok), "tokens_in": 2500, "seconds": 420, "infra_rate": 0.015,
+                     "timeout_rate": 0.03, "max_tokens": 60000, "judge": a.get("grader") == "llm"},
+            checks=checks, created_at=at("2026-05-20 00:00"))
+        A3_ENV[a["key"]] = env
+
+    # follow-up environments (#7785, #8942): the pre-Clean TaskTrove copies they trained on
+    def fu_env(key, name, domain, tt_name, count, desc, extra_checks=(), turns=(8, 30), tok=6000, n_store=60):
+        k = KEPT_BY.get(tt_name)
+        tasks = []
+        if k:
+            ex = k["rec"]["example_task"]
+            tasks.append((ex["id"], ex["instruction"], ["published example (TaskTrove Clean copy of this source)"]))
+        while len(tasks) < n_store:
+            tasks.append((f"{key}-{len(tasks):04d}", f"Task from {name}; its text is not reproduced in the sources used here.",
+                          ["placeholder"]))
+        drop = DROPPED_BY.get(tt_name)
+        checks = list(extra_checks)
+        if drop:
+            checks.append({"name": "Later TaskTrove verdict: dropped", "status": "fail", "source": TT,
+                           "detail": f"The same-name TaskTrove source {tt_name} was dropped whole from TaskTrove Clean: \"{drop[3]}\""})
+        elif k:
+            checks.append({"name": "Later TaskTrove verdict: kept", "status": "pass", "source": TT,
+                           "detail": f"Kept in TaskTrove Clean as {tt_name} ({k['kept']:,} tasks): {k['verdict']}"})
+        return make_env(w, pid, f"fu|{key}", name, domain, tasks=tasks, task_count=count, grader_id=G["q3c"],
+                        harness="Harbor terminus-2 (Daytona)", tools=["terminal keystrokes (tmux)"], reward_kind="binary",
+                        sandbox={"backend": "Daytona"}, description=desc, version="TaskTrove (pre-Clean)", source=I7785,
+                        provenance="mixed", difficulty=(0.0, 1.8),
+                        profile={"turns": turns, "tokens_out": tok, "tokens_in": 3000, "seconds": 600, "infra_rate": 0.01,
+                                 "timeout_rate": 0.02, "max_tokens": 60000}, checks=checks, created_at=at("2026-07-25 00:00"))
+
+    env_mf = fu_env("multifile", "TaskTrove: DCAgent/exp_rpt_multifile (#7785)", "code", "DCAgent__exp_rpt_multifile-v3", None,
+                    "The single source of the #7785 hyperparameter campaign: multi-module Python projects under Terminus-2, "
+                    "binary rewards per the POLICY. Same-source base mean reward 0.1734 over 1,090 trials (189 successes); "
+                    "teachers GLM 5.2 0.351 and Qwen3.5-122B-A10B 0.208. Task count of the version used is not published.",
+                    extra_checks=[c for c in [delta_check("DCAgent/exp_rpt_multifile")] if c] +
+                                 [{"name": "Base and teacher rewards (#7785)", "status": "pass", "source": HPO_REPORT,
+                                   "detail": "Qwen3-Coder-30B-A3B 0.1734 mean reward over 1,090 trials (189 successes, "
+                                             "provisional); Qwen3.5-122B-A10B 0.208; GLM 5.2 0.351."}], turns=(10, 30), tok=11000)
+    env_cal = fu_env("calendar-agent-v2", "TaskTrove: laion__nemotron-gym-agent-calendar-v2 (#8942)", "tool_use",
+                     "laion__nemotron-gym-agent-calendar-v2", 2699,
+                     "Calendar agent v2 as trained in #8942 (open-thoughts/TaskTrove, before the Clean release). 2,699 rows in "
+                     "TaskTrove @0292300. The fixed 128-task holdout overlaps this training source.", turns=(4, 30), tok=3200)
+    env_calif = fu_env("calendar-if-v3", "TaskTrove: laion__nemotron-gym-instruction-following-calendar-v3 (#8942)", "if",
+                       "laion__nemotron-gym-instruction-following-calendar-v3", 5673,
+                       "Calendar instruction-following v3 as trained in #8942. 5,673 rows in TaskTrove @0292300. The fixed "
+                       "128-task holdout overlaps this training source.", turns=(4, 30), tok=3000)
+    env_bip = fu_env("bugsinpy-v4", "BugsInPy v4 (penfever/qwen3coder-software-v49-fixed-splits)", "swe",
+                     "laion__exp_rpt_bugsinpy-v4", None,
+                     "BugsInPy v4 with a seed-42 train/validation split (#8942). 479 rows in the same-name TaskTrove "
+                     "@0292300 source; the size of the training split is not published.",
+                     extra_checks=[c for c in [delta_check("laion/exp_rpt_bugsinpy-v2")] if c], turns=(12, 30), tok=5000)
+    env_swg = fu_env("swegym-v5", "SWE-Gym v5 (penfever/qwen3coder-software-v49-fixed-splits)", "swe",
+                     "laion__swegym-tasks-patched-validated-v5", None,
+                     "SWE-Gym v5 with a seed-42 train/validation split (#8942). About 78% of matched trials hit the 30-turn cap, "
+                     "which confounds its result. 2,428 rows in the same-name TaskTrove @0292300 source.",
+                     turns=(24, 30), tok=6000)
+
+    # the A3 start point ----------------------------------------------------------------------------------
+    st = at("2026-02-12 06:00")
+    steps = 4129  # 9,437 traces × 7 epochs / global batch 16 (my arithmetic)
+    res = sft_run(w, project_id=pid, key="a3-sft", name="a3-sft-glm47-swesmith", framework="trl_sft", datasets=[(ds_a3sft, 1.0)],
+                  base_model_id=M["qwen3-8b"], steps=steps, start=st, step_seconds=64701.7 / steps, loss=(0.85, 0.17), lr=4e-5,
+                  warmup=0.1, schedule="cosine", global_batch=16, seq_len=131072, gpu=None, gpus=8, cost_rate=0.0,
+                  tags=["sft", "agent"], log_every=21, epochs=7,
+                  config="\n".join(["# train_results.json and the model card (LLaMA-Factory, OpenThoughts-Agent)",
+                                    "model: Qwen/Qwen3-8B", "dataset: DCAgent2/GLM-4.7-swesmith-...-131k   # 9,437 rows",
+                                    "learning_rate: 4e-5", "num_train_epochs: 7", "global_batch: 16",
+                                    "optimizer: adamw_torch_fused, betas (0.9, 0.98)", "lr_scheduler: cosine, warmup_ratio 0.1",
+                                    "gpus: 8", "train_runtime: 64701.7 s", "train_loss: 0.3043   # mean over training",
+                                    "total_flos: 2.65e18"]),
+                  hyperparams={"optimizer": "AdamW fused, betas (0.9, 0.98)", "train_loss_mean": 0.3043,
+                               "steps_note": "9,437 × 7 / 16 ≈ 4,129 steps (my arithmetic)"},
+                  description="SFT of Qwen3-8B on 9,437 GLM-4.7 swesmith sandbox traces (LLaMA-Factory, lr 4e-5, 7 epochs, 8 "
+                              "GPUs, 64,701.7 s): the fixed start point of every A3 run. Runtime, mean train loss (0.3043) and "
+                              "hyperparameters are published; the loss curve is simulated to average near 0.30.",
+                  source=A3_BASE_RESULTS, provenance="simulated")
+    a3base = model("a3-base", "GLM-4_7-swesmith-sandboxes-...-131k-fixthink (A3 SFT base)",
+                   hf_repo="laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink",
+                   arch="Dense (Qwen3-8B)", params_total=8.0, params_active=8.0, parent_id=M["qwen3-8b"], run_key="a3-sft",
+                   step=steps, stage="SFT", created_at=at("2026-02-13 00:00"), status="released", source=A3_BASE,
+                   notes="Qwen3-8B fine-tuned on 9,437 GLM-4.7 swesmith sandbox traces; the fixed start point of every A3 run.")
+    w.conn.execute("UPDATE runs SET output_model_id=?, framework='LLaMA-Factory (HF Trainer)' WHERE id=?", (a3base, res["run_id"]))
+    add_jobs(w, pid, res["run_id"], "a3-sft-glm47-swesmith", "completed", st, res["end"],
+             [{"name": "trainer", "cluster": None, "gpu": None, "gpus": 8, "log": "8 GPUs; type not stated."}])
+
+    # A3 runs ----------------------------------------------------------------------------------------------
+    a3_cfg = "\n".join([
+        "# A3 recipe from rl_config.json (identical in the two runs that publish it)",
+        "base_model: laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink",
+        "dataset: {dataset}",
+        "trainer:", "  advantage_estimator: rloo_n", "  loss_reduction: token_mean", "  use_kl_loss: false",
+        "  eps_clip_low: 0.2", "  eps_clip_high: 0.05", "  lr: 8.0e-6", "  weight_decay: 0.0", "  max_grad_norm: 0.9",
+        "  adam_betas: [0.9, 0.999]", "  train_batch_size: 64            # prompts per step",
+        "  n_samples_per_prompt: 8          # 512 trajectories per step", "  epochs: 2", "  max_steps: 80",
+        "  fully_async_max_staleness_steps: 16", "  policy: 2 nodes × 4 GH200, FSDP2 (fsdp_size 4)",
+        "generator:", "  vllm_engines: 48 × TP1", "  temperature: 0.7", "  top_p: 0.95", "  top_k: 20",
+        "  max_model_len: 32768", "  max_input_tokens: 32000", "  max_generate_length: {maxgen}",
+        "harbor:", "  agent: terminus-2", "  sandbox: daytona (1 CPU, 2,048 MB RAM, 2,048 MB storage)",
+        "  agent_timeout_s: 900", "  verifier_timeout_s: 120", "  n_concurrent_trials: 675", "  reward_shaping: false",
+        "  mask_exceptions: [" + ", ".join(A3_MASKED) + "]", "  passthrough_exceptions: [AgentTimeoutError]",
+        "  default_error_treatment: zero",
+        "checkpointing: hf_save_interval 5; select the best trailing EMA (alpha 1/3) of reward/avg_raw_reward, never the first saved checkpoint"])
+    a3_hp = {"advantage_estimator": "rloo_n", "loss_reduction": "token_mean", "lr": 8e-6, "weight_decay": 0.0,
+             "max_grad_norm": 0.9, "clip_low": 0.2, "clip_high": 0.05, "kl": "off", "prompts_per_step": 64, "group_size": 8,
+             "epochs": 2, "max_steps": 80, "max_staleness": 16, "temperature": 0.7, "top_p": 0.95, "top_k": 20,
+             "max_model_len": 32768, "reward_shaping": False, "gpus": "56 GH200 (policy 2 × 4 FSDP2 + 48 vLLM engines at TP1)"}
+    sweep_runs = []
+    conclusion_t = at(A3_END)
+    for a in A3:
+        if a.get("notrun"):
+            continue
+        env = A3_ENV[a["key"]]
+        key = f"a3|{a['key']}"
+        name = f"a3-{a['key']}"
+        real = a.get("real")
+        pass8 = a.get("pass8") or {}
+        seed = stable_seed("a3", a["key"])
+        events = []
+        if real:
+            ser = real_series(real)
+            meta = run_meta(real)
+            rsteps = sorted(s for s, _ in ser["reward/avg_raw_reward"])
+            n = rsteps[-1]
+            rmap = dict(ser["reward/avg_raw_reward"])
+            reward = [rmap.get(s, rmap.get(s - 1, 0.3)) for s in range(1, n + 1)]
+            tmap = dict(ser["timing/step"])
+            times = [tmap.get(s, 1200.0) for s in range(1, n + 1)]
+            end = at(a["end"])
+            start = end - sum(times)
+            status, reason = "completed", ""
+            prov = "mixed"
+            series = ser
+            sim_tags = {}
+            gen = None
+            desc = (f"A3 run on {a['ds']}: RLOO-N from the fixed Qwen3-8B agent, 64 prompts × 8 attempts per step, lr 8e-6, on "
+                    f"56 GH200s. Every metric is the published SkyRL table shipped with the checkpoint ({meta['note'].split('Our copy has ')[-1].split('. The issue')[0]}); "
+                    f"rollouts are simulated at each step's logged reward. #6187 reports reward {a['reported']} at the "
+                    f"EMA-best step {a['best']}. Dates place the logged step times back to back ending at the table's timestamp.")
+            sweep_runs.append(key)
+            events.append({"step": 0, "kind": "notice", "title": "Learning-rate column dropped",
+                           "body": "policy/policy_lr is logged as 0.0 at every step although lr is 8e-6 (a logging artifact); "
+                                   "the column is left out.", "t": start + 1})
+        else:
+            n = a.get("steps")
+            start = at(a["start"])
+            if a.get("cancel"):
+                n = int((conclusion_t - start) // a["med"])
+            times = step_times(n, a["med"], seed)
+            if a.get("cancel"):
+                times = [x * (conclusion_t - start) / sum(times) for x in times]
+            anchors = dict(a["anchors"])
+            if a.get("cancel") and max(anchors) != n:
+                v_end = anchors.pop(max(anchors))
+                anchors[n] = v_end
+            reward = anchor_curve(n, anchors, noise=0.035, seed=a["key"], ema=a.get("ema"), lo=0.0, hi=1.0)
+            status, reason = a.get("status", "completed"), a.get("reason", "")
+            prov = "simulated"
+            series = {}
+            sim_tags = {"reward": "reward/avg_raw_reward", "pass_at_k": "reward/avg_pass_at_8", "resp_len": "generate/avg_num_tokens",
+                        "adv_abs": "loss/avg_raw_advantages_abs", "step_time": "timing/step"}
+            rr = random.Random(seed)
+            e0 = rr.uniform(0.05, 0.2)
+
+            def gen(step, x, rr=rr, e0=e0):
+                return {"policy/policy_entropy": e0 * (1 - 0.25 * x) * math.exp(rr.gauss(0, 0.08)),
+                        "policy/raw_grad_norm": 0.02 * math.exp(rr.gauss(0, 0.35)),
+                        "policy/policy_loss": rr.gauss(0, 0.004), "policy/ppo_clip_ratio": 0.0,
+                        "async/staleness_mean": 0.0 if step == 1 else max(0.0, rr.gauss(1.8, 0.8))}
+            if a.get("best"):
+                pub = f"#6187 reports {a['reported']} at the EMA-best step {a['best']}"
+                if a.get("sim"):
+                    pub += "; no reward value is published, so the curve's level is simulated"
+                else:
+                    pub += "; the curve passes through every published value"
+            else:
+                pub = reason + (" #6187 reports no reward, so the curve is simulated." if a.get("sim") else "")
+            desc = (f"A3 run on {a['ds']}: RLOO-N from the fixed Qwen3-8B agent, 64 prompts × 8 attempts per step, lr 8e-6, on "
+                    f"56 GH200s. {pub}. No log is public for this run: its per-step curves, dates and step times are simulated"
+                    + (f"; steps completed: {a['why_steps']}" if a.get("why_steps") else
+                       "; steps completed are not published, so it runs to the sweep's 80-step ceiling" if n == 80 else "")
+                    + "." + (" " + a["note"] if a.get("note") else ""))
+            sweep_runs.append(key)
+        ckpts = [{"step": s, "path": f"a3-rl-{a['ds'].replace('/', '_')}/global_step_{s}"} for s in range(5, n + 1, 5)]
+        out_id = None
+        if a.get("model"):
+            out_id = model(f"a3m|{a['key']}", a["model"].split("/")[1], hf_repo=a["model"], arch="Dense (Qwen3-8B)",
+                           params_total=8.0, params_active=8.0, parent_id=a3base, run_key=key, step=a["best"], stage="RL",
+                           created_at=None, status="released", source=f"https://huggingface.co/{a['model']}",
+                           notes=f"EMA-best A3 checkpoint on {a['ds']} (step {a['best']}); #6187 reward {a['reported']}. "
+                                 f"Trained with max_model_len 32,768.")
+            for c in ckpts:
+                if c["step"] == a["best"]:
+                    c.update(model_id=out_id, title=f"Selected checkpoint: step {a['best']}",
+                             body=f"EMA-best checkpoint per #6187 (reported reward {a['reported']}), exported as {a['model']}.")
+        if a.get("export"):
+            es, repo = a["export"]
+            exp_id = model(f"a3x|{a['key']}", repo.split("/")[1], hf_repo=repo, arch="Dense (Qwen3-8B)", params_total=8.0,
+                           params_active=8.0, parent_id=a3base, run_key=key, step=es, stage="RL", created_at=None,
+                           status="released", source=A3_MODELS if "unitsyn-python-v3" in repo or "pymethods2test-v3" in repo else I6187,
+                           notes=f"Step-{es} export on Hugging Face; not a #6187 winner checkpoint.")
+            for c in ckpts:
+                if c["step"] == es:
+                    c.update(model_id=exp_id, title=f"Exported checkpoint: step {es}", body=f"Exported as {repo}.")
+        if a["key"] == "pymethods2test-large":
+            events += [
+                {"step": 80, "kind": "incident", "severity": "warning", "title": "Spurious steps 81–86 excluded",
+                 "body": "A resume past max_steps trained spurious steps 81–86; they are excluded from checkpoint selection "
+                         "and cut from this copy. The 7 job segments took 122,848 s including them.", "t": None},
+                {"step": 80, "kind": "notice", "severity": "warning", "title": "Reported reward disagrees with the curve",
+                 "body": "#6187 lists 0.74 reward and 0.83 pass@8 at step 80 ('paper hero dataset'); the published curve shows "
+                         "reward/avg_raw_reward 0.559 and pass@8 0.672 at step 80, and the model card reports EMA(80) 0.4829 "
+                         "and raw 0.5586. The curve's maximum is 0.7695 at step 1. Unresolved.", "t": None},
+                {"step": 80, "kind": "notice", "severity": "warning", "title": "Hero-run reproduction: Perlmutter vs Jupiter",
+                 "body": "\"The 8B RL hero run from OT-Agent does reproduce on Perlmutter but does not reproduce on Jupiter\": "
+                         "Perlmutter hit an anomalous step where grad norm and entropy blow up and collapsed near step 40, while "
+                         "Jupiter converged on \"fewer, cleaner tool calls and shorter overall responses. Which tanks eval "
+                         "scores because the model gives up / submits solution too soon\" (#6187).", "t": None}]
+        if a.get("maxgen") == 8192:
+            events.append({"step": 0, "kind": "config", "title": "Generation cap 8,192 tokens",
+                           "body": "The first two A3 runs (inferredbugs, llm-verifier-freelancer) logged max_generate_length=8192; "
+                                   "later runs logged 4,096 (first job log of four runs).", "t": start + 2})
+        if a["key"] == "inferredbugs":
+            events.append({"step": 78, "kind": "notice", "title": "Checkpoint choice vs the final curve",
+                           "body": "Recomputing the trailing EMA (alpha 1/3) over this final logged curve puts its best saved "
+                                   "checkpoint at step 75 (EMA 0.454), not the reported step 55 (raw 0.602, EMA 0.444); the "
+                                   "selection may have been made before superseded rows were replaced (my check).", "t": None})
+        events.append({"t": max(conclusion_t, start + sum(times) + 60), "step": n, "kind": "notice", "severity": "warning",
+                       "title": "Sweep concluded: uninformative about dataset utility", "body": A3_CONCLUSION})
+        for e in events:
+            if e.get("t") is None:
+                e.pop("t")
+        res = simulate_run(
+            w, pid=pid, key=key, name=name, envs=[(env, 1.0)], base_model_id=a3base, reward=reward, start=start, times=times,
+            group_size=8, prompts=64, sample_groups=48, store_groups=2, adv="rloo", series=series, sim_tags=sim_tags, gen=gen,
+            exact={s: {"pass_at_k": v} for s, v in pass8.items()}, harness="terminus-2", staleness=[0, 1, 1, 2, 2, 3],
+            events=events, checkpoints=ckpts, steps_planned=80,
+            run={"algorithm": "RLOO-N", "framework": "SkyRL (OpenThoughts-Agent launcher, terminal_bench)", "status": status,
+                 "status_reason": reason, "output_model_id": out_id, "primary_metric": "reward/avg_raw_reward",
+                 "gpu": "GH200", "gpus": 56, "tags": ["a3", "agentic"] + (["public-log"] if real else ["simulated"]),
+                 "code_ref": "OpenThoughts-Agent SkyRL launcher", "hyperparams": dict(a3_hp, dataset=a["ds"],
+                                                                                        max_generate_length=a.get("maxgen", 4096)),
+                 "config": a3_cfg.format(dataset=a["ds"], maxgen=a.get("maxgen", 4096)), "group_name": "a3-single-dataset (#6187)",
+                 "description": desc, "source": f"https://huggingface.co/{a['model']}" if (real and a.get("model")) else I6187,
+                 "provenance": prov,
+                 "start_body": f"RLOO-N on {a['ds']}: 64 prompts × 8 attempts per step, lr 8e-6, from the Qwen3-8B agent SFT."})
+        if out_id:
+            w.conn.execute("UPDATE models SET created_at=? WHERE id=?", (res["times"].get(a["best"], (res["end"], res["end"]))[1], out_id))
+        if a.get("export"):
+            w.conn.execute("UPDATE models SET created_at=? WHERE id=?",
+                           (at("2026-06-01 00:00") if a["key"] in ("pymethods2test-v3", "unitsyn-python-v3")
+                            else res["times"].get(a["export"][0], (res["end"], res["end"]))[1], exp_id))
+        segs = a.get("segments", 1)
+        restarts = []
+        if real and segs > 1:
+            big = sorted(((tmap.get(s, 0), s) for s in range(2, n + 1)), reverse=True)[:segs - 1]
+            restarts = [res["times"][s][0] for _, s in big]
+        add_jobs(w, pid, res["run_id"], name, status, start, res["end"],
+                 [{"name": "policy trainer (2 nodes × 4 GH200, FSDP2)", "cluster": C["jupiter"], "gpu": "GH200", "gpus": 8, "nodes": 2},
+                  {"name": "vLLM engines (48 × TP1)", "kind": "rollout", "cluster": C["jupiter"], "gpu": "GH200", "gpus": 48, "nodes": 12},
+                  {"name": "sandboxes (675 concurrent trials)", "kind": "sandbox", "cluster": C["daytona"], "gpu": None, "gpus": None}],
+                 restarts=restarts)
+        a["_res"] = res
+
+    # tasks for the A3 environments: base and latest pass rates from the first and last steps of the run on it
+    for a in A3:
+        env = A3_ENV[a["key"]]
+        res = a.get("_res")
+        if res:
+            row = w.conn.execute("SELECT reward_mean FROM run_steps WHERE run_id=? ORDER BY step", (res["run_id"],)).fetchall()
+            store_tasks(w, env, base=row[0][0], latest=row[-1][0], attempts=8)
+        else:
+            store_tasks(w, env)
+
+    # #7785 TaskTrove hyperparameter arms (published curves) ---------------------------------------------------
+    hpo = [
+        dict(key="x3", run="marin-q3c-tt-x3-kl0p001", name="tt-x3-kl0p001", model="laion/tt-x3_kl-kl0p001-76-30B", best=76,
+             start="2026-07-31 06:00", gpus=None, gpu="GH200", cluster="jupiter", status="stopped",
+             reason="Stopped by the owner at 76 of 80 steps; step 76 is the best retained checkpoint (trailing-5 EMA 0.1426, "
+                    "pass@8 0.2656); earlier EMA maxima were rotated out (max_ckpts_to_keep 2).",
+             knob="KL coefficient 0.001 with a reference model (policy world size 32)", segments=15),
+        dict(key="x5", run="marin-q3c-tt-x5-gradnorm0p45", name="tt-x5-gradnorm0p45", model="laion/tt-x5_gradnorm-gn0p45-30-30B",
+             best=30, start="2026-08-02 06:00", gpus=24, gpu="GH200", cluster="jupiter", status="stopped",
+             reason="Terminated at 68 of 80 steps with entropy 0.12 → 0.69 (about 5.6× step 1); step 30 selected (trailing-5 EMA "
+                    "0.1972, pass@8 0.4219); no resolved difference within the X5 family.",
+             knob="max grad norm 0.45", segments=13),
+        dict(key="x15", run="marin-q3c-tt-x15-megatron", name="tt-x15-megatron", model="laion/tt-x15-megatron-51-30B", best=51,
+             start="2026-08-08 00:00", gpus=32, gpu="H100", cluster="rno2a", status="stopped", median=647.6,
+             reason="Killed at 101 of 400 steps: reward collapsed to about 0 at steps 84 and 86 (entropy collapse shortened turns "
+                    "until agents hit max_turns 30); step 51 selected (trailing-5 0.2199, pass@8 0.4219).",
+             knob="Megatron backend, clip low 0.3, max staleness 3 (three settings moved at once vs X14)"),
+        dict(key="x10b", run="marin-q3c-tt-x10-fsdp2", name="tt-x10b-fsdp2-fa2", model="laion/tt-x10-fsdp2-fa2-117-30B", best=117,
+             start="2026-08-12 18:00", gpus=32, gpu="H100", cluster="rno2a", status="stopped", median=1232.5,
+             reason="The one admissible long-horizon run: 131 stable steps, stopped 2026-08-15 at a plateau; step 117 selected "
+                    "(trailing-5 EMA 0.2535, pass@8 0.3906); peak raw reward 0.332 at step 116.",
+             knob="FSDP2 + FlashAttention 2 backend, temperature 1.2, 400-step horizon"),
+    ]
+    for h in hpo:
+        ser = real_series(h["run"])
+        reduced = "reward" in ser
+        rtag = "reward" if reduced else "reward/avg_raw_reward"
+        rmap = dict(ser[rtag])
+        n = max(rmap)
+        reward = [rmap.get(s, (rmap.get(s - 1, 0.15) + rmap.get(s + 1, 0.15)) / 2) for s in range(1, n + 1)]
+        if reduced:
+            times = step_times(n, h["median"], h["key"], sigma=0.25, first=2.0)
+        else:
+            tmap = dict(ser["timing/step"])
+            times = [tmap.get(s, 1500.0) for s in range(1, n + 1)]
+        gaps = {76: 8.8 * H} if h["key"] == "x10b" else {}
+        start = at(h["start"])
+        events = []
+        if h["key"] == "x10b":
+            events = [{"step": 75, "kind": "incident", "severity": "warning", "title": "Wedged at step 75 for about 8.8 h",
+                       "body": "The X10 FSDP2 arm wedged at step 75 for about 8.8 hours."},
+                      {"step": 84, "kind": "restart", "severity": "warning", "title": "Relaunch failed, then resumed from step 84",
+                       "body": "The r3 relaunch failed with 'dataset ... got size 0' because --train_data was omitted; resumed as "
+                               "r4 from step 84 with the flag restored."}]
+        if h["key"] == "x15":
+            events = [{"step": 84, "kind": "incident", "severity": "error", "title": "Reward collapse",
+                       "body": "Reward fell to about 0 at steps 84 and 86: entropy collapse shortened turns until agents hit the "
+                               "30-turn cap."}]
+        if h["key"] == "x5":
+            events = [{"step": 68, "kind": "alert", "severity": "warning", "title": "Entropy at 5.6× its step-1 value",
+                       "body": "Entropy 0.12 → 0.69. #7785 POLICY: 3× step 1 is a watch condition; at 10×, select a checkpoint and stop."}]
+        out = model(f"hpo|{h['key']}", h["model"].split("/")[1], hf_repo=h["model"], arch="MoE (Qwen3-Coder-30B-A3B)",
+                    params_total=30.0, params_active=3.0, parent_id=M["q3c"], run_key=f"hpo|{h['key']}", step=h["best"],
+                    stage="RL", created_at=None, status="released", source=f"https://huggingface.co/{h['model']}",
+                    notes=f"#7785 arm {h['key'].upper()} ({h['knob']}); selected step {h['best']}.")
+        cfg = "\n".join([f"# #7785 arm {h['key'].upper()}: {h['knob']}", "base: Qwen/Qwen3-Coder-30B-A3B-Instruct",
+                         "source: DCAgent/exp_rpt_multifile", "agent: terminus-2 (Harbor, Daytona)",
+                         "advantage_estimator: rloo_n        # launch config; the model card says GRPO",
+                         "enable_reward_shaping: false      # launch config; the card says 'campaign verifier is pass_ratio shaping'",
+                         "train_batch_size: 64", "n_samples_per_prompt: 8", "request_window: 32768 / 4096 tokens per turn",
+                         "horizon: 80 steps or two epochs" + ("; 400-step horizon" if h["key"] in ("x10b", "x15") else ""),
+                         "one hyperparameter per experiment (POLICY)"] +
+                        (["lr: 8.0e-6", "eps_clip: 0.2 / 0.05", "loss_reduction: sequence_mean", "temperature: 1.2",
+                          "max_staleness_steps: 16", "geometry: 4 nodes × 8 H100 (policy 2 × 8, 4 engines at TP4)"]
+                         if h["key"] == "x10b" else []) +
+                        (["lr: 8.0e-6", "eps_clip: 0.3 / 0.05", "loss_reduction: sequence_mean", "temperature: 1.2",
+                          "max_staleness_steps: 3", "backend: Megatron"] if h["key"] == "x15" else []) +
+                        (["kl_coef: 0.001   # reference model; policy world size 32"] if h["key"] == "x3" else []) +
+                        (["max_grad_norm: 0.45", "geometry: 6 Jupiter nodes × 4 GH200 (16 policy GPUs + 4 engines × TP2)"]
+                         if h["key"] == "x5" else []))
+        ckpts = [{"step": h["best"], "model_id": out, "title": f"Selected checkpoint: step {h['best']}",
+                  "body": f"Exported as {h['model']}."}]
+        res = simulate_run(
+            w, pid=pid, key=f"hpo|{h['key']}", name=h["name"], envs=[(env_mf, 1.0)], base_model_id=M["q3c"], reward=reward,
+            start=start, times=times, group_size=8, prompts=64, sample_groups=48, store_groups=2, adv="rloo", series=ser,
+            harness="terminus-2", staleness=[0, 1, 1, 2, 3], events=events, checkpoints=ckpts,
+            steps_planned=400 if h["key"] in ("x10b", "x15") else 80, gaps=gaps,
+            missing=tuple(s for s in range(1, n + 1) if s not in rmap),
+            run={"algorithm": "RLOO-N (model card: GRPO)", "framework": "MarinSkyRL (" + ("Megatron" if h["key"] == "x15" else "FSDP2") + ")",
+                 "status": h["status"], "status_reason": h["reason"], "output_model_id": out,
+                 "primary_metric": "reward" if reduced else "reward/avg_raw_reward", "gpu": h["gpu"], "gpus": h["gpus"],
+                 "tags": ["tasktrove-hpo", "public-log"], "config": cfg, "group_name": "tasktrove-hpo (#7785)",
+                 "hyperparams": {"knob": h["knob"], "prompts_per_step": 64, "group_size": 8, "advantage_estimator": "rloo_n",
+                                 "reward_shaping": "off in the launch config; the model card says pass_ratio shaping"},
+                 "description": f"#7785 arm {h['key'].upper()} on Qwen3-Coder-30B-A3B-Instruct with DCAgent/exp_rpt_multifile under "
+                                f"Terminus-2: {h['knob']}. The launch config sets advantage_estimator rloo_n and reward shaping "
+                                f"off, while the model card says GRPO with pass-ratio reward shaping; both are shown. Metrics are "
+                                f"the published per-step table{' (reduced schema, no step times: the published median step time is used)' if reduced else ''}; "
+                                f"rollouts are simulated at each step's logged reward.",
+                 "source": f"https://huggingface.co/{h['model']}", "provenance": "mixed",
+                 "start_body": f"#7785 arm {h['key'].upper()}: {h['knob']}; 64 prompts × 8 attempts per step."})
+        w.conn.execute("UPDATE models SET created_at=? WHERE id=?", (res["times"][h["best"]][1], out))
+        restarts = []
+        if not reduced and h.get("segments", 1) > 1:
+            big = sorted(((tmap.get(s, 0), s) for s in range(2, n + 1) if s in res["times"]), reverse=True)[:h["segments"] - 1]
+            restarts = [res["times"][s][0] for _, s in big]
+        add_jobs(w, pid, res["run_id"], h["name"], h["status"], start, res["end"],
+                 [{"name": "trainer and engines", "cluster": C[h["cluster"]], "gpu": h["gpu"], "gpus": h["gpus"]},
+                  {"name": "sandboxes", "kind": "sandbox", "cluster": C["daytona"]}], restarts=restarts)
+        h["_res"] = res
+
+    # #8942 data-source sweep ---------------------------------------------------------------------------------
+    E = Evals(w, pid)
+    hold = {}
+    for key, name, env, base_n, desc in (
+            ("cal-if", "Fixed holdout: calendar instruction-following v3", env_calif, 28,
+             "128 fixed tasks, pass@1 at temperature 0 (Harbor terminus-2). The holdout overlaps its training source, so the "
+             "scores select configurations but are not clean generalization estimates."),
+            ("cal-agent", "Fixed holdout: calendar agent v2", env_cal, 44,
+             "128 fixed tasks, pass@1 at temperature 0. The holdout overlaps its training source."),
+            ("bugsinpy", "Fixed validation: BugsInPy v4", env_bip, 43, "128 tasks of a seed-42 train/validation split, pass@1."),
+            ("swegym", "Fixed validation: SWE-Gym v5", env_swg, 19,
+             "128 tasks of a seed-42 train/validation split, pass@1; confounded by the 30-turn cap.")):
+        E.bench(f"hold|{key}", name, "Agentic holdout (#8942)", "pass@1", 128, 1, desc, I8942C, harness="Harbor terminus-2")
+        hold[key] = base_n
+    q3c_runs = [
+        dict(key="cal-if-lr2", run="marin-q3c-cal-if-rloo-lr2", env=env_calif, hold="cal-if", lr=2e-6, best=18,
+             model="penfever/qwen3coder-calendar-if-v49-lr2-step18",
+             recipe="async RLOO-N, group 8, sequence mean, no DAPO or shaping, lr 2e-6, max staleness 2"),
+        dict(key="cal-agent-lr2", run="marin-q3c-cal-agent-rloo-lr2", env=env_cal, hold="cal-agent", lr=2e-6, best=12,
+             model="penfever/qwen3coder-calendar-agent-v49-lr2-step12",
+             recipe="async shaped RLOO-N, group 8, sequence mean, DAPO off, lr 2e-6, max staleness 2"),
+        dict(key="cal-agent-lr4", run="marin-q3c-cal-agent-rloo-lr4", env=env_cal, hold="cal-agent", lr=4e-6, best=9,
+             model="penfever/qwen3coder-calendar-agent-v49-lr4-step9",
+             recipe="async shaped RLOO-N (identity-aware shaping with aggregate fallback, 0.05 pass-through penalty), group 8, "
+                    "sequence mean, lr 4e-6, max staleness 2 — the best calendar-agent recipe (steps 6 and 9)"),
+    ]
+    q3c_hp = {"prompts_per_step": 64, "group_size": 8, "clip": "0.2 / 0.05", "tis_imp_ratio_cap": 2.0, "temperature": 1.2,
+              "top_p": 0.95, "top_k": 20, "max_grad_norm": 0.9, "request_window": 32768, "tokens_per_turn": 4096, "max_turns": 30,
+              "placement": "policy 2 nodes × 8 GPUs + 6 vLLM engines at TP4 (EP4)", "group_advantage_min_size": 4}
+    for q in q3c_runs:
+        ser = real_series(q["run"])
+        meta = run_meta(q["run"])
+        rmap = dict(ser["reward/avg_raw_reward"])
+        n = max(rmap)
+        reward = [rmap[s] for s in range(1, n + 1)]
+        tmap = dict(ser["timing/step"])
+        times = [tmap.get(s, 900.0) for s in range(1, n + 1)]
+        start = at(meta["started_at"].replace("T", " ")[:16])
+        out = model(f"q3c|{q['key']}", q["model"].split("/")[1], hf_repo=q["model"], arch="MoE (Qwen3-Coder-30B-A3B)",
+                    params_total=30.0, params_active=3.0, parent_id=M["q3c"], run_key=f"q3c|{q['key']}", step=q["best"],
+                    stage="RL", created_at=None, status="released", source=f"https://huggingface.co/{q['model']}",
+                    notes=f"#8942 checkpoint: {q['recipe']}.")
+        res = simulate_run(
+            w, pid=pid, key=f"q3c|{q['key']}", name=f"q3c-{q['key']}", envs=[(q["env"], 1.0)], base_model_id=M["q3c"],
+            reward=reward, start=start, times=times, group_size=8, prompts=64, sample_groups=48, store_groups=2, adv="rloo",
+            series=ser, harness="terminus-2", staleness=[0, 1, 1, 2],
+            checkpoints=[{"step": s, "model_id": out if s == q["best"] else None} for s in range(3, n + 1, 3)],
+            steps_planned=30,
+            run={"algorithm": "RLOO-N (async)", "framework": "MarinSkyRL (FSDP2) on Iris", "status": "completed",
+                 "output_model_id": out, "primary_metric": "reward/avg_raw_reward", "gpu": None, "gpus": 40,
+                 "tags": ["q3c-data-sweep", "public-log"], "group_name": "q3c-data-source-sweep (#8942)",
+                 "hyperparams": dict(q3c_hp, lr=q["lr"], recipe=q["recipe"]),
+                 "config": "\n".join(["# #8942 recipe (gist of best observed Qwen3-Coder RL configurations)",
+                                      "base_config: x10_fsdp2_fa2_calendar*.yaml (derived from #7785 X10)",
+                                      f"source: {meta['dataset']}", f"lr: {q['lr']:g}", f"recipe: {q['recipe']}",
+                                      "train_batch_size: 64", "n_samples_per_prompt: 8", "eps_clip: 0.2 / 0.05",
+                                      "tis_imp_ratio_cap: 2.0", "temperature: 1.2", "max_turns: 30", "max_steps: 30",
+                                      "placement: policy 2 × 8 GPUs + 6 vLLM engines at TP4 (40 GPUs, my arithmetic)"]),
+                 "description": f"#8942 run on {meta['dataset'].split('::')[-1]} from Qwen3-Coder-30B-A3B-Instruct: {q['recipe']}. "
+                                f"Metrics are the per-step dicts the run mirrored to its log, and val/* is the fixed 128-task "
+                                f"holdout at checkpoints (step 0 = the untrained base); both published. Rollouts are simulated. "
+                                f"GPU count is my arithmetic from the published placement.",
+                 "source": meta["url"], "provenance": "mixed"})
+        w.conn.execute("UPDATE models SET created_at=? WHERE id=?", (res["times"][q["best"]][1], out))
+        add_jobs(w, pid, res["run_id"], f"q3c-{q['key']}", "completed", start, res["end"],
+                 [{"name": "policy (2 nodes × 8) + 6 vLLM engines (TP4)", "cluster": C["rno2a"], "gpu": None, "gpus": 40},
+                  {"name": "sandboxes", "kind": "sandbox", "cluster": C["daytona"]}])
+        vals = {s: v for s, v in ser.get("val/pass_at_1", [])}
+        for s, v in sorted(vals.items()):
+            E.ev(f"hold|{q['hold']}", M["q3c"] if s == 0 else (out if s == q["best"] else None), v,
+                 started=(res["times"][s][1] if s in res["times"] else start - 1800) + 300, source=meta["url"],
+                 ek=f"{q['key']}|{s}", run_id=res["run_id"], step=s, provenance="mixed",
+                 config={"contaminated": s > 0, "note": "holdout overlaps the training source"})
+        q["_res"] = res
+    for key, name, env, hold_key, base_n, best_n, best, steps, recipe, reason, model_name in (
+            ("bugsinpy-v4", "q3c-bugsinpy-v4", env_bip, "bugsinpy", 43, 76, 24, 25,
+             "near-sync shaped RLOO-N, group 8, constant-denominator loss, entropy 3e-5, lr 2e-6, 4 warmup steps",
+             "Retired at step 25 after three entropy strikes.", "q3c-rl-bugsinpy-v49-factorial-constdenom-g8-lr2-r3"),
+            ("swegym-v5", "q3c-swegym-v5", env_swg, "swegym", 19, 38, 10, 11,
+             "the BugsInPy recipe (near-sync shaped RLOO-N, constant denominator, entropy 3e-5, lr 2e-6)",
+             "Stopped after step 11; about 78% of matched trials hit the 30-turn cap, so the result is confounded.",
+             "q3c-rl-swegym-v49-factorial-constdenom-g8-lr2-r1")):
+        start = at("2026-09-03 08:00") if key == "bugsinpy-v4" else at("2026-09-04 20:00")
+        reward = anchor_curve(steps, {1: 0.30 if key == "bugsinpy-v4" else 0.14, steps: 0.42 if key == "bugsinpy-v4" else 0.22},
+                              noise=0.03, seed=key)
+        seed = stable_seed("q3c", key)
+        rr = random.Random(seed)
+
+        def gen(step, x, rr=rr, strikes=(key == "bugsinpy-v4")):
+            e = 0.30 * (1 + (2.4 * max(0.0, x - 0.75) / 0.25 if strikes else 0.0)) * math.exp(rr.gauss(0, 0.05))
+            return {"policy/policy_entropy": e, "policy/raw_grad_norm": 0.1 * math.exp(rr.gauss(0, 0.3)),
+                    "async/staleness_mean": 0.0}
+        out = model(f"q3c|{key}", f"{model_name} (step {best})", arch="MoE (Qwen3-Coder-30B-A3B)", params_total=30.0,
+                    params_active=3.0, parent_id=M["q3c"], run_key=f"q3c|{key}", step=best, stage="RL", created_at=None,
+                    status="not released", source=Q3C_GIST, notes=f"Best #8942 checkpoint on {env.name}; {recipe}.")
+        res = simulate_run(
+            w, pid=pid, key=f"q3c|{key}", name=name, envs=[(env, 1.0)], base_model_id=M["q3c"], reward=reward, start=start,
+            times=step_times(steps, 1500, key, first=2.0), group_size=8, prompts=64, sample_groups=48, store_groups=2,
+            adv="rloo", sim_tags={"reward": "reward/avg_raw_reward", "pass_at_k": "reward/avg_pass_at_8",
+                                  "resp_len": "generate/avg_num_tokens", "step_time": "timing/step"},
+            gen=gen, series={"val/pass_at_1": [(0, base_n / 128), (best, best_n / 128)],
+                             "val/passed": [(0, base_n), (best, best_n)]},
+            harness="terminus-2", checkpoints=[{"step": best, "model_id": out, "title": f"Best checkpoint: step {best}"}],
+            steps_planned=30,
+            events=[{"step": steps, "kind": "alert", "severity": "warning", "title": reason.split(";")[0].rstrip("."),
+                     "body": reason}],
+            run={"algorithm": "RLOO-N (near-sync, shaped)", "framework": "MarinSkyRL (FSDP2) on Iris", "status": "stopped",
+                 "status_reason": reason, "output_model_id": out, "primary_metric": "reward/avg_raw_reward", "gpu": None,
+                 "gpus": 40, "tags": ["q3c-data-sweep", "simulated"], "group_name": "q3c-data-source-sweep (#8942)",
+                 "hyperparams": dict(q3c_hp, lr=2e-6, recipe=recipe, entropy_coef=3e-5, warmup_steps=4, max_staleness=0),
+                 "config": "\n".join(["# #8942 best recipe (gist)", f"source: {env.name}", f"recipe: {recipe}",
+                                      "loss_reduction: constant denominator", "entropy_coef: 3e-5", "lr: 2e-6", "warmup_steps: 4",
+                                      "max_staleness: 0   # near-sync", "train_batch_size: 64", "n_samples_per_prompt: 8",
+                                      "max_turns: 30"]),
+                 "description": f"#8942 best recipe on {env.name}: {recipe}. Published: holdout pass@1 {base_n}/128 → "
+                                f"{best_n}/128 at step {best} (the val/* points), the recipe and why it stopped. The training "
+                                f"curves, rollouts, dates and step times are simulated (no log is public)"
+                                + ("; entropy is simulated rising past 3× its start near the end, as the three entropy strikes imply." if key == "bugsinpy-v4" else "."),
+                 "source": Q3C_GIST, "provenance": "simulated"})
+        w.conn.execute("UPDATE models SET created_at=? WHERE id=?", (res["times"][best][1], out))
+        add_jobs(w, pid, res["run_id"], name, "stopped", start, res["end"],
+                 [{"name": "policy (2 nodes × 8) + 6 vLLM engines (TP4)", "cluster": C["rno2a"], "gpu": None, "gpus": 40}])
+        E.ev(f"hold|{hold_key}", M["q3c"], base_n / 128, started=start - 1800, source=I8942C, ek=f"{key}|0", run_id=res["run_id"],
+             step=0, config={"lineage_baseline": f"{base_n}/128"})
+        E.ev(f"hold|{hold_key}", out, best_n / 128, started=res["times"][best][1] + 300, source=Q3C_ART, ek=f"{key}|{best}",
+             run_id=res["run_id"], step=best)
+    for env, base, latest in ((env_mf, 0.1734, 0.22), (env_cal, 0.34, 0.46), (env_calif, 0.20, 0.32), (env_bip, 43 / 128, 76 / 128),
+                              (env_swg, 19 / 128, 38 / 128)):
+        store_tasks(w, env, base=base, latest=latest, attempts=8)
+
+    add_defs(w, pid, skyrl_defs(pid))
+
+    # reports ------------------------------------------------------------------------------------------------
+    kit.report(
+        w, pid, "a3", "A3 single-dataset RL sweep: uninformative about dataset utility", "Marin (#6187)", at("2026-06-06 12:00"),
+        "A3 trained one RLOO-N run per dataset from a fixed Qwen3-8B agent to rank RL datasets by how much they improve it. "
+        "Twenty runs finished, three collapsed to zero reward, four datasets were too large to extract, and six were stopped "
+        "or cancelled. Marin concluded the design measures the wrong thing and moved to shaped rewards and a new objective.",
+        [{"claim": "A fixed-recipe, one-dataset-per-run RL sweep ranks datasets by how much they improve the agent.",
+          "verdict": "rejected", "evidence": A3_CONCLUSION},
+         {"claim": "Binary reward gives most tasks a learning signal.", "verdict": "rejected",
+          "evidence": "#6187: 'binary reward leaves the majority of tasks with zero GRPO gradient'. The run pages' per-step group "
+                      "counts show the prompts whose 8 attempts all failed or all passed."},
+         {"claim": "Higher training reward means a better agent.", "verdict": "rejected",
+          "evidence": "Clean optimization 'collapses to concision / overconfident early-termination'; on Jupiter the hero-run "
+                      "reproduction converged on 'fewer, cleaner tool calls and shorter overall responses. Which tanks eval scores "
+                      "because the model gives up / submits solution too soon' (#6187 comment)."},
+         {"claim": "The OT-Agent 8B RL hero run reproduces across clusters.", "verdict": "rejected",
+          "evidence": "It reproduces on Perlmutter but not on Jupiter; Perlmutter hit an anomalous grad-norm and entropy "
+                      "blow-up and collapsed near step 40."},
+         {"claim": "pymethods2test-large, the paper hero dataset, reached 0.74 reward and 0.83 pass@8 at step 80.",
+          "verdict": "open",
+          "evidence": "#6187 lists 0.74 / 0.83; the published curve shows 0.559 reward and 0.672 pass@8 at step 80 and the model "
+                      "card reports EMA(80) 0.4829. The curve peaks at step 1 (0.7695). Unresolved."},
+         {"claim": "High A3 reward marked a usable dataset.", "verdict": "rejected",
+          "evidence": "Cross-check with TaskTrove Clean's later source verdicts: 8 of the 20 winners' sources were dropped for "
+                      "verifier defects (4 by the same name: inferredbugs 'never compiles or runs', nemotron-code-oracle-filtered "
+                      "'only test is the example shown in the prompt', crosscodeeval-csharp-v4 '0.25 reward for any "
+                      "identifier-shaped output', mix_h4_binary_easy; 4 in later versions, including identity-following, A3's "
+                      "strongest reward at 0.999)."},
+         {"claim": "Next: shaped reward on % tests passing, and a sequence-normalized objective tolerant of variable group sizes.",
+          "verdict": "open",
+          "evidence": "Stated next steps in #6187. The follow-ups used sequence-mean loss and, in #8942, shaped RLOO-N; #7785's "
+                      "launch configs still set reward shaping off."}],
+        run_keys=tuple(sweep_runs))
+    kit.report(
+        w, pid, "hpo", "TaskTrove hyperparameter campaign (#7785)", "Marin (#7785 report, 2026-08-18)", at("2026-08-18 00:00"),
+        "One hyperparameter per arm on Qwen3-Coder-30B-A3B-Instruct with DCAgent/exp_rpt_multifile under Terminus-2: 22 saved "
+        "models with reported results, about 53k GPU-hours. Arms are scored by the EMA-5 of pass@8 through the exported "
+        "checkpoint with a pooled-rollout 95% CI. Base mean reward 0.1734 over 1,090 trials; teachers GLM 5.2 0.351 and "
+        "Qwen3.5-122B-A10B 0.208.",
+        [{"claim": "I: Better hyperparameters raise peak reward and stability.", "verdict": "open",
+          "evidence": "Marin's verdict: partially upheld. X1, X2, X4, X5 and X7 were not statistically resolved; KL 0.01 was the "
+                      "only resolved gain but needed four more training nodes, so zero KL stayed the default."},
+         {"claim": "II: Weak students can match strong teachers after RL.", "verdict": "open",
+          "evidence": "Partially upheld: strong arms reach the 0.208 Qwen3.5-122B-A10B line after about 30–80 steps; GLM 5.2 is at 0.351."},
+         {"claim": "III: RL efficiency depends strongly on the implementation.", "verdict": "upheld",
+          "evidence": "Megatron policy training 14.94 s vs FSDP2 80.35 s per 1k response tokens (5.4×); median step 647.6 s vs 1,232.5 s."},
+         {"claim": "IV: Backends have similar stability and reward.", "verdict": "open",
+          "evidence": "Partially upheld: FSDP2 X10b 0.3662 [0.3475, 0.3849] vs Megatron X15 0.3484 [0.3298, 0.3669] (EMA-5 pass@8); "
+                      "the Megatron arms collapsed (X15 at steps 84–86)."},
+         {"claim": "V: Multiple epochs raise the policy beyond the band.", "verdict": "rejected",
+          "evidence": "Not upheld in the one admissible test: X10b plateaued by step ~45, mean raw reward 0.2186 / 0.2208 / 0.2167 / "
+                      "0.2039 over steps 40–60 / 60–80 / 80–100 / 100–131 (the published curve reproduces these)."}],
+        run_keys=tuple(f"hpo|{h['key']}" for h in hpo))
+    kit.report(
+        w, pid, "q3c", "Qwen3-Coder data-source sweep (#8942)", "Marin (#8942, closed 2026-09-06)", at("2026-09-06 00:00"),
+        "Four sources, fixed 128-task holdouts, best recipes per source: calendar instruction-following v3 0.21875 → 0.320, "
+        "calendar agent v2 0.34375 → 0.461, BugsInPy v4 43/128 → 76/128, SWE-Gym v5 19/128 → 38/128 (confounded). RL gains "
+        "were close to the base model's own pass@16 / pass@1 ratio, 'consistent with modest policy sharpening'.",
+        [{"claim": "pass@1 after RL was generally comparable to pass@16 before RL on the val set.", "verdict": "upheld",
+          "evidence": "#8942 finding, from the val-gain vs pass@16 ratio table."},
+         {"claim": "Holdout improvement is the most reliable way to evaluate the policy; reward trends are noisy.", "verdict": "upheld",
+          "evidence": "#8942: 'Holdout val set improvement is the most reliable way to evaluate the progress of the policy'."},
+         {"claim": "An async lag of 2 or more steps can introduce off-policy learning pathology.", "verdict": "upheld",
+          "evidence": "#8942 finding; the BugsInPy and SWE-Gym recipes run near-sync (staleness 0)."},
+         {"claim": "The 30-turn cap was adequate for SWE-Gym.", "verdict": "rejected",
+          "evidence": "'the 30-turn cap was excessively limiting' for SWE-Gym: about 78% of matched trials hit it."},
+         {"claim": "The largest gain (BugsInPy v4, 43/128 → 76/128, 1.77×) came from a sound task source.", "verdict": "open",
+          "evidence": "TaskTrove Clean later dropped the same-name source laion__exp_rpt_bugsinpy-v4: 'LLM-synthesized tests "
+                      "against a single-file stub, with assert True placeholders'. Whether #8942's split has the same tests "
+                      "is not stated."}],
+        run_keys=tuple(f"q3c|{q['key']}" for q in q3c_runs) + ("q3c|bugsinpy-v4", "q3c|swegym-v5"))
+    kit.report(
+        w, pid, "tasktrove", "TaskTrove Clean: what curation found (#7784, release logbook)", "Marin (#7784, TaskTrove Clean)",
+        at("2026-09-18 00:00"),
+        "The two-week bring-up (#7784: 221 merged PRs across MarinSkyRL and harbor; TaskTrove v3.7 → v3.17) repaired about "
+        "195k task instances and made about 155k more RL-ready across ~40 datasets, while the per-arm footprint fell from 8 "
+        "nodes / 64 GPUs to 4 nodes / 32 GPUs and context rose from 32,768 / 4,096 / 30 turns to 131,072 / 16,384 / 90. The "
+        "Clean release then kept 861,848 of 1,739,326 rows with a reason for every rejection.",
+        [{"claim": "The bring-up produced a measurable gain over the base model.", "verdict": "rejected",
+          "evidence": "#7784: 'no arm demonstrated a measurable gain over its base model across eight salvaged checkpoints'; the "
+                      "only reported gain was retracted. Verifier bugs found: untouched workspaces scored as success, verifiers "
+                      "that could never score 1, one that silently degraded a graded reward to binary."},
+         {"claim": "Every retained task scores an empty answer 0.", "verdict": "upheld",
+          "evidence": "Validity sample of release 2026.09.10.4 (10 tasks per converter): 190 of 190 empty workspaces scored 0."},
+         {"claim": "Oracle answers score 1.", "verdict": "upheld",
+          "evidence": "90 of 94 oracles scored 1 in the same sample (4 exceptions)."},
+         {"claim": "Judge-graded tasks run without extra infrastructure.", "verdict": "rejected",
+          "evidence": "The 30 judge tasks of the validity sample were infra_error because no judge endpoint was configured."},
+         {"claim": "JavaScript and TypeScript SWE sources are usable.", "verdict": "rejected",
+          "evidence": "Their oracles passed only 11/20 and 3/20, so those sets stayed rejected."},
+         {"claim": "Stronger models score higher on kept sources.", "verdict": "upheld",
+          "evidence": "Reward-delta study (≤ 300 trials per source): 24 sources with a monotonic gap ≥ 0.10; mean GLM 5.2 − "
+                      "Qwen3-Coder gap 0.22."},
+         {"claim": "The clean corpus trains a small model end to end.", "verdict": "open",
+          "evidence": "Smoke RL on Qwen3-0.6B (2 GRPO steps, 160 tasks over 16 converters, 2 H100 nodes): attempt 1 failed on "
+                      "vLLM /tokenize 404s, attempt 2 on Harbor's reward.json schema; attempt 3 ran 726 trials with 0 failed, 0 "
+                      "masked and 166 TurnCapExhaustedError, at reward 0.0 because the 0.6B model solved nothing (plumbing only)."}])
+    return pid
+
+
+
+# ================================================================== (c) Snowball 67B-A2B post-training
+
+SFT_BASE_SCORES = (17.67, 64.00, 12.67)   # grug-67b-a2b-sft-s2-thinking-step630: AIME24 / MATH-500 / OlympiadBench
+MATH_ARMS = [
+    # key, label, dataset, objective, steps, ckpt, (AIME24, MATH-500, OlympiadBench), repo, selection, router, family, anchors, extra
+    ("e1", "E1 ctx8k-p8", "DAPO-17k", "GRPO (unregularized)", 5, 5, (15.67, 70.40, 13.33),
+     "open-athena/Snowball-67B-A2B-Math-RL-E1-ctx8k-p8-Step5", "Only evaluated E1 checkpoint; re-evaluation scores",
+     "SFT router-bias repaired", "e", {1: 0.06, 5: 0.12}, {"note": "one cell of the context × policy-node grid (8,192 window, 8 policy nodes)"}),
+    ("e2", "E2 unregularized", "DAPO-17k", "GRPO (unregularized)", 21, 20, (18.00, 71.40, 14.67),
+     "open-athena/Snowball-67B-A2B-Math-RL-E2-Unreg-Step20", "Final and strongest aggregate E2-unreg checkpoint",
+     "SFT router-bias repaired", "e", {1: 0.06, 21: 0.30}, {}),
+    ("e6", "E6 original", "RLVR-MATH", "GRPO (unregularized)", 20, 20, (26.00, 76.80, 22.67),
+     "open-athena/Snowball-67B-A2B-Math-RL-E6-Step20-Repaired", "Headline E6 checkpoint in MATH_EVALS.md",
+     "SFT router-bias repaired; exact evaluated artifact", "e", None, {"real": "marin-snowball-e6-rlvr-math",
+                                                                        "router": "mutable (replace); export repaired by SFT router-bias transplant"}),
+    ("e6-repro", "E6 reproduction A", "RLVR-MATH", "GRPO (unregularized)", 20, 20, (19.67, 73.60, 20.00),
+     "open-athena/Snowball-67B-A2B-Math-RL-E6-Repro-Step20", "Final representative reproduction", "Frozen router bias", "e",
+     {1: 0.11, 20: 0.46}, {"note": "claim VI: this reproduction had higher training reward than E6 original but lower held-out scores"}),
+    ("hero-v3g", "hero-v3g", "RLVR-MATH", "GRPO", 15, 12, (19.33, 64.80, 18.67),
+     "open-athena/Snowball-67B-A2B-Math-RL-Hero-v3g-Step12", "Final evaluated v3g checkpoint", "Frozen router bias", "hero-muon",
+     {1: 0.10, 15: 0.38}, {}),
+    ("hero-v3i", "hero-v3i", "RLVR-MATH", "GRPO", 18, 8, (17.00, 72.20, 17.67),
+     "open-athena/Snowball-67B-A2B-Math-RL-Hero-v3i-Step8", "Best v3i checkpoint; step 16 regressed", "Frozen router bias",
+     "hero-adam", {1: 0.10, 18: 0.36}, {"note": "stopped at about step 18"}),
+    ("e11", "E11", "DeepScaleR", "DAPO", 50, 24, (20.00, 72.80, 19.33), "open-athena/Snowball-67B-A2B-Math-RL-E11-Step24",
+     "Report's best E11 checkpoint across three suites", "Frozen router bias", "hero-dapo", None,
+     {"real": "marin-snowball-e11-deepscaler-dapo"}),
+    ("e12", "E12", "DeepScaleR", "GRPO", 24, 8, (20.00, 71.00, 15.00), "open-athena/Snowball-67B-A2B-Math-RL-E12-Step8",
+     "Best E12 checkpoint by aggregate held-out score", "Frozen router bias", "hero-muon", None,
+     {"real": "marin-snowball-e12-deepscaler-grpo", "note": "E11 config with the objective reverted (control); cancelled after banking step 24",
+      "status": "stopped", "reason": "Cancelled after banking step 24 (control for E11)."}),
+    ("e13", "E13", "RLVR-MATH", "DAPO", 14, 8, (15.00, 69.60, 13.67), "open-athena/Snowball-67B-A2B-Math-RL-E13-Step8",
+     "Only evaluated E13 checkpoint", "Frozen router bias", "hero-dapo", {1: 0.10, 14: 0.33},
+     {"status": "failed", "reason": "Died at step 14 on a trainer uid-collision defect (fixed upstream in MarinSkyRL #439)."}),
+    ("e14", "E14", "DAPO-17k", "GRPO", 16, 16, (20.67, 73.80, 15.67), "open-athena/Snowball-67B-A2B-Math-RL-E14-Step16",
+     "Final and strongest E14 checkpoint", "Frozen router bias", "hero-muon", {1: 0.06, 16: 0.30},
+     {"note": "E12 recipe on DAPO-17k; sealed at max_steps 16"}),
+    ("e15", "E15", "RLVR-MATH", "GRPO (unregularized)", 20, 20, (24.00, 74.20, 21.67),
+     "open-athena/Snowball-67B-A2B-Math-RL-E15-Step20-Repaired", "Final repaired E15 checkpoint",
+     "SFT router-bias repaired; VERIFY OK", "e", {1: 0.11, 20: 0.40},
+     {"router": "interpolated update w=0.5; export repaired", "unrepaired": (2.00, 22.40, 1.67)}),
+    ("e17a", "E17a", "RLVR-MATH", "GRPO (unregularized)", 20, 16, (15.33, 75.60, 19.67),
+     "open-athena/Snowball-67B-A2B-Math-RL-E17a-Step16", "MATH_EVALS.md marks this as the arm's best row",
+     "Frozen router bias; zero drift", "e", {1: 0.11, 10: 0.717, 20: 0.73},
+     {"router": "frozen + stochastic rounding (MarinSkyRL #452)", "note": "the recommended recipe (exact config published); "
+      "training pass@1 reached 0.717 by step 10 without improving AIME24, and AIME24 truncation fell from 81% to 13%"}),
+    ("e17b1", "E17b1", "RLVR-MATH", "GRPO (unregularized)", 20, 20, (20.33, 73.40, 17.33),
+     "open-athena/Snowball-67B-A2B-Math-RL-E17b1-Step20-Repaired", "Final repaired E17b1 checkpoint",
+     "SFT router-bias repaired; VERIFY OK", "e", {1: 0.11, 20: 0.42},
+     {"router": "interpolate w=0.05 + stochastic rounding; export repaired"}),
+    ("e17b2", "E17b2", "RLVR-MATH", "GRPO (unregularized)", 20, 20, (20.67, 77.20, 22.00),
+     "open-athena/Snowball-67B-A2B-Math-RL-E17b2-Step20-Repaired", "Best E17 step-20 arm", "SFT router-bias repaired; VERIFY OK",
+     "e", {1: 0.11, 20: 0.44}, {"router": "interpolate w=0.15 + stochastic rounding; export repaired"}),
+    ("e17d", "E17d", "RLVR-MATH", "GRPO (unregularized)", 20, 8, (3.33, 37.80, 5.67),
+     "open-athena/Snowball-67B-A2B-Math-RL-E17d-Step8-Repaired", "Only repaired E17d export; final step 20 remains an unrepaired gap",
+     "SFT router-bias repaired control", "e", {1: 0.11, 8: 0.25, 20: 0.35},
+     {"router": "DeepSeek loss-free balancing, rate 0.01 (#454)", "lossfree": (5.33, 64.00, 19.00)}),
+    ("e17f", "E17f", "DeepScaleR", "GRPO (unregularized)", 20, 16, (14.00, 60.80, 9.33),
+     "open-athena/Snowball-67B-A2B-Math-RL-E17f-Step16", "Last usable E17f checkpoint before step-20 collapse",
+     "Frozen router bias; zero drift", "e", {1: 0.05, 16: 0.42, 18: 0.34, 20: 0.26},
+     {"router": "frozen + stochastic rounding (E17a config with DeepScaleR)", "collapse": 44.60}),
+    ("e18", "E18", "RLVR-MATH", "GRPO (unregularized)", 20, 8, (37.33, 83.00, 13.33),
+     "open-athena/Snowball-67B-A2B-Math-RL-E18-Step8", "Campaign-best absolute AIME24 and MATH-500",
+     "Frozen router bias; zero drift against 5.7T start", "e", {1: 0.25, 20: 0.50}, {"start": (37.00, 78.20, 9.00)}),
+]
+MATH_START = {"e1": "2026-07-30 06:00", "e2": "2026-07-31 00:00", "e6": "2026-08-02 00:00", "e6-repro": "2026-08-09 00:00",
+              "hero-v3g": "2026-08-14 00:00", "hero-v3i": "2026-08-16 00:00", "e11": "2026-08-17 06:00",
+              "e12": "2026-08-18 06:00", "e13": "2026-08-19 00:00", "e14": "2026-08-20 00:00", "e15": "2026-08-21 00:00",
+              "e17a": "2026-08-23 00:00", "e17b1": "2026-08-24 00:00", "e17b2": "2026-08-24 12:00", "e17d": "2026-08-25 00:00",
+              "e17f": "2026-08-25 12:00", "e18": "2026-08-26 06:00"}
+MATH_FAMILY = {
+    "e": dict(opt="AdamW", lr=1e-5, clip_high=0.2, maxgen=6528, window="8,192 = 1,664 input + 6,528 generated",
+              geo="8 policy nodes × 8 H100 + 2 vLLM engine nodes (TP1, DP8, EP8)", extra="grad clip 0.5, no KL, no entropy bonus"),
+    "hero-muon": dict(opt="Muon-H", lr=1e-4, clip_high=0.2, maxgen=8192, window="ctx10k body",
+                      geo="10 × H100x8 on cw-rno2a", extra="TIS cap 2.0, v3d token-level loop credit, no dynamic sampling"),
+    "hero-adam": dict(opt="AdamW", lr=1e-5, clip_high=0.2, maxgen=8192, window="ctx10k body", geo="10 × H100x8 on cw-rno2a",
+                      extra="TIS cap 2.0, v3d token-level loop credit, no dynamic sampling"),
+    "hero-dapo": dict(opt="Muon-H", lr=1e-4, clip_high=0.4, maxgen=8192, window="ctx10k body", geo="10 × H100x8 on cw-rno2a",
+                      extra="TIS cap 2.0, v3d token-level loop credit, DAPO dynamic-sampling filter"),
+}
+RLVR1_DOMAINS = [  # agent, rows, viewer domain, reward shape seen in v104 traces, offset (weak domains per #9359), tokens
+    ("single_step_tool_use_with_argument_comparison_agent", 20015, "tool_use", "binary", 0.12, 1200),
+    ("instruction_following_simple_agent", 11817, "if", "binary", 0.08, 1800),
+    ("code_gen_simple_agent", 7918, "code", "binary", -0.25, 5200),
+    ("ns_tools_simple_agent", 5911, "math", "binary", -0.18, 4800),
+    ("math_with_judge_simple_agent", 4767, "math", "binary", -0.18, 4800),
+    ("mcqa_simple_agent", 4168, "other", "binary", 0.10, 2200),
+    ("multichallenge_simple_agent", 4024, "chat", "partial", 0.02, 1800),
+    ("abstention_simple_agent", 4019, "other", "partial", 0.05, 1200),
+    ("toolcall_schema_single_step_tool_use_with_argument_comparison_agent", 4006, "tool_use", "binary", 0.12, 1200),
+    ("genrm_simple_agent", 3377, "chat", "partial", 0.05, 2400),
+    ("nvarc_inductive_simple_agent", 2094, "other", "binary", -0.45, 5500),
+    ("reasoning_gym_simple_agent", 2087, "other", "partial", -0.05, 3000),
+    ("structured_outputs_simple_agent", 2076, "other", "binary", -0.35, 1800),
+    ("nvarc_transductive_simple_agent", 2069, "other", None, -0.45, 5500),
+    ("jailbreak_refusal_with_explanation", 1985, "chat", "partial", 0.15, 800),
+    ("genrm_simple_agent_reasoning_off", 1412, "chat", "partial", 0.05, 1500),
+    ("calendar_simple_agent", 910, "tool_use", "binary", 0.12, 1200),
+    ("math_formal_lean_refinement_agent", 900, "math", "binary", -0.35, 5500),
+    ("jailbreak_hard_refusal_with_helplines", 416, "chat", "partial", 0.15, 800),
+    ("jailbreak_engagement_with_disclaimer", 286, "chat", "binary", 0.15, 800),
+    ("jailbreak_hard_refusal_no_redirection", 169, "chat", None, 0.15, 800),
+]
+PANEL_MODELS = [  # tracker label, key
+    ("Qwen/Qwen3.6-35B-A3B", "b-qwen36"), ("Qwen/Qwen3-Coder-30B-A3B-Instruct", "b-q3c"),
+    ("Qwen/Qwen3-Next-80B-A3B-Instruct", "b-qwen3next"), ("inclusionAI/Ling-lite-1.5", "b-ling"),
+    ("google/gemma-4-26B-A4B-it", "b-gemma4"), ("nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16", "b-nemo35"),
+    ("openai/gpt-oss-20b", "b-gptoss20"), ("nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16", "b-nemo3nano"),
+    ("moonshotai/Kimi-Linear-48B-A3B-Instruct", "b-kimi"), ("arcee-ai/Trinity-Mini", "b-trinity"),
+    ("open-athena/Grug-67B-A2B-Datakit-SFT-262K-2026.09.17", "S1"), ("open-athena/Snowball-67B-A2B-10T-Mixed-RLVR-Sync-Step92", "S2"),
+    ("laion/snowball-67b-a2b-sft-s3-nemotron-terminal-step1888", "S3"), ("laion/snowball-67b-a2b-rl-r2egym-newstack-step24", "S4"),
+    ("open-athena/Snowball-67B-A2B-Math-RL-E6-Step20-Repaired", "S5")]
+EVALCHEMY = ("Evalchemy at a 73,664-token context (73,728 served minus a 64-token margin); a trial times out at 30 min and is "
+             "scored 0.0 as AgentTimeoutError.")
+HARBOR = ("Harbor agents at 32,768 tokens. AgentTimeoutError, ContextLengthExceededError, TurnCapExhaustedError and "
+          "NonZeroAgentExitCodeError are score-able model errors (the verifier runs on whatever the agent left); unless the policy "
+          "names an error as a model error it is an infrastructure error. Timeouts: agent setup 6 min (infrastructure, retried), "
+          "agent execution 30 min (scored), verifier 5 min (infrastructure, retried). If more than 10% of a benchmark's tasks fail "
+          "on infrastructure, the whole score is invalid.")
+JUDGE = ("Judge: openai/gpt-oss-120b via Together at 131,072 tokens; a judge call that fails after retries is recorded as a "
+         "grader infrastructure failure, not a zero.")
+PANEL = [  # tracker key, name, category, metric, n, k, per_task, harness, extra description, n published?
+    ("math500", "MATH-500", "Math", "accuracy", 500, 1, False, "Evalchemy", EVALCHEMY, True),
+    ("humanevalplus", "HumanEval+", "Code", "accuracy", 164, 1, False, "Evalchemy", EVALCHEMY, False),
+    ("mbppplus", "MBPP+", "Code", "accuracy", 378, 1, False, "Evalchemy", EVALCHEMY, False),
+    ("olympiadbench", "OlympiadBench (30-question subset)", "Math", "accuracy", 30, 10, True, "Evalchemy",
+     EVALCHEMY + " 30-question subset, 10 samples. " + JUDGE + " (judge used as a fallback grader)", True),
+    ("gsm8k-0shot", "GSM8K (0-shot)", "Math", "accuracy", 1319, 1, False, "lm-eval-harness", "", False),
+    ("piqa", "PIQA", "Knowledge", "accuracy", 1838, 1, False, "lm-eval-harness", "", False),
+    ("winogrande", "WinoGrande", "Knowledge", "accuracy", 1267, 1, False, "lm-eval-harness", "", False),
+    ("boolq", "BoolQ", "Knowledge", "accuracy", 3270, 1, False, "lm-eval-harness", "", False),
+    ("truthfulqa", "TruthfulQA (mc2)", "Knowledge", "mc2", 817, 1, False, "lm-eval-harness", "", False),
+    ("triviaqa", "TriviaQA", "Knowledge", "accuracy", 17944, 1, False, "lm-eval-harness", "", False),
+    ("aime24", "AIME24 (10 launches × 10 repeats)", "Math", "accuracy", 30, 100, True, "Evalchemy",
+     EVALCHEMY + " 10 launches × 10 repeats per question.", True),
+    ("mmlu-pro", "MMLU-Pro", "Knowledge", "accuracy", 12032, 1, False, "Evalchemy", "Evalchemy at a 65,536-token context.", False),
+    ("gpqa-diamond", "GPQA Diamond (3 samples)", "Science", "accuracy", 198, 3, False, "Evalchemy", EVALCHEMY + " 3 samples.", False),
+    ("cruxeval", "CRUXEval (output)", "Code", "accuracy (output)", 800, 1, False, "Evalchemy", EVALCHEMY, False),
+    ("financebench", "FinanceBench", "Finance", "accuracy", 150, 1, False, "Evalchemy", EVALCHEMY + " " + JUDGE, False),
+    ("ifbench", "IFBench", "Instruction following", "strict prompt-level accuracy", 300, 1, False, "Evalchemy", EVALCHEMY, False),
+    ("mrcr", "MRCR", "Long context", "mean sequence similarity", 100, 1, False, "Evalchemy",
+     EVALCHEMY + " Models run at their native context (32,768 for the Stage-3 SFT, 65,536 for math RL E6).", False),
+    ("NUPA", "NUPA", "Numeracy", "exact match", 238926, 1, False, "Evalchemy", EVALCHEMY + " 238,926 items.", True),
+    ("swebench-recovery", "SWE-bench Verified random-100", "Agentic (Harbor)", "accuracy", 100, 1, True, "Harbor / Terminus-2",
+     HARBOR + " Tracker key swebench-recovery.", True),
+    ("ot-tblite-recovery", "OpenThoughts-TBLite 2.0", "Agentic (Harbor)", "accuracy", 100, 1, True, "Harbor / Terminus-2",
+     HARBOR + " Tracker key ot-tblite-recovery.", True),
+    ("tb2-recovery", "Terminal-Bench 2.0", "Agentic (Harbor)", "accuracy", 89, 1, True, "Harbor / Terminus-2",
+     HARBOR + " Tracker key tb2-recovery.", True),
+    ("ds-1000-local", "DS-1000 (mini-200)", "Code", "accuracy", 200, 1, False, "Harbor / Terminus-2",
+     HARBOR + " Seed-42 sample of 200.", True),
+    ("bfclparity-pi", "BFCL-Parity @ Pi", "Tool use", "accuracy", 200, 1, False, "Harbor / Pi", HARBOR, False),
+    ("bixbench-pi", "BixBench CLI corrections @ Pi", "Science agent", "accuracy", 205, 1, False, "Harbor / Pi",
+     HARBOR + " " + JUDGE, True),
+    ("tau3-pi", "tau3-bench @ Pi", "Tool use", "accuracy", 100, 1, False, "Harbor / Pi ACP", HARBOR, False),
+    ("SOTOPIA-hard", "SOTOPIA-hard", "Social", "normalized goal achievement", 100, 1, False, "Harbor / SOTOPIA agent",
+     HARBOR + " 100 hard episodes. " + JUDGE, True),
+]
+
+
+def v104_outcome(a):
+    if a.get("truncated"):
+        return "truncated", "max_tokens"
+    r = a["reward"] or 0.0
+    stop = {"stop": "submitted", "length": "max_tokens", "tool_calls": "tool_calls", "error": "http_error"}.get(a["stop"], a["stop"])
+    if r >= 1.0:
+        return "passed", stop
+    if r > 0:
+        return ("partial" if a["reward_kind"] == "partial" else "passed"), stop
+    return "failed", stop
+
+
+def build_snowball(w, org_id, C):
+    recipe = load_json("recipe.json.gz")
+    pid = kit.project(
+        w, org_id, "snowball-67b-a2b", "Snowball 67B-A2B post-training",
+        "Post-training Marin's first MoE, Snowball / Grug 67B-A2B (256 routed experts, 4 active, about 2B active parameters), "
+        "toward the September 2026 milestone 'Launch post-trained 67B-A2B to the world'. The July two-stage and September "
+        "Datakit SFTs; a 17-run math RLVR campaign (#7786) written up as claims with verdicts; mixed-domain RLVR on 84,426 "
+        "Nemotron RL Ultra prompts over 21 domains on 64 H100s per arm (512 × 16 per step), which produced the release "
+        "candidate Step92 (#9359); SWE RL on R2E-Gym (#9225); an on-policy distillation replication; and the 2026-09-24 eval "
+        "policy (#9409) with its 26-benchmark panel of 5 Snowball checkpoints and 10 baselines (#9412).",
+        [{"title": "Issue #7786 and corrected checkpoint catalog", "url": I7786C},
+         {"title": "Report: non-agentic RL on Snowball (2026.08.27.1)", "url": MATH_REPORT},
+         {"title": "E17a exact config", "url": E17A_CFG}, {"title": "Issue #9359: mixed-domain RLVR", "url": I9359},
+         {"title": "Mixed-RLVR experiment artifacts (v104 record)", "url": RLVR_ART},
+         {"title": "RLVR1 reproduction data", "url": RLVR1_DATA}, {"title": "Issue #9409: eval policy 2026-09-24", "url": I9409},
+         {"title": "Issue #9412: baselines and first Snowball results", "url": I9412},
+         {"title": "Eval policy TRACKER.md", "url": TRACKER}, {"title": "Issue #9225: base vs SFT vs RL vs SFT-then-RL", "url": I9225},
+         {"title": "Issue #8901: pre-RL R2E-Gym probe", "url": I8901}, {"title": "Issue #8937: R2E-Gym no-op-patch finding", "url": I8937},
+         {"title": "2-stage SFT script", "url": SFT2STAGE}, {"title": "Datakit SFT 09.17 card", "url": DK_CARD},
+         {"title": "Open-MOPD replication card", "url": MOPD}, {"title": "Milestone 13", "url": MILESTONE}],
+        "Published: every metric of the three public math-RL curves (E6, E11, E12) and of the v104 RLVR1 run, whose real "
+        "rollouts (36 random complete 16-rollout groups from each of steps 1 and 15), 800 holdout samples and trimmed "
+        "transcripts are stored; all hyperparameters, row counts, checkpoint catalogs, held-out math scores, the #9225 SWE-bench "
+        "and TB2 results, the 26-benchmark panel and the reports' claims. Simulated to agree with them: the curves of runs "
+        "without public logs (anchored on every published training value), dates and step times (the only published step time "
+        "is 2,937 s for the RLVR1 control at step 2), rollouts of all other runs and per-task eval results pinned to each "
+        "published score. The panel's per-eval infrastructure counts are not published. Not included: Delphi RL scaling "
+        "(#6279) and curriculum RL (#8765).",
+        at("2026-07-20 00:00"), pins=["train/pass_at_1", "reward/avg_raw_reward", "reward/avg_pass_at_16"])
+    M = {}
+
+    def model(key, name, kind="checkpoint", **kw):
+        M[key] = kit.model(w, pid, key, name, kind, **kw)
+        return M[key]
+    GRUG = "MoE (Grug): 256 routed experts, top-4, 26 layers, hidden 2,560, 20 heads / 5 KV heads"
+    model("june-base", "Grug 67B-A2B base (june-67b-a2b step-42150, July 2T cooldown)", "base", arch=GRUG, params_total=67.0,
+          params_active=2.0, stage="Pretrained", created_at=at("2026-07-15 00:00"), status="internal", source=S2_CARD,
+          notes="Base of the July two-stage SFT.")
+    model("base157k", "Snowball 67B-A2B base (step 157,000, unpublished)", "base", arch=GRUG, params_total=67.08,
+          params_active=2.0, stage="Pretrained", created_at=at("2026-09-10 00:00"), status="internal", source=DK_CARD,
+          notes="The Datakit SFT 09.17 card says it made 1,000 SFT updates from an unpublished base step 157,000; the RLVR exports "
+                "from the Datakit SFTs are named 10T.")
+    model("s3", "snowball-67b-a2b-sft-s3-nemotron-terminal-step1888 (Stage-3 SFT)", hf_repo="laion/snowball-67b-a2b-sft-s3-nemotron-terminal-step1888",
+          arch=GRUG, params_total=67.0, params_active=2.0, context_len=32768, stage="SFT", created_at=at("2026-09-01 00:00"),
+          status="released", source=I9412,
+          notes="5.7T-cooldown Stage-3 agentic checkpoint; base for R2E-Gym RL, math RL E18 and the 5.7T mixed-RLVR arm; "
+                "32,768-token native context. Lineage candidate S3 in #9412. Its own SFT run is not documented.")
+    model("dk0911", "Grug-67B-A2B-Datakit-SFT-262K-2026.09.11", hf_repo="open-athena/Grug-67B-A2B-Datakit-SFT-262K-2026.09.11",
+          arch=GRUG, params_total=67.08, params_active=2.0, stage="SFT", created_at=at("2026-09-11 00:00"), status="released",
+          source=RLVR_ART, parent_id=M["base157k"],
+          notes="Start checkpoint of the September 11 mixed-RLVR lineages (pinned at HF revision 50a201b1).")
+    model("dk0921", "Grug-67B-A2B-Datakit-SFT-262K-2026.09.21", hf_repo="open-athena/Grug-67B-A2B-Datakit-SFT-262K-2026.09.21",
+          arch=GRUG, params_total=67.08, params_active=2.0, stage="SFT", created_at=at("2026-09-22 00:00"), status="released",
+          source=I9225_DK, parent_id=M["base157k"],
+          notes="Datakit SFT mix of 53.7B tokens, about 4% terminus-2 JSON with the reasoning stripped; with thinking off it "
+                "scores 21/100 on SWE-bench Verified random-100 and 6/85 on TB2.")
+    model("gptoss120b", "openai/gpt-oss-120b (eval judge)", "judge", hf_repo="openai/gpt-oss-120b", arch="MoE",
+          params_total=120.0, context_len=131072, created_at=at("2026-09-16 00:00"), status="external", source=I9409,
+          notes="Judge for FinanceBench, BixBench, the OlympiadBench fallback and SOTOPIA-hard, served via Together.")
+    for label, key in PANEL_MODELS[:10]:
+        model(key, label.split("/")[-1], "external", hf_repo=label, created_at=at("2026-09-24 00:00"), status="external",
+              source=TRACKER, notes="Baseline of the 2026-09-24 eval policy panel (#9409, #9412).")
+
+    # graders ----------------------------------------------------------------------------------------------
+    g_aime = kit.grader(w, pid, "aime", "aime verifier (boxed, ±1)", "math_verify",
+                        "Minerva-style boxed-answer verifier ('Answer: \\boxed{}'): +1 for a correct final answer, −1 otherwise; "
+                        "the same grader family as held-out MATH-500. Training pass@1 is derived from the ±1 raw reward.",
+                        [{"name": "boxed answer", "weight": 1.0, "rule": "+1 if the boxed answer matches, else −1."}],
+                        "reward = +1 if correct else −1")
+    g_ultra = kit.grader(w, pid, "ultra", "Nemotron RL Ultra per-agent verifiers", "other",
+                         "Each domain agent of the NVIDIA Nemotron RL Ultra blend brings its own verifier through the skyrl_gym "
+                         "route; Marin sources do not document their internals. Reward shapes (binary or partial) are those seen "
+                         "in the retained v104 traces.",
+                         [{"name": "domain verifier", "weight": 1.0, "rule": "Per-agent verifier; binary or partial."}])
+    g_genrm = kit.grader(w, pid, "genrm", "genrm judge (temperature 0.0)", "llm_judge",
+                         "Generative reward-model judge sampled at temperature 0.0 (v104 resolved config); partial rewards.",
+                         [{"name": "genrm score", "weight": 1.0, "rule": "Judge score."}])
+    g_r2e = kit.grader(w, pid, "r2e", "R2E-Gym hidden tests", "unit_tests",
+                       "Hidden tests run on the patched repository after the Terminus-2 agent finishes; binary.",
+                       [{"name": "hidden tests", "weight": 1.0, "rule": "1 if the tests pass, else 0."}])
+
+    # datasets ---------------------------------------------------------------------------------------------
+    ds_s1 = kit.dataset(w, pid, "sft-s1-wildchat", "Grug SFT stage 1: wildchat (chat format)", "sft",
+                        sources=[{"name": "wildchat (plain chat, no thinking traces)", "category": "chat"}],
+                        description="Stage 1 of the July two-stage SFT: plain chat to establish the chat template. Row count not "
+                                    "published.", created_at=at("2026-07-18 00:00"), source=SFT2STAGE, provenance="published")
+    ds_s2 = kit.dataset(w, pid, "sft-s2-thinking", "Grug SFT stage 2: science reasoning (thinking)", "sft",
+                        hf_repo="laion/llama-nemotron-science-reasoning-on-canonical-think-full",
+                        sources=[{"name": "laion/llama-nemotron-science-reasoning-on-canonical-think-full", "category": "science",
+                                  "url": "https://huggingface.co/datasets/laion/llama-nemotron-science-reasoning-on-canonical-think-full"}],
+                        description="Stage 2 thinking data; one packed epoch is 630 steps of 64 × 32,768 tokens. Row count not "
+                                    "published.", created_at=at("2026-07-18 00:00"), source=S2_CARD, provenance="published")
+    dk_src = [x["name"] for x in recipe["datasets"][8]["sources"]]
+    ds_dk = kit.dataset(w, pid, "datakit-sft", "Grug Datakit SFT mix (registry; 2026-09-21 mix 53.7B tokens)", "sft",
+                        tokens=53_700_000_000,
+                        sources=[{"name": nm, "category": s_["category"]} for nm, s_ in zip(dk_src, recipe["datasets"][8]["sources"])],
+                        processing=[{"step": "Exclusion", "rows_in": None, "rows_out": None,
+                                     "note": "Two penfever-traces exports excluded because they 'omit the original user request "
+                                             "... and the served tool definitions'."},
+                                    {"step": "Mixture (2026-09-21)", "rows_in": None, "rows_out": None,
+                                     "note": "53.7B tokens, about 4% terminus-2 JSON with the reasoning stripped; per-source "
+                                             "weights are not public."}],
+                        description="The DataKit SFT source registry (17 named chat sources plus the penfever-traces, nemotron_sft, "
+                                    "nemotron_sft_v3 and open-swe-traces partitions). The 09.17 card names its sources as "
+                                    "OpenThoughts code, SWE-ZERO, Penfever traces, NuminaMath and GLM format-following and compaction "
+                                    "data, with 20% of packed sequences from long-context pretraining replay.",
+                        created_at=at("2026-09-10 00:00"), source=DK_SOURCES, provenance="published")
+    ds_glm = kit.dataset(w, pid, "glm53-rlvr-sft", "GLM 5.3 RLVR SFT conversations", "sft", rows=5000,
+                         sources=[{"name": "rendered GLM 5.3 RLVR conversations", "category": "other", "rows": 5000,
+                                   "synthetic": True, "generator": "GLM 5.3"}],
+                         description="5,000 rendered GLM 5.3 RLVR conversations; assistant-only loss, greedy packing into "
+                                     "32,768-token sequences.", created_at=at("2026-09-22 00:00"), source=GLM53_SFT,
+                         provenance="published")
+    ds_ag = kit.dataset(
+        w, pid, "stage3-agentic-sft", "Stage-3 agentic SFT data (#9225 arms)", "sft", tokens=1_080_000_000,
+        sources=[{"name": "OTA2: OpenThoughts-Agent-SFT-100K minus IssueTasks", "category": "agentic", "rows": 64022, "synthetic": True},
+                 {"name": "if-v2: open-athena/nemotron-gym-if-v2-qwen3.5-122b-32k-traces", "category": "if", "rows": 12484,
+                  "synthetic": True, "generator": "Qwen3.5-122B"},
+                 {"name": "RST: recursive-task-synthesis GLM-5.3 rollouts (14,410 tasks; 9,396 successes, ≥ 5 turns)",
+                  "category": "terminal", "rows": 9396, "synthetic": True, "generator": "GLM-5.3"}],
+        processing=[{"step": "Contamination removal", "rows_in": None, "rows_out": 64022,
+                     "note": "IssueTasks removed from OpenThoughts-Agent-SFT-100K: 255 of the 500 SWE-bench Verified issues "
+                             "appear rewritten inside it."},
+                    {"step": "Decontamination check", "rows_in": None, "rows_out": None,
+                     "note": "RST: zero shared word 8-grams with TB2 or SWE-bench Verified."}],
+        description="SFT data of the four #9225 arms on the Stage-3 Snowball: A = OTA2 + if-v2, B = RST + if-v2, C = OTA2 + RST + "
+                    "if-v2, D = OTA2 + RST successes + if-v2 (arm D packed 1.08B tokens).",
+        created_at=at("2026-09-17 00:00"), source=I9225_SFT, provenance="published")
+    ds_math = kit.dataset(
+        w, pid, "math-rlvr", "Snowball math RLVR sets", "rl",
+        sources=[{"name": "RLVR-MATH (snowball-67b-a2b-rlvrmath-7498)", "category": "math", "rows": 7498},
+                 {"name": "DeepScaleR", "category": "math"}, {"name": "DAPO-17k", "category": "math"}],
+        processing=[{"step": "Prepare", "rows_in": None, "rows_out": None,
+                     "note": "infra.rl_data at pinned source and validation SHAs; datasets from the marin#6279 known-good set; "
+                             "prompt budget = request window − max new tokens."}],
+        description="The three math prompt sets of the #7786 campaign. HF revisions and row counts of DeepScaleR and DAPO-17k as "
+                    "used by Marin were not found.", created_at=at("2026-07-28 00:00"), source=MATH_REPORT, provenance="published")
+    ex = recipe["datasets"][2]["examples"]
+    ds_r1 = kit.dataset(
+        w, pid, "rlvr1", "Snowball RLVR1 blend (Nemotron RL Ultra, skyrl_gym route)", "rl", rows=84426,
+        hf_repo="open-athena/Snowball-67B-A2B-RLVR1-Repro-Data",
+        license="no blanket license; components CC BY-SA 4.0, CC BY 4.0, ODC-BY 1.0, MIT, Apache 2.0",
+        sources=[{"name": a_, "category": dom if dom != "other" else "other", "rows": n_, "url": RLVR1_DATA}
+                 for a_, n_, dom, _, _, _ in RLVR1_DOMAINS],
+        processing=[{"step": "RLVR1 phase of the converted blend", "rows_in": None, "rows_out": 91026,
+                     "note": "skyrl_gym 84,526 + terminal_bench 6,500 rows."},
+                    {"step": "Route filter (skyrl_gym only)", "rows_in": 91026, "rows_out": 84526,
+                     "note": "Purpose: 'Exclude empirically zero-signal terminal-bench cohorts after 256/256 observed timeouts'."},
+                    {"step": "Holdout", "rows_in": 84526, "rows_out": 84426,
+                     "note": "Ordered tail holdout of the last 100 selected rows (validation.parquet); the async arm later used "
+                             "89 rows after removing 11 LiveCodeBench/code-generation rows."}],
+        samples=[{"source": "RLVR1 train", "category": "rl", "data": {"messages": [{"role": "user", "content": e_["prompt"]}]}}
+                 for e_ in ex],
+        description="Selected from the skyrl_gym route of a TaskTrove conversion of the public NVIDIA Nemotron RL Ultra training "
+                    "blend, preserving source order and holding out the last 100 selected rows: 84,426 training rows over 21 "
+                    "domain agents (counts are the dossier's count of extra_info.nemotron_ultra.agent). No shuffling: RLVR2 "
+                    "follows RLVR1.", created_at=at("2026-09-10 00:00"), source=RLVR1_PROV, provenance="published")
+    kit.dataset(w, pid, "rlvr2", "Snowball RLVR2 blend", "rl", rows=85118, parent_key="rlvr1", hf_repo=None,
+                processing=[{"step": "RLVR2 phase with the same route filter", "rows_in": 91718, "rows_out": 85118,
+                             "note": "85,118 train + 100 validation rows."}],
+                description="The second phase of the same blend, used for RLVR2 steps after RLVR1.",
+                created_at=at("2026-09-10 00:00"), source=RLVR1_DATA, provenance="published")
+    ds_mopd = kit.dataset(w, pid, "open-mopd", "Open-MOPD data", "distill", hf_repo="BytedTsinghua-SIA/Open-MOPD-Data",
+                          description="Prompts of the Open-MOPD on-policy distillation recipe; size not published.",
+                          created_at=at("2026-09-12 00:00"), source=MOPD, provenance="published")
+
+    # environments ------------------------------------------------------------------------------------------
+    def placeholder_tasks(prefix, n, text):
+        return [(f"{prefix}-{i:04d}", text, ["placeholder"]) for i in range(n)]
+    ENV = {}
+    for key, name, count, desc in (
+            ("rlvr-math", "RLVR-MATH (aime env)", 7498, "snowball-67b-a2b-rlvrmath-7498 in the E17a config; 7,498 problems."),
+            ("deepscaler", "DeepScaleR (aime env)", None, "DeepScaleR as used by Marin; row count not found."),
+            ("dapo17k", "DAPO-17k (aime env)", None, "DAPO-17k as used by Marin; row count not found.")):
+        ENV[key] = make_env(
+            w, pid, key, name, "math", tasks=placeholder_tasks(key, 60, f"Math problem from {name}; the problem text is not "
+                                                                    f"reproduced in the sources used here."),
+            task_count=count, grader_id=g_aime, harness="SkyRL standard entrypoint, single turn", reward_kind="binary",
+            description=f"Single-turn math prompts graded by the boxed-answer verifier with a ±1 reward. {desc} Stored tasks are "
+                        f"placeholders.", source=E17A_CFG, provenance="mixed", difficulty=(0.8, 2.0),
+            profile={"turns": (1, 1), "tokens_out": 2400, "tokens_in": 500, "seconds": 150, "infra_rate": 0.0,
+                     "max_tokens": 6528}, created_at=at("2026-07-28 00:00"),
+            checks=[{"name": "Known-good set", "status": "pass", "source": MATH_REPORT,
+                     "detail": "Datasets from the marin#6279 known-good set, prepared at pinned source and validation SHAs."}])
+    # RLVR1 domains: real v104 tasks (prompts from the retained traces), the 100-row holdout, then placeholders
+    att = load_jsonl("runs/marin-snowball-v104-rlvr1-traces/attempts.jsonl.gz")
+    tr = load_json("runs/marin-snowball-v104-rlvr1-traces/transcripts.json.gz")
+    prompts, transcripts = tr["prompts"], tr["transcripts"]
+    # the importer names tasks rlvr1-<row index> per file, so training and holdout ids collide; keep them apart
+    def tname(a_):
+        return f"rlvr1-{'holdout' if a_['kind'] == 'eval' else 'train'}-{a_['task'].split('-')[1]}"
+    dom_of_task = {tname(a_): a_["domain"] for a_ in att}
+    prompt_of = {tname(a_): prompts.get(f"{a_['kind']}:{a_['task']}") for a_ in att}
+    holdout = sorted({tname(a_) for a_ in att if a_["kind"] == "eval"}, key=lambda s: int(s.split("-")[2]))
+    trainset = sorted({tname(a_) for a_ in att if a_["kind"] == "train"}, key=lambda s: int(s.split("-")[2]))
+    RENV = {}
+    task_id = {}
+    for agent, rows, dom, shape, off, tok in RLVR1_DOMAINS:
+        jail = agent.startswith("jailbreak")
+        tasks = []
+        for nm_ in trainset + holdout:
+            if dom_of_task.get(nm_) != agent:
+                continue
+            text = ("Jailbreak-style safety prompt from the Nemotron RL Ultra blend; the text is not reproduced here." if jail else
+                    prompt_of.get(nm_) or "Prompt text not in the retained traces.")
+            tags = ["v104 holdout"] if nm_ in holdout else ["v104 step 1/15 prompt"]
+            tasks.append((nm_, text, tags))
+        hold_names = [t_ for t_ in holdout if dom_of_task.get(t_) == agent]
+        while len(tasks) < 30 + len(hold_names):
+            tasks.append((f"{agent}-{len(tasks):04d}", f"Prompt from the {agent} domain of the RLVR1 blend; its text is not stored.",
+                          ["placeholder"]))
+        rec = next(e_ for e_ in recipe["environments"] if e_["name"].endswith(": " + agent))
+        checks = [{"name": "Reward shape seen in v104 traces", "status": "pass" if shape else "warn", "source": V104,
+                   "detail": (f"{shape.capitalize()} rewards in the retained v104 step-1/step-15 traces." if shape else
+                              "No rollouts of this agent in the retained v104 sample; reward kind unknown.")},
+                  {"name": "Held-out rows", "status": "pass", "source": RLVR1_PROV,
+                   "detail": "The last 100 selected rows of the blend are the in-run holdout; the stored holdout tasks are "
+                             "marked excluded, so training never samples them."}]
+        if agent.startswith(("nvarc", "structured")):
+            checks.append({"name": "Output-contract mismatch", "status": "fail", "source": I9359,
+                           "detail": "'NVARC and structured-output verifiers had output-contract mismatches'; nearly all-zero "
+                                     "groups in these domains (#9359 per-domain trace analysis)."})
+        if agent.startswith(("nvarc", "math_formal_lean", "code_gen", "math_with_judge", "ns_tools")):
+            checks.append({"name": "Answers cut off at the turn cap", "status": "warn", "source": I9359,
+                           "detail": "'many Lean, coding, math, and NVARC generations also failed to reach a final answer before "
+                                     "the turn cap' (6,528 generated tokens per turn)."})
+        env = make_env(
+            w, pid, f"rlvr1|{agent}", f"RLVR1: {agent}", dom, tasks=tasks, task_count=rows,
+            grader_id=g_genrm if agent.startswith("genrm") else g_ultra, harness="SkyRL skyrl_gym env (nemotron_ultra)",
+            reward_kind=shape or "not observed", sandbox=None,
+            description=f"Nemotron RL Ultra domain agent {agent}: {rows:,} RLVR1 training rows. "
+                        + ("Prompts are not reproduced for jailbreak domains. " if jail else
+                           "Stored tasks are the real prompts of this domain in the retained v104 traces (training and "
+                           "holdout) plus placeholders. ")
+                        + f"Example in the dataset card: {(rec['example_task'].get('instruction') or 'none')[:160] if not jail else 'withheld'}.",
+            version="RLVR1", source=RLVR1_DATA, provenance="mixed", difficulty=(0.2, 2.2),
+            profile={"turns": (1, 3), "tokens_out": tok, "tokens_in": 900, "seconds": 120, "infra_rate": 0.003,
+                     "max_tokens": 6528, "judge": shape == "partial"},
+            checks=checks, created_at=at("2026-09-10 00:00"),
+            statuses=None)
+        for tk in env.tasks:
+            task_id[tk.name] = tk.id
+            if tk.name in holdout:
+                tk.status, tk.status_reason = "excluded", "Held out for in-run validation (the last 100 selected rows)."
+        RENV[agent] = (env, rows, off)
+    r2e_tasks = [("r2egym-v1-05937", "I've uploaded a python code repository in the directory /testbed. Consider the following "
+                                      "issue description: Title: QRdecomposition Fails on Wide and Rank Deficient Matrices …",
+                  ["published example"])] + placeholder_tasks("r2egym", 119, "R2E-Gym repository-fix task; its text is not "
+                                                                               "reproduced in the sources used here.")
+    env_r2e = make_env(
+        w, pid, "r2e", "R2E-Gym repository-fix tasks (terminus-2)", "swe", tasks=r2e_tasks, task_count=4245, grader_id=g_r2e,
+        harness="Harbor terminus-2 (summarization off in training)", tools=["terminal keystrokes (tmux)"], reward_kind="binary",
+        sandbox={"backend": "apptainer on JUWELS (RL) or Daytona (TaskTrove images)", "window": "64k: 49k input / 16k output"},
+        description="4,245 R2E-Gym training tasks (the pre-RL probe's count). RL from the base used a 1,003-task learnable band "
+                    "and SFT-then-RL a 939-task band screened from D epoch 1. Task statuses follow the #8937 audit of the "
+                    "TaskTrove v4.12 copy (shares applied to the stored sample).",
+        version="TaskTrove v4.12 audit", source=I8901, provenance="mixed", difficulty=(0.6, 2.0),
+        profile={"turns": (28, 100), "tokens_out": 9000, "tokens_in": 6000, "seconds": 900, "infra_rate": 0.02,
+                 "timeout_rate": 0.03, "max_tokens": 60000},
+        statuses={"hackable": 421 / 3035, "invalid": 25 / 3035},
+        reasons={"hackable": "Rewarded with no fix: the tests import the preinstalled pandas/numpy wheel, not /testbed (#8937).",
+                 "invalid": "The gold patch fails its own tests (#8937)."},
+        checks=[{"name": "Pre-RL probe (pass@8)", "status": "pass", "source": I8901,
+                 "detail": "Stage-3 Snowball, Terminus-2, 64k window, 4,245 train tasks at temperature 1.0: pass@1 13.3%, pass@8 "
+                           "37.1%; 36% of tasks have 1 to 7 wins out of 8. Failures came from SFT habits (patch files, "
+                           "SEARCH/REPLACE for a harness that is not there)."},
+                {"name": "No-fix vs gold-patch gate (#8937)", "status": "fail", "source": I8937,
+                 "detail": "In TaskTrove v4.12, 2,614 of the 3,035 active tasks behave correctly; 'The 421 pandas and numpy tasks "
+                           "give reward 1 no matter what the agent does'; '25 tasks have a gold patch that fails its own tests'."}],
+        created_at=at("2026-09-05 00:00"))
+
+    # SFT runs ---------------------------------------------------------------------------------------------
+    def sft(key, name, ds, base, steps, start, secs, lr, loss, gpus, gpu, cluster, desc, source, cfg, hp, out=None, group=None,
+            batch=64, seq=32768, log_every=None, ckpt=None, framework="Levanter / JAX (Grug MoE)"):
+        res = sft_run(w, project_id=pid, key=key, name=name, framework="trl_sft", datasets=[(ds, 1.0)], base_model_id=base,
+                      steps=steps, start=start, step_seconds=secs, loss=loss, lr=lr, warmup=0.03, schedule="cosine",
+                      global_batch=batch, seq_len=seq, gpu=gpu, gpus=gpus, cost_rate=0.0, tags=["sft"], config=cfg,
+                      hyperparams=hp, stage="SFT", description=desc, source=source, provenance="simulated",
+                      log_every=log_every, group_name=group, ckpt_every=ckpt, tokens_per_step=batch * seq * 0.9)
+        w.conn.execute("UPDATE runs SET framework=? WHERE id=?", (framework, res["run_id"]))
+        add_jobs(w, pid, res["run_id"], name, "completed", start, res["end"],
+                 [{"name": "trainer", "cluster": cluster, "gpu": gpu, "gpus": gpus, "nodes": (gpus or 0) // 8 or None}])
+        return res
+    s1 = sft("sft-s1", "grug-sft-s1-wildchat", ds_s1, M["june-base"], 257, at("2026-07-20 00:00"), 50.0, 5e-5, (1.6, 1.2), 64,
+             "H100", C["useast"], "Stage 1 of the July two-stage SFT: wildchat chat format on 8 nodes × 8 H100 (cw-us-east-02a), "
+             "global batch 64 × 32,768, AdamH lr 5e-5 cosine with 3% warmup, one epoch, assistant-only loss. Step count and "
+             "recipe are published; the curves and dates are simulated.", SFT2STAGE,
+             "\n".join(["# sft_67b_a2b_2stage.py, stage 1", "cluster: cw-us-east-02a (8 nodes × 8 H100-80GB)", "global_batch: 64",
+                        "seq_len: 32768", "optimizer: AdamH (beta2 0.95), cosine, warmup 3%, min_lr_ratio 0.1",
+                        "learning_rate: 5e-5", "epochs: 1   # 257 steps", "loss: assistant span only, packed"]),
+             {"optimizer": "AdamH (beta2 0.95)", "min_lr_ratio": 0.1, "loss": "assistant-only, packed"}, log_every=2)
+    s1m = model("s1", "grug-67b-a2b-sft-s1-wildchat-step257", hf_repo="penfever/grug-67b-a2b-sft-s1-wildchat-step257",
+                arch=GRUG, params_total=67.0, params_active=2.0, parent_id=M["june-base"], run_key="sft-s1", step=257,
+                stage="SFT", created_at=s1["end"], status="released", source=SFT2STAGE, notes="Chat-format stage.")
+    s2 = sft("sft-s2", "grug-sft-s2-thinking", ds_s2, s1m, 630, s1["end"] + H, 50.0, 5e-5, (1.2, 0.85), 64, "H100", C["useast"],
+             "Stage 2 of the July two-stage SFT on laion/llama-nemotron-science-reasoning-on-canonical-think-full: one packed "
+             "epoch = 630 steps; same hardware and optimizer. Its export is the start point of the math RL campaign (AIME24 "
+             "17.67, MATH-500 64.00, OlympiadBench 12.67). Curves and dates are simulated.", S2_CARD,
+             "\n".join(["# sft_67b_a2b_2stage.py, stage 2", "data: laion/llama-nemotron-science-reasoning-on-canonical-think-full",
+                        "global_batch: 64", "seq_len: 32768", "optimizer: AdamH (fp32)", "learning_rate: 5e-5",
+                        "epochs: 1   # 1 packed epoch = 630 steps", "loss: cut cross-entropy (batched_xla)"]),
+             {"optimizer": "AdamH (fp32)", "loss": "cut cross-entropy"}, log_every=3)
+    s2m = model("s2", "grug-67b-a2b-sft-s2-thinking-step630", hf_repo="marin-community/grug-67b-a2b-sft-s2-thinking-step630",
+                arch=GRUG, params_total=67.0, params_active=2.0, parent_id=s1m, run_key="sft-s2", step=630, stage="SFT",
+                created_at=at("2026-07-25 00:00"), status="released", source=S2_CARD,
+                notes="'~67B (A2B active MoE ...)'. The RL start point of the math campaign.")
+    dk = sft("dk0917", "datakit-sft-262k-0917", ds_dk, M["base157k"], 1000, at("2026-09-17 00:00"), 70.0, 2.828427e-4,
+             (1.1, 0.78), None, None, None,
+             "Datakit SFT 09.17: 1,000 SFT updates from the unpublished base step 157,000 with head-only init, learning rate "
+             "scaled from 5e-5 by √32 to 2.828427e-4, router weights and biases frozen, and 20% of packed sequences from "
+             "long-context pretraining replay. The card: 'This model has not been properly tested or evaluated'. Hardware, curves "
+             "and dates are not published (simulated).", DK_CARD,
+             "\n".join(["# Grug-67B-A2B-Datakit-SFT-262K-2026.09.17 card", "base: unpublished step 157,000",
+                        "learning_rate: 2.828427e-4   # 5e-5 × sqrt(32)", "updates: 1000", "router: weights and biases frozen",
+                        "long_context_replay: 20% of packed sequences", "mixture_cap: one pass per source",
+                        "configured_context: 262144   # long context untested"]),
+             {"router": "frozen", "long_context_replay": 0.2, "configured_context": 262144}, log_every=5)
+    dkm = model("S1", "Grug-67B-A2B-Datakit-SFT-262K-2026.09.17", hf_repo="open-athena/Grug-67B-A2B-Datakit-SFT-262K-2026.09.17",
+                arch="GrugMoeForCausalLM: 256 routed experts top-4 + shared expert, 26 layers, hidden 2560, 7 full-attention + 19 "
+                     "sliding-window (2,048) layers", params_total=67.078882816, params_active=2.0, context_len=262144,
+                parent_id=M["base157k"], run_key="dk0917", step=1000, stage="SFT", created_at=at("2026-09-19 00:00"),
+                status="released", source=DK_CARD,
+                notes="67,078,882,816 parameters, about 2B active non-embedding per token; 262,144 is a configured value. "
+                      "Lineage candidate S1 in #9412 (aggregate paired win rate 51.0%, 3rd of 5).")
+    glm = sft("glm53-sft", "glm53-rlvr-sft", ds_glm, M["dk0921"], 136, at("2026-09-22 18:00"), 60.0, 5e-5, (0.9, 0.6), 64, "H100",
+              C["rno2a"], "SFT on 5,000 rendered GLM 5.3 RLVR conversations from the Datakit SFT 09.21: assistant-only loss, greedy "
+              "packing into 32,768-token sequences, 136 optimizer steps on 64 H100s. Learning rate not published (placeholder); "
+              "curves and dates simulated.", GLM53_SFT,
+              "\n".join(["# Grug-67B-A2B-GLM53-RLVR-SFT-2026.09.23 card", "data: 5,000 rendered GLM 5.3 RLVR conversations",
+                         "loss: assistant-only", "packing: greedy into 32,768-token sequences", "steps: 136", "gpus: 64 H100",
+                         "learning_rate: not published"]), {"lr_note": "not published; 5e-5 is a placeholder"}, log_every=1)
+    glmm = model("glm53-sft", "Grug-67B-A2B-GLM53-RLVR-SFT-2026.09.23", hf_repo="open-athena/Grug-67B-A2B-GLM53-RLVR-SFT-2026.09.23",
+                 arch=GRUG, params_total=67.08, params_active=2.0, parent_id=M["dk0921"], run_key="glm53-sft", step=136,
+                 stage="SFT", created_at=at("2026-09-23 00:00"), status="released", source=GLM53_SFT,
+                 notes="Start point of the GLM53 RLVR1 async run.")
+    model("glm53-rl48", "Grug-67B-A2B-GLM53-RLVR1-Async-Step48", hf_repo="open-athena/Grug-67B-A2B-GLM53-RLVR1-Async-Step48",
+          arch=GRUG, params_total=67.08, params_active=2.0, parent_id=glmm, step=48, stage="RL", created_at=at("2026-09-25 00:00"),
+          status="released", source=GLM53_RL,
+          notes="Snapshot of a still-active async RLVR1 run (MarinSkyRL a9e3066, Megatron, router replay); its configuration is "
+                "not published, so the run itself is not shown. Holdout pass@1 0.53535 (tied with step 50), avg_score 0.58757.")
+    for r_ in (s1, s2, dk, glm):
+        w.conn.execute("UPDATE runs SET output_model_id=? WHERE id=?", (
+            {s1["run_id"]: s1m, s2["run_id"]: s2m, dk["run_id"]: dkm, glm["run_id"]: glmm}[r_["run_id"]], r_["run_id"]))
+    # #9225 agentic SFT arms on the Stage-3 Snowball
+    arms = {}
+    for key, label, data, steps, nodeh, swe_v, tb2_v in (
+            ("A", "OTA2 + if-v2", "OTA2 + if-v2", 495, 13, 0.221, 0.051),
+            ("B", "RST + if-v2", "RST + if-v2", 159, 8, 0.030, 0.004),
+            ("C", "OTA2 + RST + if-v2", "OTA2 + RST + if-v2", 626, 16, 0.213, 0.035),
+            ("D", "OTA2 + RST successes + if-v2", "OTA2 + RST successes + if-v2", 1034, 23, 0.237, 0.077)):
+        secs = nodeh * H / (16 * steps)
+        res = sft(f"arm{key}", f"stage3-sft-arm-{key}", ds_ag, M["s3"], steps, at("2026-09-18 02:00") + "ABCD".index(key) * 3 * H,
+                  secs, 1e-4, (0.9, 0.45), None, "GH200", C["jupiter"],
+                  f"#9225 SFT arm {key} on the Stage-3 Snowball: {data}. Levanter on 16 GH200 nodes, lr 1e-4, 64 × 32,768 tokens "
+                  f"per step, AdamH with 3% warmup on a cosine over two epochs"
+                  + (" — arm D ran both epochs (1,034 steps) and exported epoch 1 at step 517" if key == "D" else
+                     f"; the arm stops after one epoch ({steps} steps)")
+                  + ". Steps and results are published; the curves, dates and per-arm step time are simulated within the "
+                    "published 8–23 node-hours per arm.", I9225_SFT,
+                  "\n".join([f"# #9225 arm {key} (marin branch lukedhlee/vista-snowball-sft @ 23d8fda7)", f"data: {data}",
+                             "nodes: 16 GH200", "learning_rate: 1e-4", "global_batch: 64 × 32,768 tokens",
+                             "schedule: AdamH, warmup 3%, cosine over 2 epochs", f"steps: {steps}"]),
+                  {"nodes": 16, "node_hours": f"within 8–23 per arm ({nodeh} assumed)"}, group="stage3-agentic-sft (#9225)",
+                  log_every=max(1, steps // 150), framework="Levanter (lukedhlee/vista-snowball-sft)")
+        w.conn.execute("UPDATE jobs SET nodes=16, gpus=NULL WHERE run_id=?", (res["run_id"],))
+        mk = model(f"arm{key}", f"Stage-3 SFT arm {key} ({label})" + (" epoch 2" if key == "D" else ""), arch=GRUG,
+                   params_total=67.0, params_active=2.0, parent_id=M["s3"], run_key=f"arm{key}", step=steps, stage="SFT",
+                   created_at=res["end"], status="not released", source=I9225_SFT, notes=f"#9225 SFT arm {key} export.")
+        w.conn.execute("UPDATE runs SET output_model_id=? WHERE id=?", (mk, res["run_id"]))
+        arms[key] = (res, mk, swe_v, tb2_v)
+    resD = arms["D"][0]
+    d1 = model("armD-e1", "Stage-3 SFT arm D epoch 1 (step 517)", arch=GRUG, params_total=67.0, params_active=2.0,
+               parent_id=M["s3"], run_key="armD", step=517, stage="SFT",
+               created_at=resD["end"] - (resD["end"] - at("2026-09-18 11:00")) / 2, status="not released", source=I9225_STACK,
+               notes="Arm D after one epoch (517 steps, 1.08B packed tokens): SWE-bench Verified random-100 0.241 [0.20, 0.29].")
+
+    # math RL campaign -------------------------------------------------------------------------------------------
+    E = Evals(w, pid)
+    E.bench("m-aime24", "AIME24 (10-rep accuracy_avg)", "Math (held-out, #7786)", "accuracy", 30, 10,
+            "Held-out AIME24 for the math RL arms: 30 problems × 10 repetitions, Evalchemy long-generation (8,192 generated tokens, "
+            "repetition_penalty 1.1). 'AIME24 has only 30 items': E15 @20 − E17a @16 is +8.67 with a 95% CI of [−1.00, +19.33] "
+            "(p = 0.082). Standard errors are MATH_EVALS.md's where the public curves carry them.", I7786C, harness="Evalchemy")
+    E.bench("m-math500", "MATH-500 (single pass)", "Math (held-out, #7786)", "accuracy", 500, 1,
+            "Held-out MATH-500, single pass, Evalchemy long-generation (8,192 generated tokens, repetition_penalty 1.1). Only "
+            "scores are stored (no per-task results).", I7786C, harness="Evalchemy", per_task=False)
+    E.bench("m-olympiad", "OlympiadBench (30-question text subset, 10 reps)", "Math (held-out, #7786)", "accuracy", 30, 10,
+            "Evalchemy's 30-question OlympiadBench text subset × 10 repetitions, long-generation settings as above.", I7786C,
+            harness="Evalchemy")
+    math_runs = {}
+    for (key, label, dset, obj, steps, ckpt, scores, repo, selection, router, fam, anchors, extra) in MATH_ARMS:
+        F = MATH_FAMILY[fam]
+        env = {"RLVR-MATH": ENV["rlvr-math"], "DeepScaleR": ENV["deepscaler"], "DAPO-17k": ENV["dapo17k"]}[dset]
+        base = M["s3"] if key == "e18" else s2m
+        start_scores = extra.get("start", SFT_BASE_SCORES)
+        real = extra.get("real")
+        series, sim_tags = {}, {}
+        if real:
+            ser = real_series(real)
+            p1 = dict(ser["train/pass_at_1"])
+            n = max(p1)
+            reward = [p1[s] for s in range(1, n + 1)]
+            series = ser
+            sim_tags = {}
+            prov = "mixed"
+        else:
+            n = steps
+            reward = anchor_curve(n, anchors, noise=0.02, seed=key)
+            sim_tags = {"pass_rate": "train/pass_at_1", "pass_at_k": "train/pass_at_16", "reward": "reward/avg_raw_reward"}
+            ho = {"heldout/aime24": [(0, start_scores[0]), (ckpt, scores[0])], "heldout/math500": [(0, start_scores[1]), (ckpt, scores[1])],
+                  "heldout/olympiadbench": [(0, start_scores[2]), (ckpt, scores[2])]}
+            if extra.get("collapse"):
+                ho["heldout/math500"].append((20, extra["collapse"]))
+            if extra.get("lossfree"):
+                lf = extra["lossfree"]
+                for tg, v in zip(("heldout/aime24", "heldout/math500", "heldout/olympiadbench"), lf):
+                    ho[tg].append((20, v))
+            series = ho
+            prov = "simulated"
+        status = extra.get("status", "completed")
+        reason = extra.get("reason", "")
+        times = step_times(n, 1500.0 if fam == "e" else 1700.0, key, sigma=0.12, first=1.8)
+        start = at(MATH_START[key])
+        mult = None
+        exact = {}
+        if key == "e17f":
+            mult = lambda s: 1.0 if s <= 16 else (1.9 if s <= 18 else 2.2)  # noqa: E731
+            exact = {16: {"truncated": round(0.069 * 4096)}, 18: {"truncated": round(0.384 * 4096)}}
+        out = model(f"math|{key}", repo.split("/")[1], hf_repo=repo, arch=GRUG, params_total=67.0, params_active=2.0,
+                    parent_id=base, run_key=f"math|{key}", step=ckpt, stage="RL", created_at=at("2026-09-20 00:00"),
+                    status="released", source=f"https://huggingface.co/{repo}",
+                    notes=f"{label} checkpoint step {ckpt} ({selection}; {router}). Corrected catalog of 2026-09-20.")
+        ckpts = [{"step": ckpt, "model_id": out, "title": f"Evaluated checkpoint: step {ckpt}", "body": selection}]
+        events = []
+        if extra.get("unrepaired"):
+            un = model("math|e15-unrepaired", "E15 step 20 (unrepaired export)", arch=GRUG, params_total=67.0, params_active=2.0,
+                       parent_id=base, run_key="math|e15", step=20, stage="RL", created_at=at("2026-08-22 00:00"),
+                       status="not released", source=MATH_REPORT,
+                       notes="The E15 step-20 export with the router bias as trained: it collapses on chat evals (2.00 / 22.40 / "
+                             "1.67) until the SFT router bias is transplanted back.")
+            events.append({"step": 20, "kind": "incident", "severity": "warning", "title": "Unrepaired export collapses",
+                           "body": "Mutable router-bias exports collapse at inference: E15 step 20 scores 2.00 / 22.40 / 1.67 "
+                                   "(AIME24 / MATH-500 / OlympiadBench) until the SFT router bias is transplanted into the export "
+                                   "(repaired: 24.00 / 74.20 / 21.67)."})
+        if extra.get("lossfree"):
+            lf_m = model("math|e17d-20", "E17d step 20 (loss-free router bias, no artifact)", arch=GRUG, params_total=67.0,
+                         params_active=2.0, parent_id=base, run_key="math|e17d", step=20, stage="RL",
+                         created_at=at("2026-08-26 00:00"), status="not released", source=I7786C,
+                         notes="Reported final E17d checkpoint with the intentionally trained loss-free router bias (not "
+                               "repaired or frozen); no repaired or frozen artifact exists (documented gap).")
+            ckpts.append({"step": 20, "model_id": lf_m, "title": "Reported final checkpoint: step 20",
+                          "body": "Loss-free router bias kept; no published artifact."})
+        if key == "e17f":
+            events.append({"step": 18, "kind": "incident", "severity": "warning", "title": "Response-length runaway",
+                           "body": "Truncation rose from 6.9% to 38.4% at steps 17–18; step-20 MATH-500 fell to 44.60. Only steps "
+                                   "8 and 16 are treated as usable."})
+        if key == "e13":
+            events.append({"step": 14, "kind": "incident", "severity": "error", "title": "Trainer uid-collision defect",
+                           "body": "The run died at step 14 on a trainer uid-collision defect, fixed upstream in MarinSkyRL #439."})
+        if key == "e17a":
+            events.append({"step": 0, "kind": "config", "title": "Stochastic rounding for bf16 AdamW",
+                           "body": "With bf16 updates, about 80% of expert-tensor elements and 69% of attention-tensor elements "
+                                   "never changed at lr 1e-5; stochastic rounding (MarinSkyRL #452) is now the default.", "t": start + 1})
+        hp = {"optimizer": F["opt"], "lr": F["lr"], "prompts_per_step": 256, "group_size": 16, "clip_low": 0.2,
+              "clip_high": F["clip_high"], "kl": "off", "window": F["window"], "max_generated_tokens": F["maxgen"],
+              "router": extra.get("router", router), "dataset": dset, "objective": obj, "family_extra": F["extra"]}
+        cfg = "\n".join([f"# #7786 math RL arm {label} (report 2026.08.27.1; corrected catalog)", f"start: {'Stage-3 SFT (5.7T)' if key == 'e18' else 'grug-67b-a2b-sft-s2-thinking-step630'}",
+                         f"dataset: {dset}", f"objective: {obj}", f"optimizer: {F['opt']} lr {F['lr']:g}",
+                         "batch: 256 prompts × 16 samples", f"clip: 0.2 / {F['clip_high']}", "kl: none; entropy bonus: none",
+                         f"window: {F['window']}", f"router_bias: {extra.get('router', router)}", f"geometry: {F['geo']}",
+                         f"other: {F['extra']}", "env: aime (Minerva/boxed verifier, ±1 reward)", "strategy: FSDP2, EP=1"]
+                        + (["# exact recommended recipe: snowball_e17a_rno2a_rlvrmath_frozen_sr.yaml"] if key == "e17a" else []))
+        res = simulate_run(
+            w, pid=pid, key=f"math|{key}", name=f"snowball-math-{key}", envs=[(env, 1.0)], base_model_id=base, reward=reward,
+            start=start, times=times, group_size=16, prompts=256, sample_groups=32, store_groups=2, adv="grpo", scale=(-1.0, 1.0),
+            series=series, sim_tags=sim_tags, exact=exact, harness="single turn", tok_mult=mult, events=events,
+            checkpoints=ckpts, steps_planned=max(steps, n), max_tokens=F["maxgen"],
+            run={"algorithm": obj, "framework": "MarinSkyRL (FSDP2) on Iris cw-rno2a", "status": status, "status_reason": reason,
+                 "output_model_id": out, "primary_metric": "train/pass_at_1", "gpu": "H100", "gpus": 80,
+                 "tags": ["math-rl", "public-log" if real else "simulated"], "config": cfg, "hyperparams": hp,
+                 "group_name": "snowball-math-rl (#7786)",
+                 "description": f"Math RLVR arm {label} on {dset} ({obj}, {F['opt']} {F['lr']:g}, 256 × 16, 80 H100) from "
+                                f"{'the Stage-3 SFT' if key == 'e18' else 'the stage-2 thinking SFT'}. Held-out AIME24 / MATH-500 / "
+                                f"OlympiadBench {start_scores[0]:.2f} / {start_scores[1]:.2f} / {start_scores[2]:.2f} → "
+                                f"{scores[0]:.2f} / {scores[1]:.2f} / {scores[2]:.2f} at step {ckpt} ({selection}; {router}). "
+                                + ("Metrics are the published per-step pass@k CSV and held-out evals; rollouts are simulated."
+                                   if real else "No per-step log is public: the training curves (anchored on published values "
+                                                "where any exist), rollouts, dates and step times are simulated; the held-out "
+                                                "scores are published.")
+                                + (f" Note: {extra['note']}." if extra.get("note") else ""),
+                 "source": I7786C if not real else MATH_REPORT, "provenance": prov, "datasets": [(ds_math, 1.0)],
+                 "start_body": f"{obj} on {dset}: 256 prompts × 16 samples per step, ±1 boxed-answer reward."})
+        add_jobs(w, pid, res["run_id"], f"snowball-math-{key}", status, start, res["end"],
+                 [{"name": "policy (FSDP2)", "cluster": C["rno2a"], "gpu": "H100", "gpus": 64 if fam == "e" else 64, "nodes": 8},
+                  {"name": "vLLM engines", "kind": "rollout", "cluster": C["rno2a"], "gpu": "H100", "gpus": 16, "nodes": 2}])
+        w.conn.execute("UPDATE models SET created_at=? WHERE id=?", (res["times"].get(ckpt, (res["end"], res["end"]))[1], out))
+        math_runs[key] = (res, out, base)
+        # held-out evals: start and checkpoint (published), plus every published intermediate point of the public curves
+        pts = {}
+        if real:
+            for tg, bk in (("heldout/aime24", "m-aime24"), ("heldout/math500", "m-math500"), ("heldout/olympiadbench", "m-olympiad")):
+                se = dict(series.get(tg + "_se", []))
+                for s, v in series.get(tg, []):
+                    pts[(bk, s)] = (v, se.get(s))
+        else:
+            for bk, i_ in (("m-aime24", 0), ("m-math500", 1), ("m-olympiad", 2)):
+                pts[(bk, 0)] = (start_scores[i_], None)
+                pts[(bk, ckpt)] = (scores[i_], None)
+            if extra.get("collapse"):
+                pts[("m-math500", 20)] = (extra["collapse"], None)
+            if extra.get("lossfree"):
+                for bk, v in zip(("m-aime24", "m-math500", "m-olympiad"), extra["lossfree"]):
+                    pts[(bk, 20)] = (v, None)
+        for (bk, s), (v, se) in sorted(pts.items(), key=lambda kv: (kv[0][1], kv[0][0])):
+            mid = base if s == 0 else (out if s == ckpt else (lf_m if extra.get("lossfree") and s == 20 else None))
+            tt = start - 3 * H if s == 0 else res["times"].get(s, (res["end"], res["end"]))[1] + 2 * H
+            E.ev(bk, mid, pc(v), started=tt, source=I7786C if not real else MATH_REPORT, ek=f"{key}|{s}", run_id=res["run_id"],
+                 step=s, stderr=pc(se) if se is not None else None, provenance="mixed")
+        if extra.get("unrepaired"):
+            for bk, v in zip(("m-aime24", "m-math500", "m-olympiad"), extra["unrepaired"]):
+                E.ev(bk, un, pc(v), started=res["end"] + 4 * H, source=MATH_REPORT, ek="e15|unrepaired",
+                     config={"export": "unrepaired router bias"})
+
+    # mixed-domain RLVR (#9359) ------------------------------------------------------------------------------
+    mix_envs = [(RENV[a_][0], RENV[a_][1]) for a_, *_ in RLVR1_DOMAINS]
+    offs = {RENV[a_][0].id: RENV[a_][2] for a_, *_ in RLVR1_DOMAINS}
+    rl_hp = {"advantage_estimator": "rloo_n", "optimizer": "AdamW", "max_grad_norm": 0.5, "weight_decay": 0.0, "prompts_per_step": 512,
+             "group_size": 16, "clip": "0.2 / 0.2", "kl": 0.0, "temperature": 1.0, "top_p": 1.0, "context_window": 32768,
+             "max_prompt_len": 26240, "max_generated_tokens": 6528,
+             "strategy": "Megatron (TP1/PP2/CP1/EP16 in the v65 grid; the v65 artifact notes CP2, EP8, no sample packing)",
+             "placement": "4 learner + 4 inference nodes (64 H100)", "data_order": "no shuffling; RLVR2 follows RLVR1"}
+
+    def rlvr_cfg(name, lr, extra_lines=()):
+        return "\n".join([f"# {name} (#9359 artifacts)", "advantage_estimator: rloo_n", f"optimizer: AdamW lr {lr}",
+                          "max_grad_norm: 0.5", "weight_decay: 0.0", "train_batch_size: 512   # prompts", "n_samples_per_prompt: 16",
+                          "eps_clip: 0.2 / 0.2", "use_kl_loss: false", "temperature: 1.0", "top_p: 1.0",
+                          "context_window: 32768   # 6,528 generated tokens per turn", "placement: 4 learner + 4 inference nodes (64 H100)",
+                          "schedule: RLVR1 steps 1-128, then RLVR2 steps 129-178 (planned)"] + list(extra_lines))
+    mixed = {}
+
+    def mixed_run(key, name, base, first, n, start, secs, reward, passk, status, reason, desc, cfg, hp, out_ckpts, events=(),
+                  parent=None, extra_series=None, source=I9359, gpus=64, write_rollouts=True, prov="simulated", tags=()):
+        rng_ = random.Random(stable_seed("mix", key))
+        times = step_times(n, secs, key, sigma=0.08, first=1.3)
+        ser = dict(extra_series or {})
+
+        def gen(step, x):
+            return {"policy/policy_entropy": 0.42 * (1 - 0.3 * x) * math.exp(rng_.gauss(0, 0.05)),
+                    "policy/raw_grad_norm": 0.15 * math.exp(rng_.gauss(0, 0.3))}
+        res = simulate_run(
+            w, pid=pid, key=key, name=name, envs=mix_envs, base_model_id=base, reward=reward, start=start, times=times,
+            group_size=16, prompts=512, first_step=first, sample_groups=40, store_groups=2, adv="rloo", series=ser,
+            sim_tags={"reward": "reward/avg_raw_reward", "resp_len": "generate/avg_num_tokens", "step_time": "timing/step",
+                      "pass_at_k": "reward/avg_pass_at_16"}, gen=gen, pass_curve=passk, harness="skyrl_gym (single turn)",
+            env_offsets=offs, env_series=True, events=events, checkpoints=out_ckpts, binary=False, write_rollouts=write_rollouts,
+            staleness=[0, 1, 2] if "async" in key else None,
+            run={"algorithm": "RLOO-N", "framework": "MarinSkyRL (Megatron) on Iris cw-rno2a", "status": status,
+                 "status_reason": reason, "primary_metric": "reward/avg_raw_reward", "gpu": "H100", "gpus": gpus,
+                 "tags": ["mixed-rlvr", *tags], "config": cfg, "hyperparams": hp, "group_name": "mixed-rlvr (#9359)",
+                 "parent_run_id": parent, "description": desc, "source": source, "provenance": prov,
+                 "datasets": [(ds_r1, 1.0)],
+                 "start_body": "RLOO-N on the RLVR1 blend (21 domain agents): 512 prompts × 16 samples per step, 64 H100."})
+        add_jobs(w, pid, res["run_id"], name, status, start, res["end"],
+                 [{"name": "learner (4 nodes × 8 H100)", "cluster": C["rno2a"], "gpu": "H100", "gpus": 32, "nodes": 4},
+                  {"name": "inference (4 nodes × 8 H100)", "kind": "rollout", "cluster": C["rno2a"], "gpu": "H100", "gpus": 32, "nodes": 4}])
+        return res
+    # RLVR1 sync (the release lineage) and its RLVR2 continuation
+    t0 = at("2026-09-11 12:00")
+    n1 = 110
+    r1 = anchor_curve(n1, {1: 0.374, 12: 0.52, 40: 0.60, 92: 0.64, 110: 0.645}, noise=0.012, seed="rlvr1-sync")
+    p1 = anchor_curve(n1, {1: 0.508, 40: 0.60, 110: 0.62}, noise=0.012, seed="rlvr1-sync-p")
+    step92 = model("S2", "Snowball-67B-A2B-10T-Mixed-RLVR-Sync-Step92", hf_repo="open-athena/Snowball-67B-A2B-10T-Mixed-RLVR-Sync-Step92",
+                   arch=GRUG, params_total=67.078882816, params_active=2.0, parent_id=M["dk0911"], run_key="rlvr1-sync", step=92,
+                   stage="RL", created_at=at("2026-09-19 00:00"), status="released", source=STEP92,
+                   notes="The Snowball release candidate: leads the five-model lineage cohort 69-30-5 (68.8% aggregate win rate, "
+                         "4-0-0 pair series) over the 26-benchmark panel, but 'Step92 was selected using point estimates from "
+                         "this same 26-benchmark panel, so these are in-sample release-selection results' (#9412). The HF card is "
+                         "empty; its lr (4e-6) is inferred from the lineage job names (adam4e6). Parameter count from HF "
+                         "safetensors metadata.")
+    res1 = mixed_run(
+        "rlvr1-sync", "rlvr1-sync-adam4e6", M["dk0911"], 1, n1, t0, 2937.0, r1, p1, "completed",
+        "RLVR1 sealed at step 110; RLVR2 continued from this checkpoint.",
+        "RLVR1 with synchronous RLOO-N (the v65 control arm, AdamW 4e-6) from the Datakit SFT 09.11: the release lineage. Step "
+        "92 is the release candidate Step92. Published: the recipe, geometry, the 2,937 s step time at step 2 (2.1% policy-train "
+        "and 0.4% end-to-end MFU) and that 'RLVR1 produced clear early learning'. No RLVR1 training value of this arm is "
+        "published, so its curves are simulated; the step-1 reward is set to v104's logged 0.374 because both start from the "
+        "same checkpoint and unshuffled data (my assumption).",
+        rlvr_cfg("RLVR1 sync, v65 control arm (adam4e6)", "4e-6", ["# lr inferred from the job names (adam4e6); no resolved config for Step92"]),
+        dict(rl_hp, lr=4e-6, lr_source="inferred from job names (adam4e6)", v65_grid="adam4e6 (control), adam8e6, adam4e6 + entropy 0.01, adam4e6 + beta2 0.95"),
+        [{"step": 92, "model_id": step92, "title": "Checkpoint step 92 (release candidate)",
+          "body": "Exported as Snowball-67B-A2B-10T-Mixed-RLVR-Sync-Step92."}, {"step": 110, "title": "Checkpoint step 110 (sealed)"}],
+        events=[{"step": 2, "kind": "notice", "title": "Step time 2,937 s at step 2",
+                 "body": "The control ran 2,937 s per step at step 2, at 2.1% policy-train MFU and 0.4% end-to-end MFU."}],
+        source=I9359_GRID, tags=["release-lineage"])
+    mixed["rlvr1-sync"] = res1
+    r2 = anchor_curve(50, {1: 0.655, 6: 0.67631429, 8: 0.672, 50: 0.5974}, noise=0.01, seed="rlvr2-sync")
+    p2 = anchor_curve(50, {1: 0.605, 6: 0.6171875, 8: 0.6367, 50: 0.5039}, noise=0.01, seed="rlvr2-sync-p", hi=0.6367)
+    p2[7] = 0.6367
+    s116 = model("rlvr2-sync-116", "Snowball-67B-A2B-10T-Mixed-RLVR2-Sync-Step116", hf_repo="open-athena/Snowball-67B-A2B-10T-Mixed-RLVR2-Sync-Step116",
+                 arch=GRUG, params_total=67.08, params_active=2.0, parent_id=step92, run_key="rlvr2-sync", step=116, stage="RL",
+                 created_at=at("2026-09-23 00:00"), status="released", source=RLVR2_SYNC,
+                 notes="Best complete retained RLVR2 sync checkpoint: training pass@16 0.6171875, reward 0.67631429, 100-row holdout "
+                       "avg_score / pass@1 0.5275 / 0.44. The true pass@16 peak (step 118) was removed by checkpoint pruning. "
+                       "Trained with a 32K context window.")
+    res2 = mixed_run(
+        "rlvr2-sync", "rlvr2-sync-adam4e6", step92, 111, 50, res1["end"] + 2 * H, 2937.0, r2, p2, "completed",
+        "Completed its cumulative step-160 target.",
+        "RLVR2 (steps 111–160) continuing the sync lineage from RLVR1 checkpoint 110 (v115/v120, adam4e6). Published: step 116 "
+        "training pass@16 0.6171875 and reward 0.67631429, the pass@16 peak 0.6367 at step 118, and step 160 reward 0.5974 / "
+        "pass@16 0.5039 at sealing; 'RLVR2 validation was flat to regressing'. Other steps are simulated between these points.",
+        rlvr_cfg("RLVR2 sync (v115/v120, adam4e6)", "4e-6"), dict(rl_hp, lr=4e-6, lr_source="job name adam4e6 (v115/v120)"),
+        [{"step": 116, "model_id": s116, "title": "Checkpoint step 116 (released)"},
+         {"step": 118, "title": "Step 118: pass@16 peak (pruned)", "kept": False,
+          "body": "The true RLVR2 sync peak 'had already been removed by checkpoint pruning'; the bucket had no recoverable versions."}],
+        parent=res1["run_id"],
+        extra_series={"eval/all/pass_at_1": [(116, 0.44)], "eval/all/avg_score": [(116, 0.5275)]}, source=RLVR2_SYNC, tags=["release-lineage"])
+    mixed["rlvr2-sync"] = res2
+    # async lineage
+    ra = anchor_curve(n1, {1: 0.374, 12: 0.51, 40: 0.59, 110: 0.63}, noise=0.013, seed="rlvr1-async")
+    pa = anchor_curve(n1, {1: 0.508, 40: 0.59, 110: 0.61}, noise=0.013, seed="rlvr1-async-p")
+    a92 = model("async92", "Snowball-67B-A2B-10T-Mixed-RLVR-Async-Step92", hf_repo="open-athena/Snowball-67B-A2B-10T-Mixed-RLVR-Async-Step92",
+                arch=GRUG, params_total=67.08, params_active=2.0, parent_id=M["dk0911"], run_key="rlvr1-async", step=92, stage="RL",
+                created_at=at("2026-09-21 00:00"), status="released", source=I9359, notes="Async (bounded-staleness) RLVR1 lineage export.")
+    resa = mixed_run(
+        "rlvr1-async", "rlvr1-async-staleness2", M["dk0911"], 1, n1, t0 + 600, 2400.0, ra, pa, "completed",
+        "RLVR1 sealed at step 110; RLVR2 async continued from this checkpoint.",
+        "RLVR1 under bounded-staleness asynchronous RLOO-N (max staleness 2, TIS, router replay, TITO) from the same Datakit SFT. "
+        "The async lineage is not a clean algorithm-only comparison: early local inference-bridge overload, and its holdout "
+        "later dropped 11 LiveCodeBench rows. No training value of this arm is published and its step time is not stated "
+        "(2,400 s assumed); curves are simulated.",
+        rlvr_cfg("RLVR1 async", "not published", ["max_staleness_steps: 2", "tis: true", "router_replay: true", "tito: true"]),
+        dict(rl_hp, lr="not published", max_staleness=2, tis=True, router_replay=True, tito=True),
+        [{"step": 92, "model_id": a92, "title": "Checkpoint step 92", "body": "Exported as ...-Async-Step92."},
+         {"step": 110, "title": "Checkpoint step 110 (sealed)"}],
+        events=[{"step": 4, "kind": "incident", "severity": "warning", "title": "Inference-bridge overload",
+                 "body": "Early history includes local inference-bridge overload; recorded as a confound."}])
+    ra2 = anchor_curve(36, {1: 0.62, 30: 0.61, 36: 0.59610817}, noise=0.01, seed="rlvr2-async")
+    pa2 = anchor_curve(36, {1: 0.62, 30: 0.6660, 36: 0.63671875}, noise=0.01, seed="rlvr2-async-p", hi=0.6660)
+    a146 = model("async146", "Snowball-67B-A2B-10T-Mixed-RLVR2-Async-Step146", hf_repo="open-athena/Snowball-67B-A2B-10T-Mixed-RLVR2-Async-Step146",
+                 arch=GRUG, params_total=67.08, params_active=2.0, parent_id=a92, run_key="rlvr2-async", step=146, stage="RL",
+                 created_at=at("2026-09-23 00:00"), status="released", source=RLVR2_ASYNC,
+                 notes="Best complete retained RLVR2 async checkpoint: training pass@16 0.63671875, reward 0.59610817, holdout "
+                       "avg_score / pass@1 0.4625 / 0.37 (amended 89-row holdout). The true pass@16 peak (step 140) was pruned.")
+    resa2 = mixed_run(
+        "rlvr2-async", "rlvr2-async-staleness2", a92, 111, 36, resa["end"] + 2 * H, 2400.0, ra2, pa2, "stopped",
+        "Sealed at step 146 when the campaign's arms were sealed.",
+        "RLVR2 (steps 111–146) continuing the async lineage from RLVR1 async checkpoint 110. Published: step 146 training "
+        "pass@16 0.63671875, reward 0.59610817 and holdout 0.4625 / 0.37 on the amended 89-row holdout; the pass@16 peak "
+        "0.6660 at step 140 (pruned). Other steps simulated.",
+        rlvr_cfg("RLVR2 async", "not published", ["max_staleness_steps: 2"]), dict(rl_hp, lr="not published", max_staleness=2),
+        [{"step": 140, "title": "Step 140: pass@16 peak (pruned)", "kept": False, "body": "Removed by checkpoint pruning."},
+         {"step": 146, "model_id": a146, "title": "Checkpoint step 146 (released)"}],
+        parent=resa["run_id"], extra_series={"eval/all/pass_at_1": [(146, 0.37)], "eval/all/avg_score": [(146, 0.4625)]},
+        source=RLVR2_ASYNC)
+    # RLVR1 from the 5.7T Stage-3 SFT
+    r57 = anchor_curve(46, {1: 0.45, 20: 0.62, 46: 0.6791}, noise=0.012, seed="rlvr1-57t")
+    p57 = anchor_curve(46, {1: 0.55, 46: 0.6875}, noise=0.012, seed="rlvr1-57t-p")
+    s38 = model("57t-38", "Snowball-67B-A2B-5.7T-Mixed-RLVR-Step38", hf_repo="open-athena/Snowball-67B-A2B-5.7T-Mixed-RLVR-Step38",
+                arch=GRUG, params_total=67.0, params_active=2.0, parent_id=M["s3"], run_key="rlvr1-57t", step=38, stage="RL",
+                created_at=at("2026-09-22 00:00"), status="released", source=RLVR_57T, notes="RLVR1 from the Stage-3 SFT; exported at holdout pass@1 0.54.")
+    res57 = mixed_run(
+        "rlvr1-57t", "rlvr1-5.7t-agentic-adam4e6", M["s3"], 1, 46, at("2026-09-19 06:00"), 2937.0, r57, p57, "stopped",
+        "Reached step 46 when the campaign was sealed.",
+        "RLVR1 from the older 5.7T agentic Stage-3 SFT (v124, adam4e6-agentic57t). Published: step 46 training reward 0.6791 and "
+        "pass@16 0.6875 with holdout avg_score / pass@1 0.5606 / 0.5000, and the step-38 export at holdout pass@1 0.54. Other "
+        "steps simulated; step time assumed equal to the control's.",
+        rlvr_cfg("RLVR1 from the 5.7T Stage-3 SFT (v124)", "4e-6"), dict(rl_hp, lr=4e-6, lr_source="job name adam4e6-agentic57t (v124)"),
+        [{"step": 38, "model_id": s38, "title": "Checkpoint step 38 (released)"}],
+        extra_series={"eval/all/pass_at_1": [(38, 0.54), (46, 0.5)], "eval/all/avg_score": [(46, 0.5606)]}, source=RLVR_57T)
+    # v104: the cancelled AdamW 8e-6 arm, with its real rollouts, holdout samples and transcripts
+    v_ser = real_series("marin-snowball-v104-rlvr1-traces")
+    rv = anchor_curve(15, {1: 0.374, 6: 0.526, 15: 0.279}, noise=0.015, seed="v104")
+    pv = anchor_curve(15, {1: 0.508, 15: 0.322}, noise=0.015, seed="v104-p")
+    v_ser["policy/policy_lr"] = [(s, 8e-6) for s in range(1, 16)]
+    resv = mixed_run(
+        "v104", "rlvr1-v104-adam8e6", M["dk0911"], 1, 15, at("2026-09-16 10:00"), 2937.0, rv, pv, "stopped",
+        "Cancelled after 15 updates: holdout avg_score 0.390 → 0.278 and pass@1 0.33 → 0.18 by step 14, with many degenerate "
+        "late responses; 11,976 objects (6.0 TiB) of checkpoints deleted after cancellation, a 471 MiB bundle preserved.",
+        "RLVR1 arm v104 at AdamW 8e-6 with RLOO-N from the Datakit SFT 09.11, cancelled after 15 updates. The local importer "
+        "labels it 'GRPO, AdamW lr 4e-6 (resolved config)'; the W&B history logs policy_lr 8e-6 at every step, the launcher is "
+        "submit_v104_adam8e6_direct_s3.py, and the resolved args end with lr=8.0e-6 and advantage_estimator=rloo_n (the last "
+        "override wins), so this run is stored as RLOO-N at 8e-6. Published: training reward 0.374 → 0.526 → 0.279 at steps 1 / "
+        "6 / 15, pass@16 0.508 → 0.322, the learning rate and the holdout at steps 0–14 (8 points). The stored rollouts are "
+        "real: 36 random complete 16-rollout groups from each of steps 1 and 15 of the retained trace archive, and all 800 "
+        "holdout samples, with trimmed transcripts (jailbreak-domain texts withheld). The retained archive keeps only prompts "
+        "whose 16 rollouts all survived (315 of 512 at step 1, 487 at step 15), and the stored groups' mean reward (0.024 at "
+        "step 1, 0.252 at step 15) differs from the logged step means, so the stored sample is not representative of its step. "
+        "Training values between the published steps are simulated.",
+        rlvr_cfg("RLVR1 v104 (submit_v104_adam8e6_direct_s3.py)", "8e-6",
+                 ["# resolved-skyrl.json lists lr=4e-06 then lr=8.0e-6, and advantage_estimator grpo then rloo_n (last override wins)",
+                  "max_steps: 128"]),
+        dict(rl_hp, lr=8e-6, lr_evidence="W&B policy_lr 8e-6 at every step; launcher submit_v104_adam8e6_direct_s3.py"),
+        [], events=[{"step": 15, "kind": "notice", "severity": "warning", "title": "Cancelled: holdout degrading",
+                     "body": "Holdout avg_score fell from 0.390 (step 0) to 0.278 (step 14); pass@1 0.33 → 0.18. Checkpoints (6.0 "
+                             "TiB) deleted after cancellation."}],
+        extra_series=v_ser, source=V104, write_rollouts=False, prov="mixed", tags=["real-rollouts"])
+    run_v = resv["run_id"]
+    # real training rollouts (steps 1 and 15)
+    groups = {}
+    for a_ in att:
+        if a_["kind"] == "train":
+            groups.setdefault((a_["version"] + 1, a_["group"]), []).append(a_)
+    rows, trs = [], []
+    keep_groups = {st_: set(sorted(g_ for (s_, g_) in groups if s_ == st_)[::3]) for st_ in (1, 15)}
+    for (step, g), items in sorted(groups.items()):
+        items.sort(key=lambda z: z["index"])
+        advs = advantages([z["reward"] for z in items], "rloo")
+        for z, adv in zip(items, advs):
+            outc, stop = v104_outcome(z)
+            env = RENV[z["domain"]][0]
+            rid_ = rid("roll", run_v, z["id"])
+            rows.append({"id": rid_, "run_id": run_v, "eval_id": None, "step": step, "phase": "train",
+                         "group_id": rid("grp", run_v, step, g), "sample": z["index"], "task_id": task_id[tname(z)],
+                         "env_id": env.id, "harness": "skyrl_gym (single turn)", "model_id": M["dk0911"], "reward": z["reward"],
+                         "advantage": adv, "scores": None, "outcome": outc, "stop_reason": stop, "turns": z["turns"],
+                         "tool_calls": z["tool_calls"], "tokens_in": z["tokens_in"], "tokens_out": z["tokens_out"],
+                         "tokens_cached": None, "duration_s": None, "timing": None, "staleness": 0,
+                         "flags": {"exception": z["exception"]} if z.get("exception") else None,
+                         "seed": stable_seed(z["id"]), "trained": 1})
+            if z["domain"].startswith("jailbreak"):
+                msgs = [{"role": "note", "content": "Transcripts of jailbreak-domain rollouts are not reproduced."}]
+            elif g in keep_groups[step]:
+                msgs = transcripts.get(z["id"]) or [{"role": "note", "content": "No transcript in the retained archive."}]
+            else:
+                msgs = [{"role": "note", "content": "This is a real rollout; its transcript is in the published v104 trace archive "
+                                                    "(step-1.zip / step-15.zip). The demo stores transcripts for 12 of the 36 "
+                                                    "sampled groups per step to stay within its size budget."}]
+            trs.append({"rollout_id": rid_, "messages": msgs})
+    w.add_many("rollouts", rows)
+    for step in (1, 15):
+        w.conn.execute("UPDATE run_steps SET rollouts_stored=? WHERE run_id=? AND step=?",
+                       (sum(1 for r_ in rows if r_["step"] == step), run_v, step))
+    # holdout benchmarks: v104's evals carry the real per-sample results
+    for bk, nm, met in (("h-pass1", "RLVR1 holdout (100 rows) · pass@1", "pass@1"), ("h-avg", "RLVR1 holdout (100 rows) · avg_score", "avg score")):
+        E.bench(bk, nm, "RL holdout (#9359)", met, 100, 1,
+                "In-run holdout of the RLVR1 blend: the last 100 selected rows, one sample each. pass@1 counts samples with a "
+                "nonzero score; avg_score is the mean score (partial credit included). The async lineage later used an amended "
+                "89-row holdout (11 LiveCodeBench rows removed). v104's evals store the real per-sample results.", V104,
+                harness="SkyRL in-run eval", per_task=False)
+    ev_samples = {}
+    for a_ in att:
+        if a_["kind"] == "eval":
+            ev_samples.setdefault(a_["version"], []).append(a_)
+    vp = dict(v_ser["eval/all/pass_at_1"])
+    va = dict(v_ser["eval/all/avg_score"])
+    for ver, items in sorted(ev_samples.items()):
+        items.sort(key=lambda z: z["index"] if z["index"] is not None else 0)
+        tstart = (resv["times"][ver][1] if ver in resv["times"] else resv["start"] - 1800) + 600
+        for bk, val in (("h-pass1", vp[ver]), ("h-avg", va[ver])):
+            eid = E.ev(bk, M["dk0911"] if ver == 0 else None, val, started=tstart, source=V104_WANDB, ek=f"v104|{ver}",
+                       run_id=run_v, step=ver, provenance="published")
+            w.add_many("eval_tasks", [{"eval_id": eid, "task_id": task_id[tname(z)], "task_name": tname(z), "attempts": 1,
+                                       "passes": 1 if (z["reward"] or 0) > 0 else 0, "infra": 1 if z.get("exception") else 0,
+                                       "score": round(z["reward"] or 0.0, 4), "mean_turns": z["turns"], "mean_tokens": None}
+                                      for z in items])
+            if bk == "h-pass1":
+                for z in items:
+                    outc, stop = v104_outcome(z)
+                    rid_ = rid("roll", eid, z["id"])
+                    rows_e = {"id": rid_, "run_id": run_v, "eval_id": eid, "step": ver, "phase": "eval",
+                              "group_id": rid("grp", eid, tname(z)), "sample": 0, "task_id": task_id[tname(z)],
+                              "env_id": RENV[z["domain"]][0].id, "harness": "skyrl_gym (single turn)", "model_id": M["dk0911"],
+                              "reward": z["reward"], "advantage": None, "scores": None, "outcome": outc, "stop_reason": stop,
+                              "turns": z["turns"], "tool_calls": z["tool_calls"], "tokens_in": None, "tokens_out": None,
+                              "tokens_cached": None, "duration_s": None, "timing": None, "staleness": 0,
+                              "flags": {"exception": z["exception"]} if z.get("exception") else None,
+                              "seed": stable_seed(z["id"]), "trained": 0}
+                    w.add("rollouts", rows_e)
+                    trs.append({"rollout_id": rid_, "messages": transcripts.get(z["id"]) or
+                                [{"role": "note", "content": "Transcripts of jailbreak-domain samples are not reproduced."}]})
+    w.add_many("transcripts", trs)
+    for bk, mid, v, run_, step, src, ek, n_ in (
+            ("h-pass1", s116, 0.44, res2["run_id"], 116, RLVR2_SYNC, "sync116", 100),
+            ("h-avg", s116, 0.5275, res2["run_id"], 116, RLVR2_SYNC, "sync116", 100),
+            ("h-pass1", a146, 0.37, resa2["run_id"], 146, RLVR2_ASYNC, "async146", 89),
+            ("h-avg", a146, 0.4625, resa2["run_id"], 146, RLVR2_ASYNC, "async146", 89),
+            ("h-pass1", s38, 0.54, res57["run_id"], 38, RLVR_57T, "57t|38", 100),
+            ("h-pass1", None, 0.5, res57["run_id"], 46, RLVR_57T, "57t|46", 100),
+            ("h-avg", None, 0.5606, res57["run_id"], 46, RLVR_57T, "57t|46", 100),
+            ("h-pass1", M["glm53-rl48"], 0.53535, None, None, GLM53_RL, "glm53|48", 100),
+            ("h-avg", M["glm53-rl48"], 0.58757, None, None, GLM53_RL, "glm53|48", 100)):
+        r_t = w.conn.execute("SELECT ended_at FROM run_steps WHERE run_id=? AND step=?", (run_, step)).fetchone() if run_ else None
+        E.ev(bk, mid, v, started=(r_t[0] + 900) if r_t else at("2026-09-25 00:00"), source=src, ek=ek, run_id=run_, step=step,
+             provenance="published", n_tasks=n_,
+             config={"holdout_rows": n_, "note": "0.53535 equals 53/99 (my arithmetic)"} if ek.startswith("glm53") and bk == "h-pass1"
+             else {"holdout_rows": n_})
+
+    # SWE RL on R2E-Gym (#9225) ----------------------------------------------------------------------------------
+    r2e_hp = {"advantage": "GRPO with RLOO-n groups of 8", "loss": "sequence-mean", "tis_cap": 2, "kl": 0.0, "lr": 5e-7,
+              "max_staleness": 2, "prompts_per_step": 64, "group_size": 8, "window": "64k: 49k input / 16k output",
+              "draft": "EAGLE-3 speculative decoding", "agent": "terminus-2, summarization off",
+              "placement": "20 nodes: 8 policy (FSDP2) + 12 engine (GH200, JSC)"}
+    r2e_cfg = "\n".join(["# #9225 R2E-Gym RL (MarinSkyRL branch lukedhlee/snowball-r2egym)", "advantage: GRPO with RLOO-n groups of 8",
+                         "loss_reduction: sequence_mean", "tis_cap: 2", "use_kl_loss: false", "lr: 5e-7", "max_staleness: 2",
+                         "train_batch_size: 64", "n_samples_per_prompt: 8", "window: 65536   # 49k input / 16k output",
+                         "draft: EAGLE-3", "agent: terminus-2 (summarization off)", "placement: 20 GH200 nodes: 8 policy (FSDP2) + 12 engine"])
+    rr = anchor_curve(48, {1: 0.30, 24: 0.36, 48: 0.37}, noise=0.03, seed="r2e-base")
+    u24 = model("S4", "snowball-67b-a2b-rl-r2egym-newstack-step24", hf_repo="laion/snowball-67b-a2b-rl-r2egym-newstack-step24",
+                arch=GRUG, params_total=67.0, params_active=2.0, context_len=32768, parent_id=M["s3"], run_key="r2e-base", step=24,
+                stage="RL", created_at=None, status="released", source=I9225,
+                notes="GRPO on R2E-Gym from the Stage-3 SFT, update 24; lineage candidate S4 in #9412.")
+    u48 = model("r2e-48", "snowball-67b-a2b-rl-r2egym-newstack-step48", hf_repo="laion/snowball-67b-a2b-rl-r2egym-newstack-step48",
+                arch=GRUG, params_total=67.0, params_active=2.0, parent_id=M["s3"], run_key="r2e-base", step=48, stage="RL",
+                created_at=None, status="released", source=I9225, notes="Update 48 of the same run.")
+    resr = simulate_run(
+        w, pid=pid, key="r2e-base", name="r2e-gym-rl-from-stage3", envs=[(env_r2e, 1.0)], base_model_id=M["s3"], reward=rr,
+        start=at("2026-09-15 06:00"), times=step_times(48, 480.0, "r2e-base", sigma=0.1), group_size=8, prompts=64,
+        sample_groups=48, store_groups=2, adv="rloo",
+        sim_tags={"reward": "reward/avg_raw_reward", "pass_at_k": "reward/avg_pass_at_8", "resp_len": "generate/avg_num_tokens",
+                  "step_time": "timing/step"}, harness="terminus-2", staleness=[0, 1, 2],
+        checkpoints=[{"step": 24, "model_id": u24, "title": "Update 24 (released)"}, {"step": 48, "model_id": u48, "title": "Update 48 (released)"}],
+        run={"algorithm": "GRPO (RLOO-n groups)", "framework": "MarinSkyRL (FSDP2), branch lukedhlee/snowball-r2egym",
+             "primary_metric": "reward/avg_raw_reward", "gpu": "GH200", "gpus": None, "tags": ["swe-rl"], "config": r2e_cfg,
+             "hyperparams": dict(r2e_hp, task_band="1,003-task learnable band", sandboxes=1056, updates=48),
+             "group_name": "r2e-gym-swe-rl (#9225)",
+             "description": "GRPO with RLOO-n groups of 8 on R2E-Gym from the Stage-3 SFT: 64 × 8 per step on a 1,003-task learnable "
+                            "band, lr 5e-7, 20 GH200 nodes (8 policy + 12 engine) and 1,056 apptainer sandboxes on JUWELS. "
+                            "Published: SWE-bench Verified random-100 12/100 → 23/100 at update 24 (15 tasks gained, 4 lost) → "
+                            "25/100 at update 48, and TB2 within noise. No training curve is published: rewards, rollouts, dates "
+                            "and step times (8 min assumed, the SFT-then-RL arms' published 7–9 min) are simulated.",
+             "source": I9225_RL, "provenance": "simulated",
+             "start_body": "GRPO on the 1,003-task R2E-Gym band: 64 prompts × 8 attempts per step."})
+    for mid, s in ((u24, 24), (u48, 48)):
+        w.conn.execute("UPDATE models SET created_at=? WHERE id=?", (resr["times"][s][1], mid))
+    add_jobs(w, pid, resr["run_id"], "r2e-gym-rl-from-stage3", "completed", resr["start"], resr["end"],
+             [{"name": "policy (8 GH200 nodes, FSDP2)", "cluster": C["jupiter"], "gpu": "GH200", "nodes": 8},
+              {"name": "engines (12 GH200 nodes)", "kind": "rollout", "cluster": C["jupiter"], "gpu": "GH200", "nodes": 12},
+              {"name": "sandboxes (1,056 apptainer)", "kind": "sandbox", "cluster": C["juwels"]}])
+    sftrl = {}
+    for key, src_m, swe_v, tb2_v, t_start in (("d1", d1, 0.307, 0.050, at("2026-09-21 06:00")),
+                                              ("d2", arms["D"][1], 0.267, 0.068, at("2026-09-21 12:00"))):
+        rw = anchor_curve(30, {1: 0.40, 30: 0.52}, noise=0.02, seed=f"sftrl-{key}")
+        rng_ = random.Random(stable_seed("mixed-share", key))
+        exact = {s: {"groups_mixed": int(round(64 * rng_.uniform(0.62, 0.88)))} for s in range(1, 31)}
+        for s in exact:
+            m_ = exact[s]["groups_mixed"]
+            f_ = int(round((64 - m_) * 0.6))
+            exact[s].update(groups_all_fail=f_, groups_all_pass=64 - m_ - f_)
+        outm = model(f"sftrl-{key}", f"Stage-3 SFT arm D epoch {key[1]} + 30 GRPO steps", arch=GRUG, params_total=67.0,
+                     params_active=2.0, parent_id=src_m, run_key=f"sftrl-{key}", step=30, stage="RL", created_at=None,
+                     status="not released", source=I9225_SFTRL,
+                     notes=f"SFT-then-RL arm: SWE-bench Verified random-100 {swe_v:.3f}" + (" [0.26, 0.36], the best number in #9225" if key == "d1" else "")
+                           + f"; TB2 {tb2_v:.3f}.")
+        res = simulate_run(
+            w, pid=pid, key=f"sftrl-{key}", name=f"r2e-gym-rl-after-sft-D-epoch{key[1]}", envs=[(env_r2e, 1.0)], base_model_id=src_m,
+            reward=rw, start=t_start, times=step_times(30, 480.0, f"sftrl-{key}", sigma=0.1), group_size=8, prompts=64,
+            sample_groups=48, store_groups=2, adv="rloo", exact=exact,
+            sim_tags={"reward": "reward/avg_raw_reward", "pass_at_k": "reward/avg_pass_at_8", "resp_len": "generate/avg_num_tokens",
+                      "step_time": "timing/step"}, harness="terminus-2", staleness=[0, 1, 2],
+            checkpoints=[{"step": 30, "model_id": outm}],
+            run={"algorithm": "GRPO (RLOO-n groups)", "framework": "MarinSkyRL a03b2773 / harbor dcf609bc",
+                 "primary_metric": "reward/avg_raw_reward", "gpu": "GH200", "gpus": None, "tags": ["swe-rl", "sft-then-rl"],
+                 "config": r2e_cfg + "\nwarmup_steps: 3\ntask_band: 939 tasks screened from D epoch 1 (2 passes)\nsandboxes: 768",
+                 "hyperparams": dict(r2e_hp, task_band="939 tasks screened from D epoch 1 (2 passes)", sandboxes=768,
+                                     warmup_steps=3, steps=30), "group_name": "r2e-gym-swe-rl (#9225)",
+                 "description": f"SFT then RL: arm D epoch {key[1]} + 30 GRPO steps on a 939-task R2E-Gym band (3 warmup steps, 768 "
+                                f"sandboxes, 7–9 min per step). Published: reward 0.40 → 0.52 over 30 steps with 62–88% of groups "
+                                f"mixed, SWE-bench Verified random-100 {swe_v:.3f}"
+                                + (" [0.26, 0.36] ('the best number in this thread')" if key == "d1" else "")
+                                + f", TB2 {tb2_v:.3f}; cost 78 GPU node-hours plus 72 CPU node-hours on JUWELS per arm. Per-step "
+                                  f"values between the published endpoints, rollouts and dates are simulated.",
+                 "source": I9225_SFTRL, "provenance": "simulated",
+                 "start_body": "GRPO on the 939-task band: 64 prompts × 8 attempts per step, 3 warmup steps."})
+        w.conn.execute("UPDATE models SET created_at=? WHERE id=?", (res["end"], outm))
+        add_jobs(w, pid, res["run_id"], f"r2e-gym-rl-after-sft-D-epoch{key[1]}", "completed", t_start, res["end"],
+                 [{"name": "policy + engines (GH200)", "cluster": C["jupiter"], "gpu": "GH200", "nodes": 20,
+                   "log": "78 GPU node-hours per arm (published)."},
+                  {"name": "sandboxes (768 apptainer)", "kind": "sandbox", "cluster": C["juwels"],
+                   "log": "72 CPU node-hours per arm (published)."}])
+        sftrl[key] = (res, outm, swe_v, tb2_v)
+
+    # Open-MOPD on-policy distillation replication ------------------------------------------------------------------
+    model("smol-mixsft", "Open-MOPD-SmolLM3-3B-MixSFT (student start)", "base", hf_repo="BytedTsinghua-SIA/Open-MOPD-SmolLM3-3B-MixSFT",
+          arch="Dense (SmolLM3)", params_total=3.0, params_active=3.0, created_at=at("2026-09-12 00:00"), status="external", source=MOPD,
+          notes="Student start of the Open-MOPD recipe.")
+    mopd_run = rid("run", pid, "open-mopd")
+    t_m = at("2026-09-16 12:00")
+    rng_m = random.Random(stable_seed("mopd"))
+    mtimes = step_times(34, 900.0, "mopd", sigma=0.15)
+    steps_rows, mets, tt = [], [], t_m
+    for s in range(1, 35):
+        d = mtimes[s - 1]
+        steps_rows.append({"run_id": mopd_run, "step": s, "phase": "train", "started_at": tt, "ended_at": tt + d, "prompts": None,
+                           "rollouts": None, "rollouts_stored": 0, "reward_mean": None, "pass_rate": None, "tokens": None,
+                           "groups_all_pass": None, "groups_all_fail": None, "groups_mixed": None, "infra_errors": None,
+                           "truncated": None})
+        x = (s - 1) / 33
+        mets += [{"run_id": mopd_run, "tag": "distill/reverse_kl", "step": s,
+                  "value": round((0.62 - 0.38 * (1 - math.exp(-3 * x)) / (1 - math.exp(-3))) * math.exp(rng_m.gauss(0, 0.04)), 5)},
+                 {"run_id": mopd_run, "tag": "timing/step", "step": s, "value": round(d, 2)}]
+        tt += d
+    mopd_out = model("mopd-32", "MarinSkyRL-Open-MOPD-SmolLM3-3B-step-32", hf_repo="open-athena/MarinSkyRL-Open-MOPD-SmolLM3-3B-step-32",
+                     arch="Dense (SmolLM3)", params_total=3.0, params_active=3.0, parent_id=M["smol-mixsft"], run_key="open-mopd",
+                     step=32, stage="Distillation", created_at=at("2026-09-18 00:00"), status="released", source=MOPD,
+                     notes="MarinSkyRL-native on-policy distillation with domain-routed math / code / instruction-following teachers: "
+                           "AIME 2024 mean@64 22.03%, AIME 2025 mean@64 23.33%, IFEval 74.49%.")
+    w.add("runs", {"id": mopd_run, "project_id": pid, "name": "open-mopd-smollm3-3b", "kind": "distill", "stage": "Distillation",
+                   "algorithm": "OPD (student top-16 token IDs, clipped policy surrogate)", "framework": "MarinSkyRL @ 12e6da9e",
+                   "status": "stopped", "status_reason": "Reached a durable step 34 and was stopped; step 32 exported.",
+                   "base_model_id": M["smol-mixsft"], "output_model_id": mopd_out, "started_at": t_m, "ended_at": tt, "updated_at": tt,
+                   "steps_planned": 34, "steps_done": 34, "primary_metric": "distill/reverse_kl", "gpu": None, "gpus": None,
+                   "cost_usd": None, "cost_rate": None, "owner": "Marin", "tags": ["distillation", "replication"], "code_ref": "MarinSkyRL@12e6da9e",
+                   "config": "# Open-MOPD replication (model card)\nstudent: BytedTsinghua-SIA/Open-MOPD-SmolLM3-3B-MixSFT\n"
+                             "teachers: domain-routed math / code / instruction-following (not named)\ndata: BytedTsinghua-SIA/Open-MOPD-Data\n"
+                             "objective: student top-16 token IDs, clipped policy surrogate\n# batch, lr and hardware not published",
+                   "config_format": "yaml", "hyperparams": {"note": "batch, lr and hardware not published"}, "parent_run_id": None,
+                   "group_name": None,
+                   "description": "Replication of the Open-MOPD recipe as MarinSkyRL-native on-policy distillation of SmolLM3 3B with "
+                                  "domain-routed teachers. Published: the step-32 scores (AIME 2024 mean@64 22.03%, AIME 2025 "
+                                  "mean@64 23.33%, IFEval 74.49%) and that the run reached a durable step 34. The KL curve, dates "
+                                  "and step times are simulated; no per-step log is public.",
+                   "source": MOPD, "provenance": "simulated"})
+    w.add("run_inputs", {"run_id": mopd_run, "kind": "dataset", "ref_id": ds_mopd, "weight": 1.0})
+    w.add_many("run_steps", steps_rows)
+    w.add_many("metrics", mets)
+    w.add_many("run_events", [{"run_id": mopd_run, "t": t_m, "step": 0, "kind": "start", "severity": "info", "title": "Run started",
+                               "body": "On-policy distillation of SmolLM3 3B with domain-routed teachers."},
+                              {"run_id": mopd_run, "t": tt, "step": 34, "kind": "end", "severity": "info", "title": "Run stopped",
+                               "body": "Reached a durable step 34; step 32 exported."}])
+    w.add("checkpoints", {"id": rid("ckpt", mopd_run, 32), "run_id": mopd_run, "step": 32, "model_id": mopd_out,
+                          "path": "open-mopd/global_step_32", "size_gb": None, "created_at": steps_rows[31]["ended_at"], "kept": 1})
+    add_jobs(w, pid, mopd_run, "open-mopd-smollm3-3b", "stopped", t_m, tt, [{"name": "trainer", "cluster": None}])
+    for bk, nm, n_, k_, v in (("mopd-aime24", "AIME 2024 (mean@64)", 30, 64, 22.03), ("mopd-aime25", "AIME 2025 (mean@64)", 30, 64, 23.33),
+                              ("mopd-ifeval", "IFEval (mean@1)", 541, 1, 74.49)):
+        E.bench(bk, nm, "Distillation (Open-MOPD)", "mean@64" if k_ == 64 else "accuracy", n_, k_,
+                f"Independent evaluation on the Open-MOPD model card: {nm}. {'30 problems × 64 samples.' if k_ == 64 else '541 prompts.'}",
+                MOPD, per_task=k_ == 64)
+        E.ev(bk, mopd_out, pc(v), started=at("2026-09-18 00:00"), source=MOPD, ek="step32", run_id=mopd_run, step=32)
+
+    # #9225 SWE-bench random-100 and TB2 in the Eval Policy v0.1 setting -----------------------------------------------
+    E.bench("v01-swe", "SWE-bench Verified random-100 (#9225, policy v0.1)", "Agentic (#9225)", "pooled pass@1", 100, 3,
+            "Harbor 7b18505a, terminus-2 with summarization on, 32,768 / 8,192 tokens, temperature 1.0, Daytona; pooled pass@1 over "
+            "3 trials unless an eval says 1 trial. 95% CIs are published for arm D (0.241 [0.20, 0.29]) and D + RL (0.307 [0.26, "
+            "0.36]); their standard errors here are CI width / 3.92. Only scores are stored.", I9225, per_task=False,
+            harness="Harbor / Terminus-2")
+    E.bench("v01-tb2", "Terminal-Bench 2 (#9225, policy v0.1)", "Agentic (#9225)", "pooled pass@1", 89, 3,
+            "Harbor 7b18505a, terminus-2; pooled pass@1 over scored tasks. Where a denominator is published (4/87, 9/87, 6/85), the "
+            "unscored tasks are stored as infrastructure exclusions (my reading of the denominators).", I9225, per_task=False,
+            harness="Harbor / Terminus-2")
+    t9 = at("2026-09-20 00:00")
+    for ek, mid, run_, step, swe_v, tb2_v, k_, se, src in (
+            ("s3-3", M["s3"], None, None, 0.145, 0.094, 3, None, I9225_SFT),
+            ("s3-1", M["s3"], None, None, 0.12, None, 1, None, I9225_RL),
+            ("armA", arms["A"][1], arms["A"][0]["run_id"], 495, 0.221, 0.051, 3, None, I9225_SFT),
+            ("armC", arms["C"][1], arms["C"][0]["run_id"], 626, 0.213, 0.035, 3, None, I9225_SFT),
+            ("armD1", d1, arms["D"][0]["run_id"], 517, 0.241, 0.061, 3, round(0.09 / 3.92, 4), I9225_STACK),
+            ("armB", arms["B"][1], arms["B"][0]["run_id"], 159, 0.030, 0.004, 3, None, I9225_SFT),
+            ("armD2", arms["D"][1], arms["D"][0]["run_id"], 1034, 0.237, 0.077, 3, None, I9225_SFT2),
+            ("sftrl-d1", sftrl["d1"][1], sftrl["d1"][0]["run_id"], 30, 0.307, 0.050, 3, round(0.10 / 3.92, 4), I9225_SFTRL),
+            ("sftrl-d2", sftrl["d2"][1], sftrl["d2"][0]["run_id"], 30, 0.267, 0.068, 3, None, I9225_SFTRL),
+            ("r2e-24", u24, resr["run_id"], 24, 0.23, 4 / 87, 1, None, I9225_RL),
+            ("r2e-48", u48, resr["run_id"], 48, 0.25, 9 / 87, 1, None, I9225),
+            ("dk0921", M["dk0921"], None, None, 0.21, 6 / 85, 1, None, I9225_DK)):
+        E.ev("v01-swe", mid, swe_v, started=t9, source=src, ek=ek, run_id=run_, step=step, stderr=se, k=k_, provenance="published",
+             config={"trials": k_})
+        if tb2_v is not None:
+            n_inf = {"r2e-24": 2 * k_, "r2e-48": 2 * k_, "dk0921": 4 * k_}.get(ek)
+            E.ev("v01-tb2", mid, tb2_v, started=t9 + 600, source=src, ek=ek, run_id=run_, step=step, k=k_, n_infra=n_inf,
+                 provenance="published", config={"trials": k_})
+    E.ev("v01-swe", M["s3"], 0.12, started=t9 - 3 * H, source=I9225_RL, ek="r2e-0", run_id=resr["run_id"], step=0, k=1,
+         provenance="published", config={"trials": 1, "note": "base at 16 concurrent, 1 trial (12/100)"})
+
+    # eval policy panel (#9409, #9412) ------------------------------------------------------------------------------------
+    panel_rec = {b_["name"].split(": ", 1)[1]: b_ for b_ in recipe["benchmarks"][:26]}
+    who = {label: (M[key] if key in M else None) for label, key in PANEL_MODELS}
+    who["open-athena/Grug-67B-A2B-Datakit-SFT-262K-2026.09.17"] = dkm
+    who["open-athena/Snowball-67B-A2B-10T-Mixed-RLVR-Sync-Step92"] = step92
+    who["laion/snowball-67b-a2b-rl-r2egym-newstack-step24"] = u24
+    who["open-athena/Snowball-67B-A2B-Math-RL-E6-Step20-Repaired"] = math_runs["e6"][1]
+    lineage_run = {"open-athena/Grug-67B-A2B-Datakit-SFT-262K-2026.09.17": (dk["run_id"], 1000),
+                   "open-athena/Snowball-67B-A2B-10T-Mixed-RLVR-Sync-Step92": (res1["run_id"], 92),
+                   "laion/snowball-67b-a2b-rl-r2egym-newstack-step24": (resr["run_id"], 24),
+                   "open-athena/Snowball-67B-A2B-Math-RL-E6-Step20-Repaired": (math_runs["e6"][0]["run_id"], 20)}
+    tp = at("2026-09-23 00:00")
+    for bi, (tk, name, cat_, met, n_, k_, per_task, harness, extra_d, n_pub) in enumerate(PANEL):
+        E.bench(f"p|{tk}", f"{name} (eval policy)", f"Eval policy 2026-09-24: {cat_}", met, n_, k_,
+                f"Marin eval policy 2026-09-24 (#9409), in-distribution suite, tracker key {tk}. {extra_d} "
+                + ("" if n_pub else f"The task count is not published; {n_:,} is the benchmark's standard size (assumed). ")
+                + "Pins: Harbor 761fb516, Evalchemy abe6bb28, Marin experiment branch 19613710. Scores for 10 baselines and 5 "
+                  "Snowball lineage checkpoints from TRACKER.md (each cell links an S3 result path); per-eval infrastructure "
+                  "counts are not published. Release selection used this same panel (in-sample)."
+                + ("" if per_task else " Only scores are stored (no per-task results)."), TRACKER, harness=harness,
+                per_task=per_task)
+        for si, sc in enumerate(panel_rec[tk]["scores"]):
+            mid = who.get(sc["model"])
+            run_, step = lineage_run.get(sc["model"], (None, None))
+            E.ev(f"p|{tk}", mid, pc(sc["score"]), started=tp + bi * 900 + si * 30, source=TRACKER, ek=f"{si}", run_id=run_,
+                 step=step, config={"tracker_model": sc["model"], "stage": sc["stage"]})
+
+    # metric definitions -------------------------------------------------------------------------------------------------
+    kit.metric_defs(w, pid, "trl_sft")
+    add_defs(w, pid, [
+        ("train/pass_at_1", sig.SIGNALS["pass_rate"][0], "Training-batch pass@1 (math RL: derived from the ±1 raw reward or "
+         "environment/acc). E17a reached 0.717 by step 10 without improving AIME24.", "pct", "learning", "up", "pass_rate"),
+        ("train/pass_at_16", "Pass@16", "Share of the step's prompts with at least one correct sample out of 16.", "pct",
+         "learning", "up", None),
+        ("heldout/aime24", "AIME24 (held-out)", "Held-out AIME24, 10-rep accuracy_avg (percent).", "num1", "eval", "up", None),
+        ("heldout/aime24_se", "AIME24 SE", "Standard error of the held-out AIME24 score.", "num2", "eval", "none", None),
+        ("heldout/math500", "MATH-500 (held-out)", "Held-out MATH-500, single pass (percent).", "num1", "eval", "up", None),
+        ("heldout/math500_se", "MATH-500 SE", "Standard error of the held-out MATH-500 score.", "num2", "eval", "none", None),
+        ("heldout/olympiadbench", "OlympiadBench (held-out)", "Held-out OlympiadBench 30-question subset, 10 reps (percent).",
+         "num1", "eval", "up", None),
+        ("heldout/olympiadbench_se", "OlympiadBench SE", "Standard error of the held-out OlympiadBench score.", "num2", "eval",
+         "none", None),
+        ("eval/all/pass_at_1", "Holdout pass@1", "In-run holdout (100 rows; the async lineage later 89): share of samples with "
+         "a nonzero score. The primary ranking signal; v104 fell from 0.33 to 0.18 over 14 steps while training reward first rose.",
+         "pct", "eval", "up", None),
+        ("eval/all/avg_score", "Holdout mean score", "In-run holdout mean score, partial credit included.", "num3", "eval", "up", None),
+        ("distill/reverse_kl", sig.SIGNALS["distill_kl"][0], "Reverse KL between the student and the teachers on the student's "
+         "samples (simulated; no per-step log is public).", "num3", "learning", "down", "distill_kl"),
+    ] + skyrl_defs(pid) + [
+        (f"by_env/RLVR1: {a_}/pass_rate", f"Pass rate · {a_}", f"Mean reward of this step's sampled attempts on {a_} (simulated).",
+         "pct", "by_env", "up", f"env_pass_rate@{RENV[a_][0].id}") for a_, *_ in RLVR1_DOMAINS])
+    w.conn.execute("UPDATE metric_defs SET description=? WHERE project_id=? AND tag='reward/avg_raw_reward'",
+                   ("Mean raw verifier reward per step. Math RL (#7786): the ±1 boxed-answer reward (pass@1 = (reward + 1) / 2 "
+                    "for unregularized GRPO). Mixed RLVR (#9359): mean of the domain verifiers' rewards, which can be partial, "
+                    "so it can exceed pass@16. Marin's rule: training reward is not a proxy for held-out performance (claim VI "
+                    "rejected).", pid))
+
+    # tasks: pass rates only where a published number anchors them
+    for key, env in ENV.items():
+        store_tasks(w, env)
+    for agent, (env, rows_, off) in RENV.items():
+        store_tasks(w, env)
+    store_tasks(w, env_r2e, base=0.133, latest=None, attempts=8)
+
+    # reports ------------------------------------------------------------------------------------------------------------
+    kit.report(
+        w, pid, "math", "Non-agentic RL on Snowball: math RLVR (#7786)", "Marin (report 2026.08.27.1, #7786)", at("2026-08-27 00:00"),
+        "Twenty-five models with saved checkpoints and reported results, experiments 07-30 to 08-27-2026, non-agentic RLVR only. "
+        "The corrected catalog (2026-09-20) has 17 artifacts plus one documented gap (E17d step 20); here they are 17 runs, E17d "
+        "carrying both its step-8 repaired control and its step-20 loss-free checkpoint. The published text has no claim III.",
+        [{"claim": "I: Well-designed RL can improve Marin MoEs ('RL-ready').", "verdict": "upheld",
+          "evidence": "E6 improved AIME24 17.67 → 27, MATH-500 64.00 → 78, OlympiadBench 12.67 → 20 (its public curve: 27.33 / 78.4 "
+                      "/ 19.67 at step 15; 26.00 / 76.80 / 22.67 at the headline step 20)."},
+         {"claim": "II: Non-agentic RL is highly sensitive to objective and task distribution.", "verdict": "upheld",
+          "evidence": "'No dataset won across recipes'."},
+         {"claim": "IV: Non-agentic RL is highly sensitive to hyperparameters.", "verdict": "open",
+          "evidence": "Marin's verdict: partially upheld. LR changed stability and collapse, not the held-out frontier."},
+         {"claim": "V: Muon-H is more effective in post-training.", "verdict": "rejected",
+          "evidence": "AdamW learned faster at its viable LR; no consistent held-out Muon-H advantage."},
+         {"claim": "VI: Training reward is a reliable proxy for eval performance.", "verdict": "rejected",
+          "evidence": "The E6 reproduction had higher training reward but scored 19.67 / 73.60 / 20.00 vs the original's 26.00 / "
+                      "76.80 / 22.67."},
+         {"claim": "Checkpoints trained with a mutable router bias can be evaluated as exported.", "verdict": "rejected",
+          "evidence": "They 'collapse on chat evals (E15 step 20: 2.00 / 22.40 / 1.67)' until the SFT bias is transplanted back "
+                      "(repaired 24.00 / 74.20 / 21.67); bias-updating arms broaden routing (Gini 0.28–0.29 vs 0.57, about 221 vs "
+                      "140 effective experts per layer)."},
+         {"claim": "bf16 AdamW updates change the expert weights.", "verdict": "rejected",
+          "evidence": "About 80% of expert-tensor elements and 69% of attention-tensor elements had never changed at lr 1e-5; "
+                      "stochastic rounding (MarinSkyRL #452) is now the default."},
+         {"claim": "The arms can be ordered by AIME24.", "verdict": "open",
+          "evidence": "Fragile: E15 @20 − E17a @16 is +8.67 with a 95% CI of [−1.00, +19.33] (p = 0.082); AIME24 has only 30 items."},
+         {"claim": "E17a (frozen router, stochastic rounding) is the way forward.", "verdict": "open",
+          "evidence": "Recommendation: E17a 'seems like the most principled way forward'; 'RL training efficiency and speed should "
+                      "be a key target'; 24k and 32k contexts trained, 64k hit a backward-pass memory ceiling."}],
+        run_keys=tuple(f"math|{a_[0]}" for a_ in MATH_ARMS))
+    kit.report(
+        w, pid, "release", "Mixed-domain RLVR and the Snowball release candidate (#9359, #9409, #9412)",
+        "Marin (#9359, #9412)", at("2026-09-24 00:00"),
+        "A September 11 SFT trained through RLVR1 and RLVR2 under synchronous and bounded-staleness asynchronous schedules on 64 "
+        "H100s per arm (512 prompts × 16 samples), plus an RLVR1 arm from the older 5.7T agentic checkpoint. The sync RLVR1 "
+        "step-92 checkpoint became the release candidate after the 26-benchmark panel of the 2026-09-24 eval policy.",
+        [{"claim": "RLVR1 produced clear early learning.", "verdict": "upheld", "evidence": "#9359 TL;DR."},
+         {"claim": "RLVR2 improved validation further.", "verdict": "rejected",
+          "evidence": "'RLVR2 validation was flat to regressing': holdout pass@1 0.44 at sync step 116 and 0.37 at async step 146 "
+                      "(89-row holdout), against 0.54 for the 5.7T arm's step 38."},
+         {"claim": "Step92 is the strongest lineage checkpoint on the panel.", "verdict": "upheld",
+          "evidence": "It leads the five-model lineage cohort 69-30-5 (68.8% aggregate win rate, 4-0-0 pair series) — but 'Step92 "
+                      "was selected using point estimates from this same 26-benchmark panel, so these are in-sample "
+                      "release-selection results'; no out-of-sample check yet."},
+         {"claim": "Step92 improves on its SFT lineage across the board.", "verdict": "rejected",
+          "evidence": "It trails the Datakit SFT 09.17 (S1) on AIME24 (43.9 vs 61.0), MMLU-Pro (43.7 vs 62.0) and BFCL-Parity (12.2 "
+                      "vs 45.5)."},
+         {"claim": "Snowball checkpoints are competitive on agentic Harbor evals.", "verdict": "rejected",
+          "evidence": "SWE-bench Verified random-100: Step92 3.0 vs 72.2 for Qwen3.6-35B-A3B; Terminal-Bench 2.0: 1.2 vs 35.7."},
+         {"claim": "A higher learning rate (v104, AdamW 8e-6) improves RLVR1.", "verdict": "rejected",
+          "evidence": "v104's holdout avg_score fell 0.390 → 0.278 and pass@1 0.33 → 0.18 by step 14 while training reward first "
+                      "rose to 0.526 at step 6; cancelled after 15 updates."},
+         {"claim": "The released RLVR2 checkpoints are the lineages' best.", "verdict": "rejected",
+          "evidence": "The true RLVR2 pass@16 peaks (sync 118, async 140) 'had already been removed by checkpoint pruning'."},
+         {"claim": "Async vs sync is a clean algorithm-only comparison.", "verdict": "rejected",
+          "evidence": "Early local inference-bridge overload in the async lineage, and its holdout denominator changed (89 rows)."},
+         {"claim": "Every domain of the blend gives learning signal.", "verdict": "rejected",
+          "evidence": "'Per-domain trace analysis found nearly all-zero groups in several weak domains. NVARC and structured-output "
+                      "verifiers had output-contract mismatches; many Lean, coding, math, and NVARC generations also failed to "
+                      "reach a final answer before the turn cap.'"},
+         {"claim": "Step92 is released with a model card and post.", "verdict": "open",
+          "evidence": "As of 2026-09-26 its Hugging Face card is empty and the Open Athena blog lists no Snowball post-training "
+                      "post; the milestone 'September: Launch post-trained 67B-A2B to the world' is open."}],
+        run_keys=("rlvr1-sync", "rlvr2-sync", "rlvr1-async", "rlvr2-async", "rlvr1-57t", "v104"))
+    kit.report(
+        w, pid, "swe", "SWE RL on R2E-Gym (#9225, #8901, #8937)", "Marin (#9225)", at("2026-09-22 00:00"),
+        "Base vs SFT vs RL vs SFT-then-RL on SWE-bench Verified random-100 and Terminal-Bench 2 from the Stage-3 Snowball.",
+        [{"claim": "24 GRPO updates on R2E-Gym improve SWE-bench random-100.", "verdict": "upheld",
+          "evidence": "12/100 → 23/100; 'Paired on SWE-bench the new checkpoint solves 15 tasks the base does not and loses 4'."},
+         {"claim": "Training longer moves SWE-bench further.", "verdict": "rejected",
+          "evidence": "'Training longer does not move SWE-bench: update 48 scores 25 against update 24's 23'."},
+         {"claim": "SWE RL improves Terminal-Bench 2.", "verdict": "rejected", "evidence": "TB2 stays within noise (4/87 at update 24, 9/87 at update 48)."},
+         {"claim": "SFT on agent traces then RL beats either alone.", "verdict": "upheld",
+          "evidence": "Arm D epoch 1 + 30 GRPO steps: 0.307 [0.26, 0.36], 'the best number in this thread' (D alone 0.241, RL from "
+                      "base 0.23)."},
+         {"claim": "The agentic SFT arms also improve TB2.", "verdict": "rejected",
+          "evidence": "Stage-3 base 0.094 → arms A 0.051, C 0.035, D 0.061, B 0.004, D epoch 2 0.077."},
+         {"claim": "R2E-Gym tasks reward only real fixes.", "verdict": "rejected",
+          "evidence": "#8937 (TaskTrove v4.12): 2,614 of 3,035 active tasks behave correctly; 421 pandas/numpy tasks give reward 1 "
+                      "no matter what the agent does; 25 gold patches fail their own tests."},
+         {"claim": "OpenThoughts-Agent SFT data is free of SWE-bench Verified.", "verdict": "rejected",
+          "evidence": "255 of the 500 Verified issues appear rewritten inside its IssueTasks slice, which was removed from all arms."}],
+        run_keys=("r2e-base", "sftrl-d1", "sftrl-d2", "armA", "armB", "armC", "armD"))
+    return pid
diff --git a/viewer/build/labs/mimo.py b/viewer/build/labs/mimo.py
new file mode 100644
index 0000000000000000000000000000000000000000..a81231fa521c9c630238ddcdd7d5318d0471f9df
--- /dev/null
+++ b/viewer/build/labs/mimo.py
@@ -0,0 +1,1376 @@
+"""Xiaomi MiMo-V2.6: the two published RL runs (pro, flash) and the rest of what the lab released.
+
+Published, with the source on each record:
+- The Pro and Flash RL runs (https://mimo.xiaomi.com/rl/mimo-v26, archived in inputs/mimo): every metric
+  series, step times, restarts, notices, cost, in-training benchmark scores, per-source pass rates and
+  accepted counts, harness rollout shares.
+- The technical report and model cards: model sizes, architecture and lineage; the Distill SFT mixture
+  (Table 4); the released environments (Table 5); evaluations (Tables 3, 6, 7); validation results
+  (§4.2, Fig. 6b); router freezing (§5.4); failure analysis (§5.5); the RL cost split (Fig. 3).
+- The MiMo-V2.6-RL-oss dataset: released task ids and instructions (inputs/mimo/rl-oss-tasks.json.gz).
+- The verl mimo-oss scripts: hyperparameters of the per-domain GRPO runs on the 9B.
+- The launch blog: the Artificial Analysis index and the MiMo Visual Coding curve (inputs/mimo/blog-rl-curves.json).
+
+Simulated so that they agree with the published numbers: task difficulty and pass rates, rollouts and
+transcripts, per-task eval results, and the 9B runs' per-step curves, dates and step times.
+"""
+import datetime as dt
+import gzip
+import hashlib
+import json
+import math
+import re
+from pathlib import Path
+
+from .. import kit
+from .. import signals as sig
+from ..sim import Env, attempt, group_advantages, make_tasks, rid, rng, solve_skill, stable_seed, task_rows, weighted_choice
+from ..training import benchmark, env_metric_defs, eval_run, rl_run, sft_run
+from . import banks
+
+INPUTS = Path(__file__).resolve().parent.parent / "inputs" / "mimo"
+DASHBOARD = "https://mimo.xiaomi.com/rl/mimo-v26"
+ARCHIVE = "https://github.com/huanghw1989/mimo-rl-telemetry"
+TR = "https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL/blob/main/MiMo_V2_6_technical_report.pdf"
+PRO_CARD = "https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Pro-RL"
+FLASH_CARD = "https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Flash-RL"
+DISTILL_CARD = "https://huggingface.co/XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B"
+QWEN_CARD = "https://huggingface.co/Qwen/Qwen3.5-9B"
+DS_URL = "https://huggingface.co/datasets/XiaomiMiMo/MiMo-V2.6-RL-oss"
+DOCKER = "https://hub.docker.com/r/xiaomimimo/mimo-v2.6-rl-oss"
+VERL = "https://github.com/XiaomiMiMo/verl/tree/mimo-oss"
+VERL_FILE = "https://github.com/XiaomiMiMo/verl/blob/mimo-oss/"
+UNI_AGENT = "https://github.com/XiaomiMiMo/uni-agent"
+MIMOAGENT = "https://github.com/XiaomiMiMo/mimoagent"
+BLOG = "https://mimo.xiaomi.com/mimo-v2-6"
+BLOG_CURVES = "https://mimo.xiaomi.com/mimo-v2-6/rl-curves.js"
+
+SIGNAL_OF = {
+    "dynsam/avg@n": "pass_rate", "critic/rewards/mean": "reward", "actor/entropy_loss": "entropy",
+    "actor/grad_norm": "grad_norm", "actor/pg_loss": "pg_loss", "actor/pg_clipfrac": "clip_frac",
+    "actor/lr": "lr", "train_infer_diff/new_infer/kl": "train_infer_kl",
+    "ctx_response_length/mean": "response_len", "ctx_total_length/mean": "context_len",
+    "ctx_total_length/clip_ratio": "truncation_rate", "dynsam/agg_turn/mean": "turns",
+    "dynsam/passrate/zero": "all_fail_share", "dynsam/passrate/one": "all_pass_share",
+    "dynsam/infra_error/seq_rate": "infra_error_rate", "partial/avg_staleness": "staleness",
+    "timing_s/step": "step_time", "timing_s/outer_gen": "gen_time", "timing_s/trainer_ops": "train_time",
+    "perf/total_num_tokens": "tokens_trained", "env/active": "active_sandboxes",
+}
+
+# dashboard category -> viewer domain. "visual" is the report's aesthetic-design share (websites, apps, games,
+# slides, SVG, video, Figma), so it renders as front-end building.
+DOMAIN = {"code": "code", "general": "agentic", "chat": "chat", "visual": "web", "cyber": "cyber"}
+
+# Production task prompts are not published: honest placeholders for the two categories whose tasks the
+# report describes only by kind.
+DESIGN_KINDS = [("website", "Open-ended design: build a website to a brief."),
+                ("interactive-app", "Open-ended design: build an interactive application."),
+                ("game", "Open-ended design: build a small game."), ("3d-scene", "Open-ended design: build a 3D scene."),
+                ("slides", "Open-ended design: produce a slide deck."), ("svg", "Open-ended design: draw an SVG illustration."),
+                ("video", "Open-ended design: produce a short video."), ("figma", "Open-ended design: produce a Figma design."),
+                ("visual-replication", "High-fidelity visual replication: reproduce a reference design as code.")]
+CONTEXT_KINDS = [("context-following", "Context-following task.")]
+
+# Hackable share of environments per cleanup round, read from the report's Fig. 6b (approximate).
+HACK_ROUNDS = {"code/dataset-obg8": [0.92, 0.49, 0.33, 0.22], "code/dataset-zg6q": [1.0, 0.09],
+               "code/dataset-x7wh": [1.0, 0.13], "code/dataset-m1dt": [1.0, 0.20]}
+
+# Report Table 3: MiMo-V2.6-Pro, MiMo-V2.6-Flash, MiMo-V2.5-Pro, Claude Opus 5, GPT-5.6 Sol, Claude Fable 5.
+TABLE3_COLS = ["pro", "flash", "v25", "opus5", "sol", "fable5"]
+TABLE3 = [
+    ("deepswe", (71.9, 67.9, 19.0, 74.0, 73.0, 70.0)),
+    ("programbench", (26.5, 26.0, 12.5, 37.0, 25.0, 33.0)),
+    ("mimo-code-bench", (63.2, 61.2, 40.4, 68.6, 59.3, None)),
+    ("automation", (53.1, 52.3, 16.0, 50.3, 45.8, 46.2)),
+    ("toolathlon-verified", (76.9, 73.6, 49.1, 80.6, 74.9, 77.9)),
+    ("gdpval-aa", (1673, None, 1107, 1708, 1588, 1595)),
+    ("agents-last-exam", (31.6, 27.6, 13.2, 31.6, 30.8, 25.7)),
+    ("terminal-bench-4", (34.9, 28.8, 1.5, 49.0, 39.9, 42.4)),
+    ("terminal-bench-2.1", (89.9, 87.6, 65.2, 89.1, 88.8, 84.3)),
+    ("osworld-verified", (82.0, 80.8, None, 83.4, 83.0, 86.0)),
+    ("jobbench", (62.0, 61.2, 25.0, 65.7, 45.4, 57.4)),
+    ("cybergym", (94.0, 95.1, 40.0, None, None, None)),
+    ("mimo-cyber-bench", (80.2, 77.2, 0.0, None, None, None)),
+    ("exploitgym", (17.8, 6.0, 0.2, 22.1, 30.3, 28.4)),
+    ("exploitbench", (47.9, 25.3, 16.6, 70.0, 78.5, 78.0)),
+    ("sec-bench-pro", (66.3, 47.5, 17.7, None, 79.1, None)),
+    ("mimo-visual-coding", (72.3, 71.5, None, 70.0, 73.4, 69.1)),
+]
+
+# Report Table 6: Qwen3.5-9B, MiMo-V2.6-Distill-Qwen-9B (SFT), + domain GRPO (RL). Domain picks the RL run.
+TABLE6 = [
+    ("swe-bench-verified", "code", (60.0, 61.1, 66.2)),
+    ("swe-bench-pro", "code", (32.0, 44.6, 47.6)),
+    ("mimo-code-bench-mini", "code", (19.5, 51.6, 59.9)),
+    ("mimo-cyber-bench-mini", "cyber", (5.7, 31.3, 47.0)),
+    ("automation-avg1", "general", (5.0, 30.3, 33.1)),
+    ("terminal-bench-2.1", "general", (27.0, 37.1, 52.8)),
+    ("toolathlon-verified", "general", (25.9, 35.2, 38.0)),
+    ("officeqa-pro", "general", (9.0, 19.5, 24.8)),
+    ("jobbench", "general", (2.6, 18.3, 25.2)),
+    ("mimo-general-bench-mini", "general", (28.5, 62.2, 70.6)),
+    ("mimo-visual-coding-mini", "webdev", (61.7, 64.0, 72.4)),
+]
+MUSIC_SCORES = (45.7, 52.5)  # internal music benchmark after SFT and after music GRPO (report §7.2)
+
+# Report Table 7: seven harnesses (four training mini-harnesses, then codex, claude code, mini-swe-agent).
+TABLE7_HARNESSES = ["mini-harness1", "mini-harness2", "mini-harness3", "mini-harness4", "codex", "claude code", "mini-swe-agent"]
+TABLE7 = [
+    ("swe-verified-7h", "SWE-bench Verified", 500,
+     {"qwen": ([58.4, 36.4, 54.8, 57.8, 48.6, 54.8, 60.6], 53.1), "sft": ([61.7, 63.9, 61.7, 63.1, 58.5, 61.7, 65.3], 62.3),
+      "rl": ([67.9, 65.1, 66.6, 67.2, 61.1, 65.3, 66.7], 65.7)}),
+    ("swe-pro-7h", "SWE-bench Pro", 731,
+     {"qwen": ([33.5, 15.2, 31.1, 31.1, 23.1, 26.9, 31.6], 27.5), "sft": ([45.2, 46.6, 45.1, 45.5, 40.3, 42.2, 45.6], 44.4),
+      "rl": ([48.5, 46.9, 47.6, 48.0, 42.6, 43.1, 48.4], 46.5)}),
+    ("mimo-code-mini-7h", "MiMo Code Bench (mini)", 100,
+     {"qwen": ([19.0, 7.5, 16.5, 22.5, 10.5, 13.5, 17.5], 15.3), "sft": ([53.2, 56.7, 51.5, 56.3, 46.0, 51.2, 56.8], 53.1),
+      "rl": ([62.5, 64.5, 57.0, 63.3, 50.7, 53.0, 62.0], 59.0)}),
+]
+
+# RL cost split, report Fig. 3 (rollout / training / grader).
+COST_SPLIT = {"pro": (("rollouts", 0.438), ("training", 0.435), ("grader", 0.127)),
+              "flash": (("rollouts", 0.449), ("training", 0.409), ("grader", 0.142))}
+
+MODEL_SPEC = {
+    "pro": {"name": "MiMo-V2.6-Pro", "repo": "XiaomiMiMo/MiMo-V2.6-Pro-RL", "card": PRO_CARD, "total": 1024.22, "active": 42.0,
+            "exact": "1,024,216,603,392",
+            "body": "70 layers (60 sliding-window attention with window 128, 10 global attention; the first block is global attention "
+                    "with a dense FFN), hidden size 6144, 128 query / 8 KV heads, head dim 192 (QK) / 128 (V), 384 routed experts "
+                    "with 8 active, no shared experts; omni encoders (681M MiMo-ViT, 308M audio tokenizer, 127M audio patch encoder) "
+                    "and a 5-layer MTP drafter",
+            "pretrain": "30T tokens (27T text + 3T omni)", "deepswe": ("71.9", "72.57")},
+    "flash": {"name": "MiMo-V2.6-Flash", "repo": "XiaomiMiMo/MiMo-V2.6-Flash-RL", "card": FLASH_CARD, "total": 310.76, "active": 15.0,
+              "exact": "310,756,322,688",
+              "body": "48 layers (39 sliding-window attention, 9 global attention), hidden size 4096, 64 query heads (8 KV heads in "
+                      "sliding-window layers, 4 in global ones), 256 routed experts with 8 active, no shared experts, 3 multi-token-"
+                      "prediction layers; the same omni encoders as Pro",
+              "pretrain": "48T tokens (26T text + 22T omni)", "deepswe": ("67.9", "65.68")},
+}
+ARCH = "Hybrid sliding-window / global-attention sparse MoE, omni-modal"
+
+
+def load(name):
+    p = INPUTS / name
+    if p.suffix == ".gz":
+        with gzip.open(p, "rt") as fh:
+            if name.endswith(".jsonl.gz"):
+                return [json.loads(line) for line in fh if line.strip()]
+            return json.load(fh)
+    return json.loads(p.read_text())
+
+
+def explainer_index():
+    items = load("metrics-explainers.json.gz")["items"]
+    out = []
+    for it in items:
+        pattern = it["id"].replace("<cat>", "[^/]+").replace("<id>", "[^/]+").replace("<harness>", "[^/]+")
+        out.append((pattern, it))
+    return out
+
+
+def describe(tag, official, explainers):
+    if tag in official:
+        return official[tag]
+    for pattern, it in explainers:
+        if re.fullmatch(pattern, tag):
+            return it.get("what") or it.get("name")
+    return ""
+
+
+def judge_target(mean_reward):
+    """Pass probability p that makes a judge-scored attempt average `mean_reward`.
+
+    sim.attempt draws judge rewards from Beta(1 + 6p, 1 + 6(1 - p)), whose mean is 0.125 + 0.75p."""
+    return min(0.99, max(0.01, (mean_reward - 0.125) / 0.75))
+
+
+def list_bank(items):
+    def gen(r, i):
+        return items[i][0], items[i][1]
+    return gen
+
+
+def placeholder_bank(kinds, note):
+    def gen(r, i):
+        slug, text = kinds[r.randrange(len(kinds))]
+        return f"{slug}-{i:04d}", f"{text} {note}"
+    return gen
+
+
+def pct(v):
+    return round(v / 100.0, 6)
+
+
+def spend(w, org_id, pid, start, end, cost, split):
+    """Spread a run's published cost over the UTC days it ran, by category, so the rows add up to the cent."""
+    spans, t = [], start
+    while t < end:
+        nxt = min(end, (math.floor(t / 86400) + 1) * 86400)
+        spans.append((dt.datetime.fromtimestamp(t, dt.timezone.utc).strftime("%Y-%m-%d"), (nxt - t) / (end - start)))
+        t = nxt
+    parts = [round(cost * share, 2) for _, share in split[:-1]]
+    parts.append(round(cost - sum(parts), 2))
+    for (cat, _), total in zip(split, parts):
+        vals = [round(total * f, 2) for _, f in spans]
+        vals[-1] = round(total - sum(vals[:-1]), 2)
+        for (day, _), v in zip(spans, vals):
+            w.add("usage", {"org_id": org_id, "project_id": pid, "day": day, "category": cat, "quantity": None,
+                            "unit": "usd", "cost_usd": v})
+
+
+def build(w, now):
+    at = kit.ts
+    org_id = rid("org", "xiaomi-mimo")
+    w.add("orgs", {"id": org_id, "slug": "xiaomi-mimo", "name": "Xiaomi MiMo",
+                   "about": "Xiaomi's foundation-model team.", "url": "https://mimo.xiaomi.com"})
+    pid = rid("proj", "mimo-v2.6")
+    dash = load("dashboard-runs.json")
+    official = dash["descriptions"]
+    pub = {k: {"series": load(f"{k}-series.json.gz"), "axis": load(f"{k}-axis.json.gz"), "status": load(f"{k}-status.json.gz"),
+               "events": load(f"{k}-events.json.gz")} for k in ("pro", "flash")}
+    oss = load("rl-oss-tasks.json.gz")
+    curves = {p["title"]: p for p in load("blog-rl-curves.json")["panels"]}
+    w.add("projects", {
+        "id": pid, "org_id": org_id, "slug": "mimo-v2-6", "name": "MiMo-V2.6 RL",
+        "summary": "Scaling RL on MiMo-V2.6: the two published 30-step mixed RL runs of MiMo-V2.6-Pro and -Flash (code, general "
+                   "agent, visual design, context following and cyber, 1,568 prompts × 16 attempts per step), and the open baseline "
+                   "built beside them: MiMo-V2.6-Distill-Qwen-9B, distilled from 77.4B tokens of MiMo-generated data, with per-domain "
+                   "GRPO on the released RL environments.",
+        "created_at": at("2026-08-20 00:00"),
+        "sources": [{"title": "MiMo-V2.6 RL live dashboard", "url": DASHBOARD},
+                    {"title": "mimo-rl-telemetry archive of the dashboard (MIT)", "url": ARCHIVE},
+                    {"title": "MiMo-V2.6 technical report", "url": TR},
+                    {"title": "MiMo-V2.6-Pro-RL model card", "url": PRO_CARD},
+                    {"title": "MiMo-V2.6-Flash-RL model card", "url": FLASH_CARD},
+                    {"title": "MiMo-V2.6-Distill-Qwen-9B model card", "url": DISTILL_CARD},
+                    {"title": "MiMo-V2.6-RL-oss environments dataset", "url": DS_URL},
+                    {"title": "XiaomiMiMo/verl, branch mimo-oss (per-domain GRPO recipes)", "url": VERL},
+                    {"title": "XiaomiMiMo/uni-agent", "url": UNI_AGENT},
+                    {"title": "XiaomiMiMo/mimoagent", "url": MIMOAGENT},
+                    {"title": "MiMo-V2.6 launch blog", "url": BLOG}],
+        "data_note": "Published: every metric, step time, restart, notice, cost and in-training benchmark score of the Pro and Flash "
+                     "runs (Xiaomi's live RL dashboard); model sizes and lineage (model cards); the SFT mixture, released environments "
+                     "and validation results (technical report, dataset card); evaluation scores (report Tables 3, 6 and 7, launch "
+                     "blog); the open recipes' hyperparameters (verl mimo-oss scripts). Simulated to match: rollouts, transcripts and "
+                     "task pass rates (matched to the published per-source pass rates), per-task eval results (matched to each "
+                     "published score), and the 9B runs' per-step curves, dates and step times, of which only the start and end "
+                     "scores are published. Dashboard data-source and harness names are Xiaomi's own anonymized ids.",
+        "pins": dash["pins"]})
+    explainers = explainer_index()
+
+    # models ---------------------------------------------------------------
+    M = {}
+
+    def model(key, name, kind="checkpoint", **kw):
+        M[key] = kit.model(w, pid, key, name, kind, **kw)
+        return M[key]
+
+    models = {}
+    for key, s in MODEL_SPEC.items():
+        end = pub[key]["status"]["run"]["end"]
+        mid = model(f"{key}|mid", f"{s['name']} base (pre- and mid-trained)", "base", arch=ARCH, params_total=s["total"],
+                    params_active=s["active"], context_len=1048576, stage="Pre-/mid-training", created_at=at("2026-09-10 00:00"),
+                    status="internal", source=TR,
+                    notes=f"{s['body']}. Pre-trained on {s['pretrain']} at 32K context extended to 256K, then agent-centric "
+                          "mid-training at 256K extended to 1M with the Muown optimizer for hidden weights and MXFP4 quantization-"
+                          "aware training; mid-training also added self-correction examples against reward hacking. Weights of "
+                          "this stage are not released.")
+        sft = model(f"{key}|base", f"{s['name']} SFT checkpoint", arch=ARCH, params_total=s["total"], params_active=s["active"],
+                    context_len=1048576, parent_id=mid, stage="SFT", created_at=1789468339.334 - 86400 * 3, status="internal",
+                    source=TR,
+                    notes="Output of the short SFT stage that precedes RL. Its data, size and hyperparameters are not published "
+                          "(the report's 77.4B-token SFT mixture is for the 9B distillation, not this model). RL starts from its FP32 "
+                          "master weights and Muown optimizer row state.")
+        extra = (" MiMo-V2.6-Pro-UltraSpeed, an API mode with up to 20× faster output at the same quality, has no separate "
+                 "weights." if key == "pro" else "")
+        out = model(f"{key}|rl", s["repo"].split("/")[1], hf_repo=s["repo"], arch=ARCH, params_total=s["total"],
+                    params_active=s["active"], context_len=1048576, parent_id=sft, run_key=key, step=30, stage="RL",
+                    created_at=end, status="released", source=s["card"],
+                    notes=f"Output of the 30-step mixed RL run, released on Hugging Face under MIT on Sept 21, 2026 ({s['exact']} "
+                          "parameters, weights in FP8 E4M3); launch blog Sept 22. The model card lists the report's Table 3 scores for "
+                          "this checkpoint; the report places MOPD2 (multi-prefix multi-teacher on-policy distillation) after mixed "
+                          "RL and calls Table 3 the final results, so they need not equal the run's own step-30 evals (DeepSWE v1.1: "
+                          f"{s['deepswe'][0]} in Table 3, {s['deepswe'][1]} at step 30)." + extra)
+        models[key] = (sft, out)
+
+    sft_start = at("2026-08-24 00:00")
+    qwen = model("qwen3.5-9b", "Qwen3.5-9B", "base", hf_repo="Qwen/Qwen3.5-9B", arch="Dense, hybrid linear attention + full attention (Qwen3.5)",
+                 params_total=9.41, params_active=9.41, context_len=262144, stage="Pretrained", created_at=at("2026-08-20 00:00"),
+                 status="available", source=DISTILL_CARD,
+                 notes="Base model of the open distillation. Size and context as on the MiMo-V2.6-Distill-Qwen-9B card, which is a "
+                       "full fine-tune of this model.")
+    model("mimo-v2.6-sft-grader", "MiMo-V2.6-SFT (general-task grader)", "judge", created_at=at("2026-09-14 00:00"),
+                  status="internal", source=TR,
+                  notes="A self-hosted MiMo-V2.6-SFT model graded the general-agent rubrics during the flagship RL runs 'to support "
+                        "stable scoring'. Its size and checkpoint are not disclosed.")
+    for key, name, repo, note in (
+            ("mimo-v2.5-pro", "MiMo-V2.5-Pro", "XiaomiMiMo/MiMo-V2.5-Pro", "Previous-generation MiMo model; a reference column in Table 3."),
+            ("claude-opus-5", "Claude Opus 5", None, "Frontier reference in Table 3, evaluated at its highest reasoning effort."),
+            ("gpt-5.6-sol", "GPT-5.6 Sol", None, "Frontier reference in Table 3, evaluated at its highest reasoning effort."),
+            ("claude-fable-5", "Claude Fable 5", None, "Frontier reference in Table 3, evaluated at its highest reasoning effort.")):
+        model(key, name, "external", hf_repo=repo, created_at=at("2026-09-21 00:00"), status="external", source=TR, notes=note)
+    ref_ids = {"pro": models["pro"][1], "flash": models["flash"][1], "v25": M["mimo-v2.5-pro"], "opus5": M["claude-opus-5"],
+               "sol": M["gpt-5.6-sol"], "fable5": M["claude-fable-5"]}
+
+    # datasets --------------------------------------------------------------
+    ds_mix = kit.dataset(
+        w, pid, "distill-sft-mixture", "MiMo-V2.6 Distill SFT mixture", "sft", tokens=77_400_000_000,
+        sources=[{"name": "Code", "category": "code", "tokens": 23_200_000_000, "synthetic": True, "generator": "MiMo (MiMo-generated data)"},
+                 {"name": "Cyber", "category": "cyber", "tokens": 11_000_000_000, "synthetic": True, "generator": "MiMo (MiMo-generated data)"},
+                 {"name": "General", "category": "agentic", "tokens": 22_000_000_000, "synthetic": True, "generator": "MiMo (MiMo-generated data)"},
+                 {"name": "Visual", "category": "visual", "tokens": 21_200_000_000, "synthetic": True, "generator": "MiMo (MiMo-generated data)"}],
+        processing=[{"step": "Weighted mixture of MiMo-generated data", "rows_in": None, "rows_out": None,
+                     "note": "77.4B tokens: code 23.2B (29.9%), cyber 11.0B (14.2%), general 22.0B (28.5%), visual 21.2B (27.4%)."},
+                    {"step": "Loss masking", "rows_in": None, "rows_out": None,
+                     "note": "27.2B of the 77.4B tokens are loss-bearing: code 7.3B, cyber 4.8B, general 5.7B, visual 9.4B."}],
+        description="Weighted SFT mixture used to distill MiMo into Qwen3.5-9B (report Table 4): MiMo-generated data spanning "
+                    "coding, cybersecurity, general-domain and visual tasks, 77.4B tokens of which 27.2B are loss-bearing (they "
+                    "contribute to the SFT objective). Values are rounded to one decimal; totals use unrounded counts. Row counts, "
+                    "the generating checkpoints and the data itself are not published, so no rows are stored.",
+        created_at=sft_start - 86400 * 2, source=DISTILL_CARD, provenance="published")
+    samples = []
+    cat_of = {"code": "swe", "general": "agentic", "webdev": "visual", "music": "music"}
+    for cfg in ("code", "general", "webdev", "music"):
+        for smp in oss["samples"][cfg]:
+            data = {"messages": [{"role": "user", "content": smp["prompt"][:2500]}]}
+            data.update({k: v for k, v in smp.items() if k != "prompt"})
+            samples.append({"source": cfg, "category": cat_of[cfg], "data": data})
+    kit.dataset(
+        w, pid, "rl-oss", "MiMo-V2.6-RL-oss", "rl", rows=7780, license="apache-2.0", hf_repo="XiaomiMiMo/MiMo-V2.6-RL-oss",
+        sources=[{"name": "code (opensource-code)", "category": "swe", "rows": 2698, "synthetic": None, "license": "apache-2.0", "url": DS_URL},
+                 {"name": "cyber (arvo)", "category": "cyber", "rows": 1000, "synthetic": False, "license": "apache-2.0", "url": DS_URL},
+                 {"name": "general: general_agent", "category": "agentic", "rows": 925, "synthetic": True, "license": "apache-2.0", "url": DS_URL},
+                 {"name": "general: terminal_bench", "category": "terminal", "rows": 64, "synthetic": None, "license": "apache-2.0", "url": DS_URL},
+                 {"name": "webdev (blackbox/webdev)", "category": "visual", "rows": 2093, "synthetic": True, "license": "apache-2.0", "url": DS_URL},
+                 {"name": "music", "category": "music", "rows": 1000, "synthetic": True, "license": "apache-2.0", "url": DS_URL}],
+        processing=[{"step": "Leak cleanup", "rows_in": None, "rows_out": None,
+                     "note": "Build logs, verifier outputs, residual patches, compiled artifacts and out-of-repo caches removed; git "
+                             "history kept only up to the base commit; container-level network isolation (report §4.2.6, mimoagent "
+                             "anti_hack_cleanup)."},
+                    {"step": "Flaky-test screen", "rows_in": None, "rows_out": None,
+                     "note": "Code: F2P tests fail and P2P tests pass before the reference patch, both pass after it, stable across 8 reruns."},
+                    {"step": "Rollout audit", "rows_in": None, "rows_out": None,
+                     "note": "Code: 4 attempts per task; an auditing agent flags passing-but-wrong and failing-but-right results."},
+                    {"step": "Hack-agent screening", "rows_in": None, "rows_out": None,
+                     "note": "Repeated until the hack agent found no working exploit in any environment."}],
+        samples=samples,
+        description=f"The released RL training environments (report Table 5 rounds them to about 3k code, 1k cyber, 1k general "
+                    f"and 2k visual tasks, plus about 1k music tasks): 2,698 code, 1,000 cyber, 989 general (925 knowledge-work "
+                    f"tasks and 64 terminal-bench repair tasks), 2,093 webdev and 1,000 music tasks, 7,780 rows in all. Task images "
+                    f"are on Docker Hub as xiaomimimo/mimo-v2.6-rl-oss (3,764 tags: 2,698 code, 1,000 arvo, 65 general-agent-env, "
+                    f"1 webdev; {DOCKER}). Code tasks mix mined GitHub issues and written specifications, so they are not marked "
+                    f"synthetic. The rows shown are real published prompts; cyber rows are not reproduced here.",
+        created_at=at("2026-09-21 00:00"), source=DS_URL, provenance="published")
+
+    # graders and environments: the flagship run's data sources -------------------
+    graders = {}
+    for cat, kind, desc, comps, formula in (
+            ("code", "unit_tests",
+             "Hidden tests run in the task's sandbox; the reward is 1 only if they pass. In the flagship run passing solutions are "
+             "further told apart by quality: Groupwise Reward Synthesis (offline task-specific rubrics, reward = tests × solution "
+             "score × behavior score) on a subset of high-pass-rate tasks, and Groupwise Advantage Redistribution on the rest, where "
+             "an SFT-trained grader ranks the passing patches of a group on approach, precision, minimality, side effects and "
+             "craftsmanship and moves positive advantage toward the better ones; confirmed hacks are reset to 0 (report §4.3).",
+             [{"name": "tests", "weight": 1.0, "rule": "1 if the required tests pass, else 0."}], None),
+            ("general", "rubric",
+             "Atomic binary rubric items: code checks for deterministic properties (database values, deliverable formats) and LLM "
+             "checks for open-ended content, kept when repeated and cross-model judgments agree, plus negative checks for unintended "
+             "changes to unrelated files or databases. During the flagship RL a self-hosted MiMo-V2.6-SFT model was the grader "
+             "(report §4.2.2).",
+             [{"name": "rubric items", "weight": 1.0, "rule": "Items passed; the flagship run's aggregation is not published."}], None),
+            ("chat", "not published",
+             "Context-following prompts, 3% of the flagship batch. The report does not describe their grader.",
+             [{"name": "score", "weight": 1.0, "rule": "Not published."}], "reward: not published"),
+            ("visual", "llm_judge",
+             "Open-ended design: pointwise rubrics for runtime correctness, instruction adherence, layout integrity and basic "
+             "aesthetics, then group-wise comparison of the rendered artifacts within each rollout group, rewarding clearly "
+             "stronger candidates. High-fidelity replication: rule-based similarity such as pixel-level similarity, plus LLM "
+             "holistic judging (report §4.2.3).",
+             [{"name": "pointwise rubrics", "weight": None, "rule": "Runtime correctness, instruction adherence, layout integrity, basic aesthetics."},
+              {"name": "group-wise comparison", "weight": None, "rule": "Rendered artifacts of one group compared together; stronger ones score higher."}],
+             "reward from pointwise rubrics and group-wise comparison (combination not published)"),
+            ("cyber", "execution",
+             "Vulnerability reproduction: a submission is accepted when the crash it produces matches the ground-truth report's "
+             "vulnerability type and crash location under rule-based string matching. Deterministic, no LLM judge (report §4.2.4).",
+             [{"name": "crash match", "weight": 1.0, "rule": "1 if type and location match the ground-truth report, else 0."}], None)):
+        graders[cat] = kit.grader(w, pid, cat, f"{cat}-grader", kind, desc, comps, formula)
+
+    envs = {}
+    for key in ("pro", "flash"):
+        series = pub[key]["series"]
+        for tag in series:
+            parts = tag.split("/")
+            if not (tag.startswith("train/passrate/avg_passrate/") and len(parts) == 5):
+                continue
+            name = f"{parts[3]}/{parts[4]}"
+            if name in envs:
+                continue
+            cat = parts[3]
+            resp = series.get(f"ctx_response_length/{name}/mean") or series.get(f"ctx_response_length/{cat}/mean") or [None]
+            resp_v = next((v for v in reversed(resp) if v), 20000)
+            env_id = rid("env", pid, name)
+            n_tasks = {"code": 900, "general": 420, "chat": 260, "visual": 380, "cyber": 300}[cat]
+            bank = (placeholder_bank(DESIGN_KINDS, "The production prompts are not published.") if cat == "visual" else
+                    placeholder_bank(CONTEXT_KINDS, "The production prompts are not published.") if cat == "chat" else
+                    banks.bank_for(DOMAIN[cat], name))
+            # no simulated task defects: the report screens flaky tests out (8 reruns) and publishes no defect counts
+            tasks = make_tasks(env_id, n_tasks, bank, (0.0, 2.2))
+            agentic = cat in ("code", "general", "cyber", "visual")
+            envs[name] = Env(id=env_id, project_id=pid, name=name, domain=DOMAIN[cat], harness="mixed",
+                             reward_kind="binary" if cat in ("code", "cyber", "general") else "scalar",
+                             tasks=tasks, infra_rate=0.006, timeout_rate=0.02,
+                             turns=(30, 150) if cat == "visual" else ((44, 150) if agentic else (1, 1)),
+                             tokens_out=resp_v * 0.8, tokens_in=4100, seconds=900 if agentic else 40,
+                             max_tokens=262144 if name == "code/dataset-4onq" else 1048576,
+                             judge=cat in ("chat", "visual"), tools=[])
+    hack_check = {"name": "Confirmed hacking during training", "status": "pass", "source": TR,
+                  "detail": "Offline trajectory audits ran throughout both runs, and the groupwise grader reset confirmed-hack "
+                            "trajectories to reward 0 before computing advantages. The logged confirmed-hack share stayed below 2% of "
+                            "all trajectories at every step of both runs (about 0.4–1.8% per step; report Fig. 6b, run-wide rather than "
+                            "per source)."}
+    env_desc = {
+        "code": "Repository-level coding tasks solved by an agent in a sandbox; agentic and competitive coding are 68% of the "
+                "flagship batch. Tasks shown are simulated placeholders; the production prompts are not published.",
+        "general": "General tool-use and knowledge-work tasks (12% of the flagship batch) in local, resettable workspaces with "
+                   "software mocks, graded on rubrics. Tasks shown are simulated placeholders.",
+        "chat": "Context-following prompts (3% of the flagship batch); this category is not in the released dataset and the "
+                "report does not describe its tasks or grader.",
+        "visual": "Aesthetic-design tasks (13% of the flagship batch; the dashboard calls the category 'visual'): websites, apps, "
+                  "games, 3D scenes, slides, SVG, video and Figma designs, graded with pointwise rubrics and group-wise comparison.",
+        "cyber": "Vulnerability-reproduction tasks (4% of the flagship batch). The MiMo team removed this source from the pro run "
+                 "after step 14 because they saw bad patterns in its rollout logs; flash kept it for all 30 steps. Tasks are not "
+                 "shown."}
+    for name, env in envs.items():
+        cat = name.split("/")[0]
+        checks = []
+        if name in HACK_ROUNDS:
+            rounds = HACK_ROUNDS[name]
+            checks.append({"name": "Hack agent, cleanup rounds", "status": "pass", "rounds": rounds, "source": TR,
+                           "detail": "Share of this source's environments where the hack agent found a working exploit, by cleanup "
+                                     "round (read from the report's Fig. 6b, so approximate). Each round's findings fed the next "
+                                     "cleanup, and the team kept going until the hack agent found no successful exploit in any "
+                                     "environment."})
+        if cat == "code":
+            checks.append(hack_check)
+        if cat == "cyber":
+            checks.append({"name": "Rollout review", "status": "warn", "source": DASHBOARD,
+                           "detail": "Removed from the pro run after step 14: the team 'observed some bad patterns in the rollout "
+                                     "logs' (dashboard notice, Sept 17). Flash trained on it for all 30 steps."})
+        w.add("environments", {
+            "id": env.id, "project_id": pid, "name": name, "domain": env.domain, "version": "",
+            "description": env_desc[cat] + " Name as published on the dashboard.",
+            "harness": "not published" if cat == "chat" else "23 harnesses (harness-A … harness-U)",
+            "tools": [], "grader_id": graders[cat], "reward_kind": env.reward_kind,
+            "sandbox": None if cat == "chat" else {"isolation": "one sandbox per rollout, restorable to a fixed initial state",
+                                                  "network": "container-level isolation"},
+            "task_count": len(env.tasks), "created_at": 1789468339.334 - 86400 * 20, "source": DASHBOARD,
+            "provenance": "mixed", "checks": checks or None})
+
+    # graders and environments: the released RL-oss configs ------------------------
+    g_code = kit.grader(
+        w, pid, "oss-code", "rl-oss code tests", "unit_tests",
+        "The task's hidden test patch is applied and its test command runs in the pod; the reward is 1.0 if it exits 0. Fail-to-pass "
+        "(F2P) tests must go from failing to passing and pass-to-pass (P2P) tests must keep passing; 276 tasks run a two-phase "
+        "'base && new' command (P2P regression first, then F2P). Verifier timeout 1,800 s. In the flagship run GRS and GAR add "
+        "quality grading on top.",
+        [{"name": "test command", "weight": 1.0, "rule": "1.0 if mimo_test_command.sh exits 0 (F2P fail→pass, P2P stay pass), else 0.0."}])
+    g_general = kit.grader(
+        w, pid, "oss-general", "rl-oss general rubric", "rubric",
+        "Each task ships a verify.py and verifier_meta.json. Deterministic checks run first, then red-line gates (for example a "
+        "src_protect source-conservation gate sets the score to 0 if the agent changed files or database tables outside its "
+        "footprint), then atomic rubric items judged by an LLM at GA_JUDGE_URL (the script's placeholder default is gpt-4o-mini), "
+        "weighted by tier (critical, important). The open recipe binarizes the weighted score at 1.0 (REWARD_BINARIZE). The 64 "
+        "terminal-bench tasks use in-pod tests with an anti_hack_guard.py.",
+        [{"name": "red-line gates", "weight": None, "rule": "Any violation sets the task score to 0."},
+         {"name": "rubric items", "weight": 1.0, "rule": "Tier-weighted share of atomic items passed (LLM and code checks)."},
+         {"name": "binarize", "weight": None, "rule": "Reward 1 if the weighted score reaches 1.0, else 0."}],
+        "reward = 1 if the gates pass and the weighted rubric score ≥ 1.0, else 0")
+    g_web = kit.grader(
+        w, pid, "oss-webdev", "rl-oss webdev vision grader", "llm_judge",
+        "An external grader service renders each rollout's dist/ full-page in a headless browser. A no-LLM runtime gate checks "
+        "that the site builds and renders; a group pick compares the group's renders over an 8-round Williams design for relative "
+        "visual quality; a per-rollout query-fit judge (0–1) deducts for missed requirements.",
+        [{"name": "runtime gate", "weight": None, "rule": "No-LLM check that the build renders."},
+         {"name": "pick_norm", "weight": None, "rule": "Relative visual quality within the group (8-round Williams design), normalized."},
+         {"name": "query_deduct", "weight": None, "rule": "Deduction from the per-rollout query-fit judge (0–1)."}],
+        "reward = max(0, (pick_norm − query_deduct + 2) / 3)")
+    g_music = kit.grader(
+        w, pid, "oss-music", "rl-oss music scorer", "execution",
+        "CPU scorer with no dependencies beyond the standard library and the abc2midi binary: the ABC answer is rendered to MIDI "
+        "and scored for human-likeness. Outputs that cannot be rendered, or have 10 or more bar errors, blank output or channel "
+        "conflicts, get 0. Runs off the GPU path with 16 reward workers.",
+        [{"name": "feature bands", "weight": 0.85, "rule": "Conformance to human percentile bands over 18 features in 6 groups (rhythm, texture, acoustic, tonal, register, structure)."},
+         {"name": "histogram agreement", "weight": 0.15, "rule": "Jensen–Shannon agreement with corpus pitch-class, interval and duration histograms."}],
+        "reward = clamp(0.85 × bands + 0.15 × histogram agreement, 0, 1)")
+    g_cyber = kit.grader(
+        w, pid, "oss-cyber", "rl-oss cyber rule checks", "execution",
+        "Rule checks: the vulnerability type and crash location come from the same ground-truth sanitizer report that defines the "
+        "task and are matched by string comparison, so grading is deterministic, reproducible and cheap; no LLM judge (report §4.2.4).",
+        [{"name": "crash match", "weight": 1.0, "rule": "1 if type and location match the ground-truth report, else 0."}])
+
+    ga = [g for g in oss["general"]]
+    oss_env = {}
+    oss_env["code"] = kit.environment(
+        w, pid, "oss|code", "rl-oss/code", "code", n_tasks=len(oss["code"]), task_count=2698, bank=list_bank(oss["code"]),
+        grader_id=g_code, harness="mimoagent code mini-harnesses: mini-mimocode, mini-bash, mini-claude-code, mini-codex (500-step limit)",
+        tools=["bash", "read", "write", "edit", "grep", "glob", "task", "exec_command", "apply_patch"], reward_kind="binary",
+        sandbox={"backend": "Kubernetes, one pod per rollout", "workdir": "/testbed (2,179 tasks) or /workspace/repo (519)",
+                 "network": "isolated; git history kept up to the base commit", "concurrency": "up to 2,048 sessions"},
+        description="Software-engineering tasks from the released code config (data_source opensource-code, ids format-code-task-*): "
+                    "GitHub-issue-style or specification-style requests against a repository, each with its own Docker image. The "
+                    "report builds its code corpus from mined PRs and issues, employee requests, specifications, source-code-driven "
+                    "synthesis and long-horizon engineering tasks, plus filtered public sets (SWE-rebench, PrimeIntellect SWE-RL, "
+                    "SWE-Lego). 2,000 of the 2,698 tasks are stored with their real ids and first lines; tasks whose statement "
+                    "mentions security topics are left out.",
+        version="MiMo-V2.6-RL-oss", source=DS_URL, provenance="mixed", difficulty=(0.2, 2.0), created_at=at("2026-08-20 00:00"),
+        profile={"turns": (40, 500), "tokens_out": 25000, "tokens_in": 6000, "seconds": 1500, "infra_rate": 0.01,
+                 "timeout_rate": 0.03, "max_tokens": 245760},
+        checks=[{"name": "Reference patch and flaky-test screen", "status": "pass", "source": TR,
+                 "detail": "For tasks with a reference patch, F2P tests must fail and P2P tests must pass before the patch, and both "
+                           "must pass after it, with the outcome stable across eight reruns; this screens out flaky tests and "
+                           "environment-induced reward noise. The report states the rule, not how many tasks it removed."},
+                {"name": "Oracle verification", "status": "pass", "source": UNI_AGENT,
+                 "detail": "Before training, each task's gold solution is run through its normal verifier to check sandbox "
+                           "scalability and verifier correctness (uni-agent, docs/source/quickstart/oracle-verification.md). The "
+                           "documented full run on SWE-bench Verified solved 492 of 500 gold patches (98.4%, 0 errors), and the docs "
+                           "accept a few triaged oracle failures (invalid gold patches, flaky samples, environment drift). No oracle "
+                           "count is published for this dataset."},
+                {"name": "Rollout audit (4 attempts)", "status": "pass", "source": TR,
+                 "detail": "Each task is attempted four times; an auditing agent reads all four rollouts with the statement, tests and "
+                           "reference patch and flags passing-but-wrong and failing-but-right results for review. Tests that enforce "
+                           "requirements missing from the specification are revised or removed."},
+                {"name": "Leak cleanup and runtime guard", "status": "pass", "source": MIMOAGENT,
+                 "detail": "anti_hack_cleanup purges build residue, compiled artifacts and out-of-repo caches (the code notes that the "
+                           "env_hacker audit found these the single biggest leak vector); git history is truncated to the base "
+                           "commit; a runtime AntiHackGuard answers likely solution-fetching tool calls with a dummy observation "
+                           "instead of ending the rollout."},
+                {"name": "Infrastructure failures excluded", "status": "pass", "source": VERL,
+                 "detail": "avg@n_no_infra keeps a prompt's pass rate only if at least min(2, n) attempts survived; attempts lost to "
+                           "infrastructure are left out of the denominator instead of scoring 0."}])
+    code_meta = {row[0]: row for row in oss["code"]}
+    for t in oss_env["code"].tasks:
+        row = code_meta.get(t.name)
+        if row:
+            t.tags = [x for x in (row[2], "two-phase base && new" if row[3] else None) if x]
+    oss_env["general"] = kit.environment(
+        w, pid, "oss|general", "rl-oss/general", "agentic", n_tasks=len(ga), task_count=989, bank=list_bank([(g[0], g[5]) for g in ga]),
+        grader_id=g_general, harness="mimoagent general agent (Claude-Code-style tools and the task's MCP servers, 500-step limit)",
+        tools=["Bash", "Read", "Write", "Edit", "Grep", "Glob", "MCP servers of the task"], reward_kind="binary",
+        sandbox={"backend": "Kubernetes pod with a main and a sidecar container",
+                 "state": "MCP servers and SQLite live in the sidecar, isolated from the agent", "reset": "fixed initial state"},
+        description="Knowledge-work tasks from the released general config: 925 general-agent tasks across 16 professional domains "
+                    "(accounting/audit/tax 157, finance/insurance 135, healthcare operations 107, consulting and business operations "
+                    "89, HR 77, IT 72, government 72, education administration 55, legal 47, energy/ESG 47, then manufacturing, "
+                    "e-commerce, construction, hospitality, logistics and agriculture), 504 in English and 421 in Chinese, difficulty "
+                    "tiers t1–t5, from 693 scenarios; plus 64 terminal-bench repair tasks. Each environment is a workspace with local "
+                    "software mocks reached over MCP. 947 tasks are stored with their real ids (the terminal-bench tasks in the "
+                    "Security category are left out). In the open recipe the reward is binary.",
+        version="MiMo-V2.6-RL-oss", source=DS_URL, provenance="mixed", difficulty=(0.0, 2.0), created_at=at("2026-08-20 00:00"),
+        profile={"turns": (30, 500), "tokens_out": 15000, "tokens_in": 8000, "seconds": 600, "infra_rate": 0.01,
+                 "timeout_rate": 0.03, "max_tokens": 212992},
+        checks=[{"name": "Rubric validation", "status": "pass", "source": TR,
+                 "detail": "Rubric items are atomic and binary: code checks for deterministic properties, LLM checks for open-ended "
+                           "content, kept when repeated and cross-model judgments agree. Rollouts from models of different strength "
+                           "are reviewed to loosen criteria that reject valid solutions and tighten ones that accept incomplete work."},
+                {"name": "Negative and adversarial checks", "status": "pass", "source": DS_URL,
+                 "detail": "Negative checks catch unintended changes to unrelated files or databases, and adversarial solutions that "
+                           "look correct without solving the task are used to test the rubrics (report §4.2.2). In the released "
+                           "graders a src_protect gate sets the score to 0 when the agent changes anything outside its footprint."},
+                {"name": "Terminal-bench anti-hack guard", "status": "pass", "source": DS_URL,
+                 "detail": "The 64 terminal-bench tasks ship an in-pod anti_hack_guard.py that sets the reward to 0 on planted "
+                           "interpreter hooks or protected-file changes."},
+                {"name": "Infrastructure failures excluded", "status": "pass", "source": VERL_FILE + "scripts/general/general.sh",
+                 "detail": "INVALID_REWARD_FOR_INFRA=true: rollouts that fail for infrastructure reasons get the sentinel reward −999 "
+                           "and are left out of the group statistics instead of counting as 0."}])
+    gen_meta = {row[0]: row for row in ga}
+    for t in oss_env["general"].tasks:
+        row = gen_meta.get(t.name)
+        if row:
+            t.tags = [x for x in (row[1], row[2], row[3], f"t{row[4]}" if row[4] else None) if x]
+    oss_env["webdev"] = kit.environment(
+        w, pid, "oss|webdev", "rl-oss/webdev", "web", n_tasks=len(oss["webdev"]), task_count=2093, bank=list_bank(oss["webdev"]),
+        grader_id=g_web, harness="webdev agent (Claude-Code tool set, 64-step limit)",
+        tools=["Bash", "Read", "Write", "Edit", "Grep", "Glob"], reward_kind="scalar",
+        sandbox={"backend": "Kubernetes pod", "workdir": "/workspace", "network": "egress proxy to CDNs", "output": "dist/"},
+        description="Website-building tasks from the released webdev config (data_source blackbox/webdev, all category 'website'): "
+                    "the agent builds a static site to the brief and delivers it to dist/, which the vision grader renders. 2,000 "
+                    "of the 2,093 tasks are stored with their real ids.",
+        version="MiMo-V2.6-RL-oss", source=DS_URL, provenance="mixed", difficulty=(0.0, 1.6), created_at=at("2026-08-20 00:00"),
+        profile={"turns": (25, 64), "tokens_out": 40000, "tokens_in": 3000, "seconds": 1500, "infra_rate": 0.01,
+                 "timeout_rate": 0.01, "max_tokens": 245760, "judge": True},
+        checks=[{"name": "Runtime gate", "status": "pass", "source": VERL,
+                 "detail": "A no-LLM gate checks that the delivered dist/ builds and renders before any judging."},
+                {"name": "Whole groups kept", "status": "pass", "source": VERL_FILE + "scripts/design/webdev.sh",
+                 "detail": "The reward is relative within a group, so filter_groups is off; rollouts lost to infrastructure are "
+                           "dropped from the GRPO group (DROP_INFRA_FROM_GROUP=1) rather than scored 0."}])
+    oss_env["music"] = kit.environment(
+        w, pid, "oss|music", "rl-oss/music", "other", n_tasks=len(oss["music"]), task_count=1000,
+        bank=list_bank([(m[0], m[5]) for m in oss["music"]]), grader_id=g_music, harness="single turn (ABC notation out)",
+        tools=[], reward_kind="scalar", sandbox={"backend": "none (single turn)", "scorer": "CPU, 16 workers, abc2midi"},
+        description="Symbolic composition tasks from the released music config: write a complete piece in ABC notation to a brief "
+                    "(key, tempo, meter, length, instrumentation, texture, mood). 504 prompts in Chinese and 496 in English, 79 style "
+                    "tags, meters 4/4 (746), 3/4 (147), 2/4 (57), 6/8 (38) and 7/8 (12), 1–6 voices. All 1,000 tasks are stored with "
+                    "their source ids.",
+        version="MiMo-V2.6-RL-oss", source=DS_URL, provenance="mixed", difficulty=(0.0, 1.4), created_at=at("2026-08-20 00:00"),
+        profile={"turns": (1, 1), "tokens_out": 6000, "tokens_in": 300, "seconds": 120, "infra_rate": 0.002,
+                 "timeout_rate": 0.0, "max_tokens": 100000, "judge": True},
+        checks=[{"name": "Scorer dependency and rejects", "status": "pass", "source": VERL,
+                 "detail": "A missing abc2midi binary stops the run instead of scoring every rollout 0; answers that cannot be "
+                           "rendered, or have 10 or more bar errors, blank output or channel conflicts, score 0."}])
+    mus_meta = {m[0]: m for m in oss["music"]}
+    for t in oss_env["music"].tasks:
+        row = mus_meta.get(t.name)
+        if row:
+            t.tags = [x for x in (row[1], row[2], row[3], f"{row[4]} voices" if row[4] else None) if x]
+    oss_env["cyber"] = kit.environment(
+        w, pid, "oss|cyber", "rl-oss/cyber", "cyber", n_tasks=0, task_count=1000, bank=list_bank([]), grader_id=g_cyber,
+        harness="ARVO agent (bash, read, write, edit; 300-step limit)", tools=["bash", "read", "write", "edit"], reward_kind="binary",
+        sandbox={"backend": "Kubernetes pod", "user": "restricted agent user; grading service in the pod"},
+        description="Vulnerability-reproduction tasks from the released cyber config (data_source arvo): 1,000 tasks over 176 "
+                    "open-source projects built on OSS-Fuzz-derived targets (AddressSanitizer 683, MemorySanitizer 235, "
+                    "UndefinedBehaviorSanitizer 82). The demo keeps this domain to counts and the grader: no tasks, rollouts or "
+                    "transcripts are stored, and there is no cyber run here.",
+        version="MiMo-V2.6-RL-oss", source=DS_URL, provenance="published", created_at=at("2026-08-20 00:00"),
+        checks=[{"name": "Deterministic verification", "status": "pass", "source": TR,
+                 "detail": "Grading shares one source of truth with the task description and uses rule-based matching, so it is "
+                           "deterministic, reproducible and cheap; no LLM judge."}])
+
+    # the flagship runs -------------------------------------------------------------
+    notices = load("notices.json.gz")
+    benches_pub = load("benchmarks.json.gz")
+    harness_names = sorted({t.split("/")[2] for t in pub["pro"]["series"] if t.startswith("train/harness/")})
+    run_ids = {}
+    router = ("The MoE router is frozen for the whole run to keep expert loads stable (report §5.1). In an otherwise identical "
+              "Pro run with a trainable router, load at decoder layer 9 collapsed over the first 20 steps: coefficient of variation "
+              "0.78 → 2.0, peak load 6× → 16× the mean, cold experts 0.5% → 22%. Restoring the step-20 router to its pre-RL weights "
+              "restored balance with unchanged benchmark scores, so the collapse came from router drift (report §5.4, Fig. 11).")
+    notice_kind = {
+        "n-5ef2b1": ("notice", None, "Offline results backfilled",
+                     "Offline evaluation runs behind training (about 5–8 steps) and its scores are posted by hand as they finish."),
+        "n-92030c": ("incident", 11, "Restart: VRAM issue on one node",
+                     "A GPU memory (VRAM) problem on one node forced a restart. The report says most infrastructure interruptions "
+                     "in both runs were GPU-memory double-bit errors (DBEs)."),
+        "n-b60f90": ("incident", 16, "Undetected infrastructure error; back to step 15",
+                     "For about three hours, failed rollouts on one data source were not flagged as infrastructure errors, so they "
+                     "were scored as ordinary failures. The run went back to its step-15 checkpoint and re-ran steps 16 and 17 "
+                     "(avg@n 0.6025 → 0.5950 and 0.5857 → 0.6013); the logged step-17 infrastructure-error rate, 3.0%, is the "
+                     "run's highest."),
+        "n-15ac72": ("incident", 15, "Grader unreachable; run restarted",
+                     "After step 14 the trainer could not reach the grader service over the network, so rewards could not be "
+                     "computed and the run was restarted (report §5.5)."),
+        "n-4e29eb": ("incident", 17, "GPU out of memory at step 17 (MoE load imbalance)",
+                     "Within one micro-batch, one expert-parallel rank received more than 30× the mean token load although the "
+                     "full batch was balanced, and ran out of GPU memory. The team changed the parallelism to reduce activation "
+                     "memory (report §5.5)."),
+        "n-6b9c4a": ("data", 25, "Easy tasks filtered out",
+                     "Prompts the policy already solves on every attempt give GRPO no signal (every attempt gets the same "
+                     "reward), so they were dropped from the pool mid-run."),
+    }
+    for key in ("pro", "flash"):
+        label = f"mimo-v2.6-{key}"
+        run_id = rid("run", pid, key)
+        run_ids[key] = run_id
+        series, axis, status, events = pub[key]["series"], pub[key]["axis"], pub[key]["status"], pub[key]["events"]
+        steps, walls = axis["steps"], axis["walls"]
+        start, end = status["run"]["start"], status["run"]["end"]
+        totals = status["totals"]
+        cost = status["cost"]["so_far"]
+        rows = []
+        for tag, values in series.items():
+            if tag.startswith("train/passrate/avg_passrate/") and all(not v for v in values):
+                continue   # the dashboard reports 0 for sources whose pass rate it doesn't measure: leave them unmeasured
+            for step, v in zip(steps, values):
+                if v is None or (isinstance(v, float) and math.isnan(v)):
+                    continue
+                rows.append({"run_id": run_id, "tag": tag, "step": step, "value": v})
+        w.add_many("metrics", rows)
+        step_rows = []
+        prev_wall = start
+        for i, step in enumerate(steps):
+            get = lambda t: (series.get(t) or [None] * len(steps))[i]
+            measurable = get("dynsam/num_measurable") or 0
+            zero, one = get("dynsam/passrate/zero") or 0, get("dynsam/passrate/one") or 0
+            step_rows.append({
+                "run_id": run_id, "step": step, "phase": "train", "started_at": prev_wall, "ended_at": walls[i],
+                "prompts": int(get("dynsam/num_target") or 1568), "rollouts": int(get("train/verdicts/trained") or 0),
+                "rollouts_stored": 0, "reward_mean": get("critic/rewards/mean"), "pass_rate": get("dynsam/avg@n"),
+                "tokens": int(get("perf/total_num_tokens") or 0), "groups_all_pass": int(round(one * measurable)),
+                "groups_all_fail": int(round(zero * measurable)),
+                "groups_mixed": int(round((1 - zero - one) * measurable)),
+                "infra_errors": int(round((get("dynsam/infra_error/seq_rate") or 0) * (get("train/verdicts/trained") or 0))),
+                "truncated": int(round((get("ctx_total_length/clip_ratio") or 0) * (get("train/verdicts/trained") or 0))),
+            })
+            prev_wall = walls[i]
+        # rollouts sampled to match the published per-source pass rates and harness shares
+        r = rng("mimo-rollouts", key)
+        roll = []
+        env_names = [n for n in envs if f"train/passrate/avg_passrate/{n}" in series]
+        for i, step in enumerate(steps):
+            get = lambda t: (series.get(t) or [None] * len(steps))[i]
+            live_envs, weights = [], []
+            for n in env_names:
+                acc = get(f"dynsam/{n}/num_accepted/step")
+                if acc:
+                    live_envs.append(envs[n])
+                    weights.append(acc)
+            hw = [(h, get(f"train/harness/{h}/training/rollouts") or 0) for h in harness_names]
+            hw = [(h, x) for h, x in hw if x]
+            stored = 0
+            for g in range(6):
+                env = weighted_choice(r, live_envs, weights)
+                p = get(f"train/passrate/avg_passrate/{env.name}")
+                p = 0.5 if p is None else min(0.99, max(0.01, p))
+                if env.judge:  # scalar rewards: the published pass rate is the mean reward
+                    p = judge_target(p)
+                skill = solve_skill([t.difficulty for t in env.tasks[:200]], p)
+                task = env.tasks[r.randrange(len(env.tasks))]
+                atts = [attempt(r, env, task, skill) for _ in range(16)]
+                advs = group_advantages([a["reward"] for a in atts])
+                harness = (weighted_choice(r, [h for h, _ in hw], [x for _, x in hw])
+                           if (hw and env.domain in ("code", "agentic", "cyber", "web")) else "single-turn")
+                for j, a in enumerate(atts):
+                    roll.append({"id": rid("roll", run_id, step, g, j), "run_id": run_id, "eval_id": None, "step": step,
+                                 "phase": "train", "group_id": rid("grp", run_id, step, g), "sample": j, "task_id": task.id,
+                                 "env_id": env.id, "harness": harness, "model_id": models[key][0], "reward": a["reward"],
+                                 "advantage": advs[j], "scores": None, "outcome": a["outcome"], "stop_reason": a["stop_reason"],
+                                 "turns": a["turns"], "tool_calls": a["tool_calls"], "tokens_in": a["tokens_in"],
+                                 "tokens_out": a["tokens_out"], "tokens_cached": a["tokens_cached"],
+                                 "duration_s": a["duration_s"], "timing": a["timing"], "staleness": r.choice([0, 0, 0, 1]),
+                                 "flags": None, "seed": stable_seed(run_id, step, g, j),
+                                 "trained": 0 if a["reward"] is None else 1})
+                    stored += 1
+            step_rows[i]["rollouts_stored"] = stored
+        w.add_many("run_steps", step_rows)
+        w.add_many("rollouts", roll)
+        # events: start, router, restarts, notices with plain explanations, report incidents, checkpoints, end
+        ev = [{"run_id": run_id, "t": start, "step": 0, "kind": "start", "severity": "info", "title": "Run started",
+               "body": f"{totals['prompts_per_step']:,} prompts per step; {totals['trained_step']:,} trajectories trained per step."},
+              {"run_id": run_id, "t": start + 1, "step": 0, "kind": "config", "severity": "info", "title": "Router frozen for RL",
+               "body": router}]
+        for e in events:
+            if e["kind"] == "restart":
+                ev.append({"run_id": run_id, "t": e["t"], "step": None, "kind": "restart", "severity": "warning",
+                           "title": "Run restarted", "body": ""})
+        for n in notices:
+            text = n["text"]
+            mentions = [k for k in ("pro", "flash") if k in text]
+            if mentions and key not in mentions:
+                continue
+            if not (start - 86400 < n["t"] < end + 86400 * 3):
+                continue
+            kind, step, title, why = notice_kind.get(n.get("id"), ("notice", None, "Notice from the MiMo team", ""))
+            ev.append({"run_id": run_id, "t": n["t"], "step": step, "kind": kind,
+                       "severity": {"incident": "warning", "data": "info", "notice": "info"}[kind], "title": title,
+                       "body": f"Notice: “{text}” {why}".strip()})
+            if n.get("id") == "n-15ac72":
+                ev.append({"run_id": run_id, "t": n["t"] + 1, "step": 15, "kind": "data", "severity": "info",
+                           "title": "Cyber source removed from the pro run",
+                           "body": "The same notice says the team removed the cyber dataset because they 'observed some bad "
+                                   "patterns in the rollout logs'. cyber/dataset-9aui has no accepted prompts in the pro run "
+                                   "after step 14; the flash run kept training on it for all 30 steps."})
+        if key == "flash":
+            ev.append({"run_id": run_id, "t": walls[14], "step": 16, "kind": "incident", "severity": "warning",
+                       "title": "Kubernetes failure in the cyber task cluster",
+                       "body": "Report §5.5: 'Flash was also restarted after a "
+                               "Kubernetes failure caused pods in the Cyber-task cluster to crash between steps 15 and 16.' The "
+                               "report gives only the step range; the dashboard's restart from step 15 falls in the same window."})
+        ev.append({"run_id": run_id, "t": end, "step": steps[-1], "kind": "end", "severity": "info",
+                   "title": "Run completed", "body": f"{len(steps)} steps, {totals['restarts']} restarts."})
+        for s in (10, 20, 30):
+            ev.append({"run_id": run_id, "t": walls[s - 1], "step": s, "kind": "checkpoint", "severity": "info",
+                       "title": f"Checkpoint step {s}", "body": ""})
+            w.add("checkpoints", {"id": rid("ckpt", run_id, s), "run_id": run_id, "step": s,
+                                  "model_id": models[key][1] if s == 30 else None,
+                                  "path": f"mimo://{label}/global_step_{s}", "size_gb": None,
+                                  "created_at": walls[s - 1], "kept": 1})
+        w.add_many("run_events", ev)
+        lr = (series.get("actor/lr") or [None])[-1]
+        hp = {"prompts_per_step": totals["prompts_per_step"], "group_size": 16,
+              "trajectories_trained_per_step": totals["trained_step"], "lr": lr, "optimizer": "Muown",
+              "weight_decay": 0, "lr_warmup": "none", "grad_clip": 1.0, "loss_agg_mode": "prompt-mean",
+              "norm_adv_by_std_in_grpo": False, "partial_rollout_staleness": 4,
+              "clip_bounds_init": "[0.2, 5.0] for positive and negative advantages, tuned online from entropy",
+              "clip_low_logged": 0.2, "clip_high_logged": 0.27, "router": "frozen", "rollout_experts": "MXFP4",
+              "max_context_tokens": 1048576, "dynamic_sampling": True, "partial_rollouts": True,
+              "task_mix": "coding 68%, aesthetic design 13%, general tool use 12%, cyber 4%, context following 3%"}
+        config = "\n".join([
+            "# Published facts about this run (report §5.1 and the RL dashboard; the full config is not public)",
+            f"run: {label}", "algorithm: GRPO, fully asynchronous with partial rollouts (staleness 4)",
+            f"prompts_per_step: {totals['prompts_per_step']}", "group_size: 16",
+            f"trajectories_trained_per_step: {totals['trained_step']}",
+            "optimizer: Muown  # Muon part: momentum 0.95 (Nesterov), 10 Newton-Schulz iterations, update scale 0.5; Adam part: betas 0.95/0.95, eps 1e-8",
+            f"learning_rate: {lr}   # constant, no warmup, no weight decay, grad clip 1.0",
+            "loss_agg_mode: prompt-mean", "norm_adv_by_std_in_grpo: false",
+            "clip_bounds: four decoupled bounds initialized to [0.2, 5.0], tuned online from policy entropy  # dashboard logs clip_low 0.20, clip_high 0.27",
+            "router: frozen", "rollout: MXFP4 experts; R3 routing replay, top-p candidate-set replay, QDQ after each update",
+            "dynamic_sampling: true   # all-pass and all-fail groups filtered",
+            "partial_rollouts: true   # long trajectories resume across steps (staleness logged)",
+            "task_mix: {coding: 0.68, aesthetic_design: 0.13, general_tool_use: 0.12, cyber: 0.04, context_following: 0.03}",
+            f"data_sources: [{', '.join(sorted(env_names))}]"])
+        w.add("runs", {
+            "id": run_id, "project_id": pid, "name": label, "kind": "rl", "stage": "RL", "algorithm": "GRPO",
+            "framework": "verl", "status": "completed", "status_reason": "", "base_model_id": models[key][0],
+            "output_model_id": models[key][1], "started_at": start, "ended_at": end, "updated_at": end,
+            "steps_planned": 30, "steps_done": steps[-1], "primary_metric": "dynsam/avg@n", "gpu": None, "gpus": None,
+            "cost_usd": round(cost, 2), "cost_rate": round(status["cost"]["rate_per_s"] * 3600, 2), "owner": "MiMo team",
+            "tags": ["agentic", "published"], "code_ref": "XiaomiMiMo/verl@mimo-oss", "config": config,
+            "config_format": "yaml", "hyperparams": hp, "parent_run_id": None, "group_name": "mimo-v2.6",
+            "description": f"The 30-step mixed RL run of {MODEL_SPEC[key]['name']} ('You Only RL Once'): code, general-agent, "
+                           "design, context-following and cyber tasks mixed in one batch across 23 harnesses, streamed live from "
+                           "the trainer's logs. Metrics, step times, restarts, notices, cost and in-training benchmark scores are "
+                           "the published ones; rollouts are simulated to match the published per-source pass rates.",
+            "source": DASHBOARD, "provenance": "mixed"})
+        for n in env_names:
+            acc = [x for x in (series.get(f"dynsam/{n}/num_accepted/step") or []) if x]
+            w.add("run_inputs", {"run_id": run_id, "kind": "environment", "ref_id": envs[n].id,
+                                 "weight": round(sum(acc) / max(1, len(acc)), 1)})
+
+    # task pass rates for the base and the final policy (from the first and last published rates)
+    for name, env in envs.items():
+        p0 = p1 = None
+        for key in ("pro", "flash"):
+            vals = [v for v in (pub[key]["series"].get(f"train/passrate/avg_passrate/{name}") or []) if v is not None]
+            if vals and any(vals):
+                p0 = vals[0] if p0 is None else p0
+                p1 = vals[-1] if p1 is None else p1
+        if p0 is None:
+            d = [t.difficulty for t in env.tasks]
+            rows = list(task_rows(env, solve_skill(d, 0.5), None, attempts=16))
+            for r in rows:
+                r["base_pass"] = r["latest_pass"] = None   # pass rate not published for this source
+            w.add_many("tasks", rows)
+            continue
+        p0, p1 = min(0.99, max(0.01, p0)), min(0.99, max(0.01, p1))
+        if env.judge:
+            p0, p1 = judge_target(p0), judge_target(p1)
+        d = [t.difficulty for t in env.tasks]
+        w.add_many("tasks", list(task_rows(env, solve_skill(d, p0), solve_skill(d, p1), attempts=16)))
+
+    # metric definitions for the dashboard's tags
+    tags = set(pub["pro"]["series"]) | set(pub["flash"]["series"])
+    defs = []
+    fmt_rules = [(p, f) for p, f in dash["formats"]]
+    for tag in sorted(tags):
+        fmt = next((f for p, f in fmt_rules if re.search(p, tag)), "num3")
+        signal = SIGNAL_OF.get(tag)
+        m = re.fullmatch(r"train/passrate/avg_passrate/([^/]+/[^/]+)", tag)
+        if m and m.group(1) in envs:
+            signal = f"env_pass_rate@{envs[m.group(1)].id}"
+        m = re.fullmatch(r"dynsam/([^/]+/[^/]+)/num_accepted/step", tag)
+        if m and m.group(1) in envs:
+            signal = f"env_accepted@{envs[m.group(1)].id}"
+        label = sig.SIGNALS[signal][0] if signal in sig.SIGNALS else tag
+        better = sig.SIGNALS[signal][3] if signal in sig.SIGNALS else "none"
+        grp = sig.SIGNALS[signal][4] if signal in sig.SIGNALS else tag.split("/")[0]
+        defs.append({"project_id": pid, "tag": tag, "label": label, "description": describe(tag, official, explainers),
+                     "unit": "", "format": {"int": "int", "pct": "pct", "ratio": "pct", "duration": "duration",
+                                            "compact": "compact", "sci": "sci", "gb": "num1"}.get(fmt, "num3"),
+                     "grp": grp, "better": better, "pinned": 1 if tag in dash["pins"] else 0, "signal": signal})
+    w.add_many("metric_defs", defs)
+
+    # the open 9B baseline: SFT, then per-domain GRPO with the released recipes --------------
+    def fix_run(run_key, prefix, final_model=None, final_step=None, end=None):
+        run = rid("run", pid, run_key)
+        w.conn.execute("UPDATE runs SET cost_usd=NULL, cost_rate=NULL WHERE id=?", (run,))
+        have_final = w.conn.execute("SELECT 1 FROM checkpoints WHERE run_id=? AND step=?", (run, final_step)).fetchone()
+        if final_step and end and not have_final:  # verl also saves at the last step
+            w.add("checkpoints", {"id": rid("ckpt", run, final_step), "run_id": run, "step": final_step, "model_id": None,
+                                  "path": "", "size_gb": None, "created_at": end, "kept": 1})
+            w.add("run_events", {"run_id": run, "t": end - 1, "step": final_step, "kind": "checkpoint", "severity": "info",
+                                 "title": f"Checkpoint step {final_step}", "body": ""})
+        for (ck_id, step) in w.conn.execute("SELECT id, step FROM checkpoints WHERE run_id=?", (run,)).fetchall():
+            w.conn.execute("UPDATE checkpoints SET path=?, model_id=? WHERE id=?",
+                           (f"{prefix}/global_step_{step}", final_model if step == final_step else None, ck_id))
+        return run
+
+    sft_steps = 2000
+    sft_hp = {"lr": None, "schedule": None, "warmup_ratio": None, "global_batch": None, "max_seq_len": None, "steps": None,
+              "total_tokens": 77_400_000_000, "loss_tokens": 27_200_000_000,
+              "note": "SFT hyperparameters are not published; the step count, step time and curves are simulation placeholders."}
+    sft_cfg = "\n".join([
+        "# MiMo-V2.6-Distill-Qwen-9B SFT (report §7.1, Table 4). Hyperparameters are not published.",
+        "base_model: Qwen/Qwen3.5-9B", "data: MiMo-generated mixture, 77.4B tokens (27.2B loss-bearing)",
+        "mixture: {code: 23.2B, cyber: 11.0B, general: 22.0B, visual: 21.2B}",
+        "learning_rate: null        # not published", "global_batch: null         # not published",
+        "sequence_length: null      # not published (the model's context is 262,144)", "epochs: null               # not published",
+        "# Simulation placeholders: 2,000 steps of 38.7M tokens, i.e. one pass over the mixture; loss and timing curves are illustrative."])
+    sft = sft_run(w, project_id=pid, key="distill-sft", name="distill-qwen-9b-sft", framework="megatron_sft",
+                  datasets=[(ds_mix, 1.0)], base_model_id=qwen, output_model_id=None, steps=sft_steps, start=sft_start,
+                  step_seconds=110.0, loss=(0.95, 0.42), lr=1e-5, warmup=0.03, schedule="cosine", global_batch=None,
+                  seq_len=262144, tokens_per_step=77.4e9 / sft_steps, gpu=None, gpus=None, cost_rate=0.0, owner="MiMo team",
+                  tags=["distillation", "open-baseline", "simulated"], config=sft_cfg, hyperparams=sft_hp, stage="SFT",
+                  description="SFT of Qwen3.5-9B on MiMo-generated data spanning coding, general-agent, visual and cyber tasks, "
+                              "which produced the released MiMo-V2.6-Distill-Qwen-9B (report §7.1). The data mixture and the "
+                              "start and end scores (Table 6) are published; hyperparameters are not, so the step count, dates and "
+                              "curves here are simulated.",
+                  source=DISTILL_CARD, provenance="simulated", group_name="distill-qwen-9b", ckpt_every=500)
+    sft_id = sft["run_id"]
+    # the learning rate and a validation split are not published: drop those placeholder curves
+    for signal in ("lr", "val_loss"):
+        w.conn.execute("DELETE FROM metrics WHERE run_id=? AND tag=?", (sft_id, sig.FRAMEWORK_TAGS["megatron_sft"][signal]))
+    w.conn.execute("UPDATE run_events SET body=? WHERE run_id=? AND kind='start'",
+                   ("SFT of Qwen3.5-9B on the MiMo-generated mixture (77.4B tokens, 27.2B loss-bearing). Batch size, sequence "
+                    "length and learning rate are not published.", sft_id))
+    sft_end = sft["end"]
+    distill = model("distill-9b", "MiMo-V2.6-Distill-Qwen-9B", hf_repo="XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B",
+                    arch="Dense Qwen3.5: 32 layers with full attention every 4th (linear attention otherwise), hidden 4096, 16 heads / 4 KV, head dim 256, 1 MTP layer",
+                    params_total=9.41, params_active=9.41, context_len=262144, parent_id=qwen, run_key="distill-sft",
+                    step=sft_steps, stage="SFT", created_at=sft_end, status="released", source=DISTILL_CARD,
+                    notes="SFT of Qwen3.5-9B on 77.4B tokens of MiMo-generated data (27.2B loss-bearing) across code, cyber, general "
+                          "and visual tasks; 9,409,813,744 parameters in BF16. Released under MIT on Sept 21, 2026 'as a starting "
+                          "point for open research in agentic RL'; it is the common start of the per-domain GRPO runs.")
+    w.conn.execute("UPDATE runs SET output_model_id=? WHERE id=?", (distill, sft_id))
+    fix_run("distill-sft", "distill-qwen-9b-sft", distill, sft_steps)
+
+    def code_cfg(harness_lines):
+        return "\n".join([
+            "# Simulated reproduction of the open code recipe", f"# {VERL_FILE}scripts/code/train.sh",
+            f"# {VERL_FILE}recipes/code/config/train.yaml",
+            "MODEL_PATH: XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B", "TRAIN_DATA: MiMo-V2.6-RL-oss code.parquet   # 2,698 tasks",
+            *harness_lines,
+            "N: 16                        # attempts per prompt", "TRAIN_BATCH_SIZE: 64         # prompts per step",
+            "PPO_MINI_BATCH_SIZE: 64      # must equal the batch for prompt-mean", "TOTAL_STEPS: 200", "TOTAL_EPOCHS: 10",
+            "MAXLEN: 262144               # prompt 16,384 + response 245,760", "PROMPT_LENGTH: 16384",
+            "actor.optim.lr: 1.0e-6", "actor.optim.weight_decay: 0.01", "actor.optim.lr_decay_style: constant",
+            "actor.clip_ratio_low: 0.2", "actor.clip_ratio_high: 0.2", "actor.clip_ratio_c: 3.0",
+            "LOSS_AGG_MODE: prompt-mean", "NORM_ADV_BY_STD_IN_GRPO: false", "ENTROPY_COEFF: 0", "use_kl_loss: false",
+            "ROLLOUT_TEMPERATURE: 1.0", "ROLLOUT_TOP_P: 0.95", "ROLLOUT_TOP_K: 20",
+            "FILTER_GROUPS_ENABLE: true   # metric: reward", "trainer.v1.trainer_mode: colocate_async",
+            "MAX_OFF_POLICY_THRESHOLD: 2  # staleness; older samples dropped",
+            "TRAIN_NNODES: 8", "TRAIN_NGPUS_PER_NODE: 8", "ACTOR_TP: 8", "ACTOR_PP: 1", "ACTOR_CP: 1", "ROLLOUT_TP: 2",
+            "kv_cache_dtype: fp8_e4m3", "MAX_CONCURRENT_SESSIONS: 2048   # one Kubernetes pod per session",
+            "TRAJECTORY_TIMEOUT: 4800", "SAVE_FREQ: 5"])
+
+    code_hp = {"group_size": 16, "prompts_per_step": 64, "ppo_mini_batch_size": 64, "total_training_steps": 200,
+               "total_epochs": 10, "lr": 1e-6, "weight_decay": 0.01, "lr_schedule": "constant", "max_prompt_len": 16384,
+               "max_response_len": 245760, "max_model_len": 262144, "clip_ratio_low": 0.2, "clip_ratio_high": 0.2,
+               "clip_ratio_c": 3.0, "loss_agg_mode": "prompt-mean", "norm_adv_by_std_in_grpo": False, "entropy_coeff": 0,
+               "kl": "off", "temperature": 1.0, "top_p": 0.95, "top_k": 20, "filter_groups": "on (metric: reward)",
+               "trainer_mode": "colocate_async", "max_off_policy_threshold": 2, "gpus": "8 nodes × 8",
+               "actor_parallelism": "Megatron TP 8, PP 1, CP 1", "rollout_tp": 2, "save_freq": 5}
+    specs = [
+        {"key": "9b-code", "name": "distill-qwen-9b-code-grpo", "env": "code", "out": "distill-9b|code-rl",
+         "out_name": "Distill-Qwen-9B + code GRPO (single harness)", "start": at("2026-08-28 06:00"), "steps": 200, "step_s": 2400,
+         "n": 16, "prompts": 64, "store": 2, "gpus": 64, "lr": 1e-6, "async": True, "norm": False, "filter": True, "save": 5,
+         "target": (0.516, 0.599), "anchor": "MiMo Code Bench (mini)",
+         "hp": dict(code_hp, harness="one mini-harness (Table 6 code rows use single-harness RL; the report does not name it)"),
+         "config": code_cfg(["MIMOAGENT_HARNESS_SPEC: a one-entry spec   # single-harness RL for Table 6; the harness is not named"]),
+         "source": VERL_FILE + "scripts/code/train.sh", "harness": "one mini-harness (not named)",
+         "what": "the open code recipe (scripts/code/train.sh) run with a single mini-harness, as used for the Table 6 code rows"},
+        {"key": "9b-code-mh", "name": "distill-qwen-9b-code-grpo-4harness", "env": "code", "out": "distill-9b|code-mh-rl",
+         "out_name": "Distill-Qwen-9B + multi-harness code GRPO", "start": at("2026-09-03 00:00"), "steps": 200, "step_s": 2700,
+         "n": 16, "prompts": 64, "store": 2, "gpus": 64, "lr": 1e-6, "async": True, "norm": False, "filter": True, "save": 5,
+         "target": (0.531, 0.590), "anchor": "MiMo Code Bench (mini), mean over the seven Table 7 harnesses",
+         "hp": dict(code_hp, harness="mix-four-whitebox: mini-mimocode, mini-bash, mini-claude-code, mini-codex (step-hash routing, seed 20260911)"),
+         "config": code_cfg(["MIMOAGENT_HARNESS_SPEC: config/agent/code/mix-four-whitebox.yaml   # mini-mimocode, mini-bash, mini-claude-code, mini-codex",
+                             "MIXED_HARNESS_MODE: step-hash   # one harness per prompt and round, from a hash of (seed, round, instance id)",
+                             "MIXED_HARNESS_SEED: 20260911", "EXP_NAME: four-whitebox"]),
+         "source": VERL_FILE + "scripts/code/train.sh", "harness": "mixed",
+         "what": "the open code recipe's default four-harness mix (scripts/code/train.sh, config/agent/code/mix-four-whitebox.yaml), "
+                 "the separate multi-harness experiment of Table 7"},
+        {"key": "9b-general", "name": "distill-qwen-9b-general-grpo", "env": "general", "out": "distill-9b|general-rl",
+         "out_name": "Distill-Qwen-9B + general GRPO", "start": at("2026-08-28 08:00"), "steps": 75, "step_s": 1500,
+         "n": 8, "prompts": 64, "store": 3, "gpus": 32, "lr": 2e-6, "async": False, "norm": False, "filter": True, "save": 1,
+         "target": (0.622, 0.706), "anchor": "MiMo General Bench (mini)",
+         "hp": {"group_size": 8, "prompts_per_step": 64, "ppo_mini_batch_size": 64, "total_epochs": 5,
+                "steps": "75 (5 epochs × 15 full batches of 64 from 989 tasks)", "lr": 2e-6, "max_prompt_len": 49152,
+                "max_response_len": 212992, "max_model_len": 262144, "clip_ratio": 0.2, "loss_agg_mode": "prompt-mean",
+                "norm_adv_by_std_in_grpo": False, "entropy_coeff": 0, "kl": "off", "temperature": 1.0, "top_p": 0.95,
+                "top_k": -1, "filter_groups": "on (metric: reward)", "trainer_mode": "sync",
+                "length_penalty": {"max_penalty": 0.1, "deadzone": 0.3, "anchor_quantile": 0.5, "pass_threshold": 0.5,
+                                   "penalty_exponent": 1.5, "min_pass_rate": 0.5},
+                "reward_binarize_threshold": 1.0, "invalid_reward_for_infra": -999,
+                "judge": "LLM rubric judge at GA_JUDGE_URL (the script's placeholder default is gpt-4o-mini)",
+                "gpus": "4 nodes × 8", "actor_tp": 8, "rollout_tp": 4, "trajectory_timeout_s": 1200, "save_freq": 1},
+         "config": "\n".join([
+             "# Simulated reproduction of the open general recipe", f"# {VERL_FILE}scripts/general/general.sh",
+             f"# {VERL_FILE}recipes/general/config/general.yaml", "MODEL_PATH: XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B",
+             "TRAIN_DATA: MiMo-V2.6-RL-oss general/train.parquet   # 989 tasks", "ROLLOUT_N: 8", "TRAIN_BATCH_SIZE: 64",
+             "PPO_MINI_BATCH_SIZE: 64", "TOTAL_EPOCHS: 5", "MAXLEN: 262144", "PROMPT_LENGTH: 49152", "RESPONSE_LENGTH: 212992",
+             "ACTOR_LR: 2e-6", "actor.clip_ratio: 0.2", "loss_agg_mode: prompt-mean", "norm_adv_by_std_in_grpo: false",
+             "ROLLOUT_TEMPERATURE: 1.0", "ROLLOUT_TOP_P: 0.95", "ROLLOUT_TOP_K: -1", "FILTER_GROUPS_ENABLE: true",
+             "LENGTH_PENALTY_ENABLE: true   # max_penalty 0.1, deadzone 0.3, anchor_quantile 0.5",
+             "REWARD_BINARIZE: true", "REWARD_BINARIZE_THRESHOLD: 1.0", "INVALID_REWARD_FOR_INFRA: true", "INVALID_REWARD_VALUE: -999",
+             "GA_JUDGE_MODEL: not stated for the report's run   # script placeholder default: gpt-4o-mini",
+             "trainer.v1.trainer_mode: sync", "NNODES: 4", "NGPUS_PER_NODE: 8", "ACTOR_TP: 8", "ROLLOUT_TP: 4",
+             "TRAJECTORY_TIMEOUT: 1200", "save_freq: 1"]),
+         "source": VERL_FILE + "scripts/general/general.sh", "harness": None,
+         "what": "the open general recipe (scripts/general/general.sh)"},
+        {"key": "9b-webdev", "name": "distill-qwen-9b-webdev-grpo", "env": "webdev", "out": "distill-9b|webdev-rl",
+         "out_name": "Distill-Qwen-9B + webdev GRPO", "start": at("2026-08-29 00:00"), "steps": 65, "step_s": 2100,
+         "n": 8, "prompts": 32, "store": 3, "gpus": 64, "lr": 1e-6, "async": True, "norm": True, "filter": False, "save": 10,
+         "target": (judge_target(0.56), judge_target(0.62)), "anchor": "the recipe's step-1 reward of 0.56 (the end value is simulated)",
+         "hp": {"group_size": 8, "prompts_per_step": 32, "ppo_mini_batch_size": 32, "total_epochs": 1,
+                "steps": "65 (2,093 tasks in full batches of 32)", "lr": 1e-6, "max_prompt_len": 16384,
+                "max_response_len": 245760, "max_model_len": 262144, "clip_ratio": 0.2, "loss_agg_mode": "prompt-mean",
+                "norm_adv_by_std_in_grpo": "not set (verl default: true)", "entropy_coeff": 0, "kl": "off",
+                "temperature": 0.6, "top_p": 0.95, "top_k": 20, "filter_groups": "off (the reward is relative within a group)",
+                "drop_infra_from_group": True, "trainer_mode": "colocate_async", "max_off_policy_threshold": 4,
+                "reward": "max(0, (pick_norm − query_deduct + 2) / 3)", "gpus": "8 nodes × 8", "rollout_tp": 4,
+                "save_freq": 10, "sampling_note": "A run with these sampling settings scored 0.56 at step 1; runs on verl's defaults sat at 0.26–0.36 (webdev.env.example)."},
+         "config": "\n".join([
+             "# Simulated reproduction of the open webdev recipe", f"# {VERL_FILE}scripts/design/webdev.sh",
+             f"# {VERL_FILE}recipes/design/config/webdev.yaml", "MODEL_PATH: XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B",
+             "TRAIN_DATA: MiMo-V2.6-RL-oss webdev.parquet   # 2,093 tasks", "N: 8", "TRAIN_BATCH_SIZE: 32",
+             "PPO_MINI_BATCH_SIZE: 32", "TOTAL_EPOCHS: 1", "MAXLEN: 262144", "PROMPT_LENGTH: 16384",
+             "actor.optim.lr: 1e-6", "actor.clip_ratio: 0.2", "loss_agg_mode: prompt-mean",
+             "ROLLOUT_TEMPERATURE: 0.6   # measured: 0.56 at step 1 vs 0.26-0.36 with verl's defaults", "ROLLOUT_TOP_P: 0.95",
+             "ROLLOUT_TOP_K: 20", "algorithm.filter_groups.enable: false   # group-relative reward needs the whole group",
+             "DROP_INFRA_FROM_GROUP: 1", "INVALID_REWARD_FOR_INFRA: false", "trainer.v1.trainer_mode: colocate_async",
+             "max_off_policy_threshold: 4", "TRAIN_NNODES: 8", "TRAIN_NGPUS_PER_NODE: 8", "ACTOR_TP: 8", "ROLLOUT_TP: 4",
+             "DESIGN_GRADER_URL: external vision grader service", "SAVE_FREQ: 10"]),
+         "source": VERL_FILE + "scripts/design/webdev.sh", "harness": None,
+         "what": "the open webdev recipe (scripts/design/webdev.sh)"},
+        {"key": "9b-music", "name": "distill-qwen-9b-music-grpo", "env": "music", "out": "distill-9b|music-rl",
+         "out_name": "Distill-Qwen-9B + music GRPO", "start": at("2026-08-30 00:00"), "steps": 124, "step_s": 700,
+         "n": 8, "prompts": 32, "store": 3, "gpus": 64, "lr": 1e-6, "async": True, "norm": True, "filter": False, "save": 10,
+         "target": (judge_target(0.457), judge_target(0.525)), "anchor": "the internal music benchmark (45.7 → 52.5 on the scorer's 0–100 scale)",
+         "hp": {"group_size": 8, "prompts_per_step": 32, "ppo_mini_batch_size": 32, "total_epochs": 4,
+                "steps": "124 (4 epochs × 31 full batches of 32 from 1,000 tasks)", "lr": 1e-6, "max_prompt_len": 16384,
+                "max_response_len": 100000, "max_model_len": 116384, "multi_turn": False, "clip_ratio": 0.2,
+                "loss_agg_mode": "not set (verl default)", "norm_adv_by_std_in_grpo": "not set (verl default: true)",
+                "entropy_coeff": 0, "kl": "off", "filter_groups": "off", "trainer_mode": "colocate_async",
+                "max_off_policy_threshold": 4, "reward_workers": 16, "gpus": "8 nodes × 8", "rollout_tp": 4,
+                "val_before_train": True, "test_freq": 10, "save_freq": 10},
+         "config": "\n".join([
+             "# Simulated reproduction of the open music recipe", f"# {VERL_FILE}scripts/design/music.sh",
+             f"# {VERL_FILE}recipes/design/config/music.yaml", "MODEL_PATH: XiaomiMiMo/MiMo-V2.6-Distill-Qwen-9B",
+             "TRAIN_DATA: MiMo-V2.6-RL-oss music.parquet   # 1,000 tasks", "N: 8", "TRAIN_BATCH_SIZE: 32",
+             "PPO_MINI_BATCH_SIZE: 32", "TOTAL_EPOCHS: 4", "MAXLEN: 116384", "PROMPT_LENGTH: 16384   # response 100,000",
+             "multi_turn: false", "actor.optim.lr: 1e-6", "actor.clip_ratio: 0.2", "algorithm.filter_groups.enable: false",
+             "reward: recipes.design.music.scorer.compute_score   # abc2midi render + human-likeness score",
+             "REWARD_NUM_WORKERS: 16", "trainer.v1.trainer_mode: colocate_async", "max_off_policy_threshold: 4",
+             "TRAIN_NNODES: 8", "TRAIN_NGPUS_PER_NODE: 8", "ACTOR_TP: 8", "ROLLOUT_TP: 4", "val_before_train: true",
+             "TEST_FREQ: 10", "SAVE_FREQ: 10"]),
+         "source": VERL_FILE + "scripts/design/music.sh", "harness": None,
+         "what": "the open music recipe (scripts/design/music.sh)"},
+    ]
+    rl9 = {}
+    for spec in specs:
+        env = oss_env[spec["env"]]
+        env.harness = spec["harness"] or env.harness
+        out_id = rid("model", pid, spec["out"])
+        res = rl_run(w, project_id=pid, key=spec["key"], name=spec["name"], framework="verl", envs=[(env, spec["prompts"])],
+                     base_model_id=distill, output_model_id=out_id, steps=spec["steps"], group_size=spec["n"],
+                     prompts_per_step=spec["prompts"], sample_groups=spec["prompts"], store_groups=spec["store"],
+                     start=spec["start"], step_seconds=float(spec["step_s"]), env_targets={env.id: spec["target"]},
+                     algorithm="GRPO", hyperparams=spec["hp"], config=spec["config"], gpu=None, gpus=spec["gpus"],
+                     cost_rate=0.0, owner="MiMo team", tags=["open-recipe", "simulated", spec["env"]],
+                     code_ref="XiaomiMiMo/verl@mimo-oss", stage="RL",
+                     description=f"Simulated reproduction of {spec['what']}: GRPO from MiMo-V2.6-Distill-Qwen-9B on the released "
+                                 f"environments (report §7.2). Hyperparameters are the script defaults and the start and end evals are "
+                                 f"the published scores; per-step metrics, rollouts, dates and step times are simulated, with the "
+                                 f"training pass rate anchored on {spec['anchor']}.",
+                     source=spec["source"], provenance="simulated", async_rl=spec["async"], normalize_adv=spec["norm"],
+                     dynamic_sampling=spec["filter"], lr=spec["lr"], ckpt_every=spec["save"], group_name="distill-qwen-9b")
+        model(spec["out"], spec["out_name"], arch="Dense Qwen3.5", params_total=9.41, params_active=9.41, context_len=262144,
+              parent_id=distill, run_key=spec["key"], step=spec["steps"], stage="RL", created_at=res["end"],
+              status="not released", source=TR,
+              notes="Checkpoint of the report's domain-specific GRPO experiment on the 9B (Tables 6 and 7); not released. The run "
+                    "that produced it here is a simulated reproduction of the open recipe.")
+        fix_run(spec["key"], spec["name"], out_id, spec["steps"], res["end"])
+        rl9[spec["env"] if spec["key"] != "9b-code-mh" else "code-mh"] = (res, spec)
+    # step-hash harness routing for the four-harness run: one harness per prompt and round
+    mh_run = rid("run", pid, "9b-code-mh")
+    names = {t.id: t.name for t in oss_env["code"].tasks}
+    arms = ["mini-mimocode", "mini-bash", "mini-claude-code", "mini-codex"]
+    for gid, step, task_id in w.conn.execute("SELECT DISTINCT group_id, step, task_id FROM rollouts WHERE run_id=?", (mh_run,)).fetchall():
+        digest = hashlib.sha256(f"20260911\0{step}\0{names.get(task_id, task_id)}".encode()).digest()
+        w.conn.execute("UPDATE rollouts SET harness=? WHERE group_id=?", (arms[int.from_bytes(digest[:8], "big") % 4], gid))
+    cyber_rl = model("distill-9b|cyber-rl", "Distill-Qwen-9B + cyber GRPO", arch="Dense Qwen3.5", params_total=9.41,
+                     params_active=9.41, context_len=262144, parent_id=distill, stage="RL", created_at=at("2026-09-05 00:00"),
+                     status="not released", source=VERL_FILE + "scripts/arvo/arvo.sh",
+                     notes="Checkpoint of the report's cyber GRPO experiment (Table 6: MiMo Cyber Bench (mini) 31.3 → 47.0), trained "
+                           "with the open ARVO recipe (16 attempts × 64 prompts, 300 steps, lr 1e-6, staleness 8). The run is not "
+                           "shown in this demo, which keeps cyber to counts and scores.")
+    # task pass rates on the released environments, from the SFT checkpoint to the latest run on each
+    for env_key, first_run, last_run, n in (("code", "code", "code-mh", 16), ("general", "general", "general", 8),
+                                            ("webdev", "webdev", "webdev", 8), ("music", "music", "music", 8)):
+        env = oss_env[env_key]
+        kit.write_tasks(w, env, base_skill=rl9[first_run][0]["facts"][0]["skills"][env.id],
+                        latest_skill=rl9[last_run][0]["skills"][env.id], attempts=n)
+
+    # metric definitions for the simulated runs' framework tags and per-environment breakdowns
+    kit.metric_defs(w, pid, "verl")
+    kit.metric_defs(w, pid, "megatron_sft")
+    have = {r_[0] for r_ in w.conn.execute("SELECT tag FROM metric_defs WHERE project_id=?", (pid,))}
+    w.add_many("metric_defs", [d for d in env_metric_defs(pid, [oss_env[k] for k in ("code", "general", "webdev", "music")])
+                               if d["tag"] not in have])
+
+    # benchmarks and evals -------------------------------------------------------------
+    B = {}
+
+    def bench(key, name, category, metric, n, k, desc, source, harness=None, version="", bank=None, difficulty=(0.0, 1.8)):
+        B[key] = benchmark(w, project_id=pid, key=key, name=name, version=version, category=category, metric=metric,
+                           harness=harness, n_tasks=n, k=k, description=desc, source=source, bank=bank, difficulty=difficulty)
+        B[key].store_tasks = True
+        return B[key]
+
+    def ev(key, model_id, value, *, started, source, ek, run_id=None, step=None, config=None, command="", duration=5400.0):
+        b = B[key]
+        if b.metric in ("elo", "index", "score"):
+            return eval_run(w, b, model_id=model_id, score=value, raw=True, run_id=run_id, step=step, started=started,
+                            duration=duration, source=source, provenance="published", key=ek, config=config, command=command)
+        s = pct(value)
+        eid = eval_run(w, b, model_id=model_id, score=s, run_id=run_id, step=step, started=started, duration=duration,
+                       source=source, provenance="mixed", key=ek, config=config, command=command)
+        # eval_run rounds to whole task-attempts; keep the published score exactly (per-task results stay within 1/(n·k))
+        w.conn.execute("UPDATE evals SET score=? WHERE id=?", (s, eid))
+        return eid
+
+    note3 = "Report Table 3. Attempts per task are not stated there; per-task results are simulated to match the score."
+    bench("deepswe", "DeepSWE v1.1", "Code agent", "avg@3", 500, 3,
+          "Long-horizon software engineering, held out from training (Huang et al., 2026). In-training scores (avg@3, "
+          "mini-swe-agent) were posted on the RL dashboard as the runs progressed; offline eval lags training by about 5–8 steps "
+          "and scores were backfilled by hand. config.total_tokens_k on those evals is the launch blog's total-token count "
+          "(thousands) at that step. Final scores from Table 3. Task count not published; 500 stored tasks is an assumption.",
+          DASHBOARD, harness="mini-swe-agent", version="v1.1", bank=banks.eval_bank("deepswe"), difficulty=(0.0, 1.9))
+    bench("inhouse-coding", "In-house Coding Bench", "Code agent", "avg@3", 400, 3,
+          "Xiaomi's in-house coding benchmark as posted on the RL dashboard (avg@3) during the runs. It may be the suite Table 3 "
+          "calls MiMo Code Bench, but the sources do not say so. Task count not published; 400 stored tasks is an assumption.",
+          DASHBOARD, bank=banks.eval_bank("inhouse-coding"), difficulty=(0.0, 1.9))
+    bench("automation", "AutomationBench v1.0.6", "General agent", "avg@3", 300, 3,
+          "Cross-application workflow orchestration through REST APIs in simulated SaaS environments, including API discovery "
+          "and business rules. In-training scores (avg@3) from the RL dashboard; final scores from Table 3. The report's Fig. 9 "
+          "and the launch blog plot this benchmark with different values at early steps (Pro steps 1–12, Flash steps 1–16; e.g. "
+          "Pro step 1 is 45.2 there and 46.2 here) and add Pro steps 25, 27, 28 and 30 (55.0 at step 30) and a step-0 value "
+          "(Pro 46.5, Flash 45.2); the dashboard's values are kept. Task count not published; 300 stored tasks is an assumption.",
+          DASHBOARD, version="v1.0.6", bank=banks.eval_bank("automation"), difficulty=(0.0, 1.9))
+    bench("mimo-visual-coding", "MiMo Visual Coding", "Visual agent", "avg@1", 200, 1,
+          "Xiaomi's in-house visual-coding benchmark spanning open-ended design and high-fidelity visual replication (WebDev, "
+          "Image2Code). In-training scores every 3 steps from the launch blog's RL-progress chart (the report's Fig. 9), with "
+          "config.total_tokens_k the chart's total-token count in thousands; final scores from Table 3. Metric and task count "
+          "not published; avg@1 and 200 tasks are assumptions.", BLOG_CURVES)
+    bench("programbench", "ProgramBench", "Code agent", "avg@1", 200, 1,
+          "Rebuild a program from its compiled binary and documentation so it reproduces the reference behavior (Yang et al., "
+          "2026a). " + note3 + " Task count not published; 200 is an assumption.", TR)
+    bench("mimo-code-bench", "MiMo Code Bench", "Code agent", "avg@1", 300, 1,
+          "Xiaomi's in-house evaluation of coding agents across a diverse range of coding tasks. " + note3 +
+          " Task count not published; 300 is an assumption.", TR)
+    bench("toolathlon-verified", "Toolathlon-Verified", "General agent", "avg@1", 108, 1,
+          "Long-horizon, multi-application workflows with diverse tools, including MCP servers (HKUST NLP, 2026). Table 3 "
+          "(attempts not stated) and Table 6 (avg@1). 108 tasks, the original Toolathlon size, is an assumption for the "
+          "verified split.", TR)
+    bench("gdpval-aa", "GDPval-AA 2.1", "General agent", "elo", 220, 1,
+          "Artificial Analysis's GDPval evaluation of professional deliverables on economically valuable tasks, reported as an "
+          "Elo rating (floor 1000). Table 3; MiMo-V2.6-Flash has no result. Only the rating is stored, with no per-task results; "
+          "220 tasks (GDPval's gold subset) is an assumption.", TR)
+    bench("agents-last-exam", "Agents' Last Exam", "General agent", "avg@1", 200, 1,
+          "Long-horizon, economically valuable professional tasks with verifiable outcomes (Sun et al., 2026). " + note3 +
+          " Task count not published; 200 is an assumption.", TR)
+    bench("terminal-bench-4", "Terminal Bench 4.0", "General agent", "avg@1", 100, 1,
+          "Complex tasks in terminal environments (Marten et al., 2026). " + note3 + " Harness, turn and context settings are "
+          "not given. Task count not published; 100 is an assumption.", TR, version="4.0")
+    bench("terminal-bench-2.1", "Terminal Bench 2.1", "General agent", "avg@1", 89, 1,
+          "Complex tasks in terminal environments (Merrill et al., 2026). Table 3 (settings not given) and Table 6 (avg@1); the "
+          "report does not say where Qwen3.5-9B's 27.0 comes from. 89 tasks, Terminal-Bench 2.0's size, is an assumption.", TR,
+          version="2.1")
+    bench("osworld-verified", "OSWorld-Verified", "General agent", "avg@1", 369, 1,
+          "Interactive computer use across real web and desktop applications. " + note3 + " No MiMo-V2.5-Pro result. 369 tasks, "
+          "OSWorld's size, is an assumption.", TR)
+    bench("jobbench", "JobBench", "General agent", "avg@1", 200, 1,
+          "Workplace workflows that domain experts rank as high priority for delegation to AI agents (Li et al., 2026b). Table 3 "
+          "(attempts not stated) and Table 6 (avg@1). Task count not published; 200 is an assumption.", TR)
+    bench("cybergym", "CyberGym", "Cybersecurity", "avg@1", 1000, 1,
+          "Reproducing real-world vulnerabilities (Wang et al., 2025); the report corrected flawed evaluation environments with "
+          "its §4.2.4 method. " + note3 + " No frontier-model results. CyberGym's paper lists 1,507 instances and the corrected "
+          "count is not stated, so 1,000 stored tasks is an assumption. Task ids are neutral; no task content is stored.", TR)
+    bench("mimo-cyber-bench", "MiMo Cyber Bench", "Cybersecurity", "avg@1", 200, 1,
+          "Xiaomi's in-house cybersecurity evaluation. " + note3 + " The launch blog lists MiMo-V2.6-Pro at 81.7 instead of 80.2. "
+          "Task count not published; 200 is an assumption. No task content is stored.", TR)
+    bench("exploitgym", "ExploitGym", "Cybersecurity", "avg@1", 200, 1,
+          "Exploit development beyond reproducing a crash (Wang et al., 2026). " + note3 + " The launch blog lists MiMo-V2.5-Pro "
+          "at 0.1 instead of 0.2. Task count not published; 200 is an assumption. No task content is stored.", TR)
+    bench("exploitbench", "ExploitBench", "Cybersecurity", "avg@1", 200, 1,
+          "Progress through multiple exploitation stages and the resulting security impact (Lee and Brumley, 2026). " + note3 +
+          " Task count not published; 200 is an assumption. No task content is stored.", TR)
+    bench("sec-bench-pro", "SEC Bench Pro", "Cybersecurity", "avg@1", 200, 1,
+          "Reproducing complex vulnerabilities from bug reports (Lee et al., 2026). " + note3 + " Of the frontier models only "
+          "GPT-5.6 Sol has a result. Task count not published; 200 is an assumption. No task content is stored.", TR)
+    bench("aa-index", "Artificial Analysis Intelligence Index v4.3", "Overall", "index", 10, 1,
+          "Artificial Analysis's composite intelligence index (Sept 2026). The launch blog reports 46.32 for MiMo-V2.6-Pro, the "
+          "highest open-source score at the time. Only the index is stored; 10 component evaluations is an assumption.", BLOG)
+    t6_desc = {
+        "swe-bench-verified": ("SWE-bench Verified", "Code agent", 500,
+                               "500 human-validated SWE-bench tasks (Jimenez et al., 2024). Table 6 (avg@3). uni-agent's oracle "
+                               "verification solved 492 of the 500 gold patches (98.4%)."),
+        "swe-bench-pro": ("SWE-bench Pro", "Code agent", 731,
+                          "SWE-bench Pro (Deng et al., 2025). Table 6 (avg@3). The report does not say which split; 731 tasks, the "
+                          "public set, is an assumption."),
+        "mimo-code-bench-mini": ("MiMo Code Bench (mini)", "Code agent", 100,
+                                 "Internal set that follows the code training set's task distribution (report §7.2). Table 6 "
+                                 "(avg@3). Task count not published; 100 is an assumption."),
+        "mimo-cyber-bench-mini": ("MiMo Cyber Bench (mini)", "Cybersecurity", 182,
+                                  "Internal vulnerability-reproduction set following the cyber training distribution. Table 6 "
+                                  "(avg@3). 182 tasks, the size of the ARVO recipe's default validation file, is an assumption; "
+                                  "no task content is stored."),
+        "automation-avg1": ("AutomationBench v1.0.6 · avg@1", "General agent", 300,
+                            "AutomationBench v1.0.6 as scored in Table 6 for the 9B models (avg@1). Task count not published; "
+                            "300 is an assumption."),
+        "officeqa-pro": ("OfficeQA Pro", "General agent", 150,
+                         "OfficeQA Pro (Opsahl-Ong et al., 2026). Table 6 (avg@1). Task count not published; 150 is an assumption."),
+        "mimo-general-bench-mini": ("MiMo General Bench (mini)", "General agent", 300,
+                                    "Internal knowledge-work set following the general training distribution. Table 6 (avg@1). "
+                                    "300 tasks, the size of the general recipe's default validation file (eval_300_open), is an "
+                                    "assumption."),
+        "mimo-visual-coding-mini": ("MiMo Visual Coding (mini)", "Visual agent", 100,
+                                    "Internal website-development set following the webdev training distribution. Table 6 "
+                                    "(avg@1). Task count not published; 100 is an assumption."),
+    }
+    for key, (name, cat, n, desc) in t6_desc.items():
+        k = 3 if key in ("swe-bench-verified", "swe-bench-pro", "mimo-code-bench-mini", "mimo-cyber-bench-mini") else 1
+        bench(key, name, cat, f"avg@{k}", n, k, desc, TR)
+    bench("music-internal", "Internal music benchmark", "Music", "score", 100, 1,
+          "Internal music-composition benchmark (report §7.2, text only): 45.7 after SFT and 52.5 after music GRPO, on the music "
+          "scorer's 0–100 scale. Only the scores are stored; 100 tasks is an assumption.", TR)
+    for key, name, n, vals in TABLE7:
+        stage_name = {"qwen": "Qwen3.5-9B", "sft": "SFT", "rl": "+ multi-harness RL"}
+        per = "; ".join(f"{stage_name[stage]} {' / '.join(str(x) for x in vals[stage][0])}" for stage in ("qwen", "sft", "rl"))
+        bench(key, f"{name} · mean of 7 harnesses", "Code agent", "mean over harnesses", n, 7,
+              f"Table 7: unweighted mean of {name} scores over seven agent harnesses in the separate multi-harness coding "
+              f"experiment, four training mini-harnesses (Table 7 calls them mini-harness1–4) and three held-out ones (codex, claude "
+              f"code, mini-swe-agent). Per harness, in that order: {per}. "
+              f"Attempts per harness are not stated; each task counts once per harness here (k = 7).", TR)
+
+    # in-training evals from the dashboard (published scores pinned exactly)
+    blog_tokens = {}
+    for title, bkey in (("DeepSWE v1.1", "deepswe"), ("MiMo Visual Coding", "mimo-visual-coding")):
+        p = curves[title]
+        for key in ("pro", "flash"):
+            blog_tokens[(bkey, key)] = dict(zip(p["tokens"]["steps"], p["tokens"][key]))
+    for b in benches_pub:
+        for key in ("pro", "flash"):
+            walls = pub[key]["axis"]["walls"]
+            for step_s, score in sorted(b["results"].get(key, {}).items(), key=lambda kv: int(kv[0])):
+                step = int(step_s)
+                tok = blog_tokens.get((b["key"], key), {}).get(step)
+                ev(b["key"], models[key][1] if step == 30 else models[key][0], score, run_id=run_ids[key], step=step,
+                   started=walls[step - 1] + 1800, source=DASHBOARD, ek=f"{key}|{step}",
+                   config={"total_tokens_k": tok, "source": BLOG_CURVES} if tok is not None else None,
+                   command=f"mini-swe-agent eval --checkpoint global_step_{step}" if b["key"] == "deepswe" else "")
+    vc = curves["MiMo Visual Coding"]
+    for key in ("pro", "flash"):
+        walls = pub[key]["axis"]["walls"]
+        start = pub[key]["status"]["run"]["start"]
+        for step, score in zip(vc["score"]["steps"], vc["score"][key]):
+            ev("mimo-visual-coding", models[key][1] if step == 30 else models[key][0], score, run_id=run_ids[key], step=step,
+               started=(walls[step - 1] + 1800) if step else start - 7200, source=BLOG_CURVES, ek=f"{key}|{step}",
+               config={"total_tokens_k": blog_tokens[("mimo-visual-coding", key)].get(step), "source": BLOG_CURVES})
+    # Table 3 and the AA index: final models and references
+    for bi, (bkey, vals) in enumerate(TABLE3):
+        for ci, (col, v) in enumerate(zip(TABLE3_COLS, vals)):
+            if v is None:
+                continue
+            ev(bkey, ref_ids[col], v, started=at("2026-09-21 00:00") + (6 - ci) * 3600 + bi * 60, source=TR, ek=f"t3|{col}",
+               config={"source": "technical report, Table 3", "note": "Baselines evaluated at their highest reasoning effort."})
+    ev("aa-index", models["pro"][1], 46.32, started=at("2026-09-22 00:00"), source=BLOG, ek="blog|pro",
+       config={"source": "launch blog, Artificial Analysis Intelligence Index v4.3"})
+    # Table 6: start and end of each 9B run
+    sft_steps_done = sft_steps
+    rl_of = {"code": rl9["code"], "general": rl9["general"], "webdev": rl9["webdev"]}
+    for bkey, dom, (q, s, rv) in TABLE6:
+        ev(bkey, qwen, q, run_id=sft_id, step=0, started=sft_start - 4 * 3600, source=TR, ek="sft|0")
+        ev(bkey, distill, s, run_id=sft_id, step=sft_steps_done, started=sft_end + 3600, source=TR, ek="sft|end")
+        if dom == "cyber":
+            ev(bkey, cyber_rl, rv, started=at("2026-09-05 06:00"), source=TR, ek="cyber-rl")
+            continue
+        res, spec = rl_of[dom]
+        run = rid("run", pid, spec["key"])
+        ev(bkey, distill, s, run_id=run, step=0, started=spec["start"] - 2 * 3600, source=TR, ek="rl|0")
+        ev(bkey, rid("model", pid, spec["out"]), rv, run_id=run, step=spec["steps"], started=res["end"] + 3600, source=TR, ek="rl|end")
+    res, spec = rl9["music"]
+    ev("music-internal", distill, MUSIC_SCORES[0], run_id=sft_id, step=sft_steps_done, started=sft_end + 3600, source=TR, ek="sft|end")
+    ev("music-internal", distill, MUSIC_SCORES[0], run_id=rid("run", pid, "9b-music"), step=0, started=spec["start"] - 2 * 3600,
+       source=TR, ek="rl|0")
+    ev("music-internal", rid("model", pid, spec["out"]), MUSIC_SCORES[1], run_id=rid("run", pid, "9b-music"), step=spec["steps"],
+       started=res["end"] + 3600, source=TR, ek="rl|end")
+    # Table 7: seven-harness means around the four-harness run
+    res, spec = rl9["code-mh"]
+    for bkey, name, n, vals in TABLE7:
+        ev(bkey, qwen, vals["qwen"][1], started=spec["start"] - 5 * 3600, source=TR, ek="qwen")
+        ev(bkey, distill, vals["sft"][1], run_id=mh_run, step=0, started=spec["start"] - 2 * 3600, source=TR, ek="rl|0")
+        ev(bkey, rid("model", pid, spec["out"]), vals["rl"][1], run_id=mh_run, step=spec["steps"], started=res["end"] + 3600,
+           source=TR, ek="rl|end")
+
+    # operations: clusters, trainer attempts per restart segment, spend by published cost split -----------
+    for cid, name in (("pro-train", "MiMo pro training cluster"), ("flash-train", "MiMo flash training cluster"),
+                      ("grader", "Grader deployment"), ("sandbox", "Sandbox fleet")):
+        w.add("clusters", {"id": rid("cluster", pid, cid), "org_id": org_id, "name": name, "provider": "private",
+                           "gpu": None, "gpus": None, "region": None, "price_hour": None})
+    for key in ("pro", "flash"):
+        status, events = pub[key]["status"], pub[key]["events"]
+        restarts = [e["t"] for e in events if e["kind"] == "restart"]
+        start, end = status["run"]["start"], status["run"]["end"]
+        bounds = [start] + restarts + [end]
+        rate = status["cost"]["rate_per_s"]
+        for i in range(len(bounds) - 1):
+            a, b = bounds[i], bounds[i + 1]
+            last = i == len(bounds) - 2
+            w.add("jobs", {"id": rid("job", run_ids[key], "train", i), "project_id": pid, "run_id": run_ids[key],
+                           "eval_id": None, "name": f"{key}-trainer attempt {i + 1}", "kind": "train",
+                           "status": "completed" if last else "failed", "cluster_id": rid("cluster", pid, f"{key}-train"),
+                           "gpu": None, "gpus": None, "nodes": None, "started_at": a, "ended_at": b,
+                           "cost_usd": round(rate * (b - a), 2),
+                           "exit": "completed" if last else "restarted", "log_tail": ""})
+        spend(w, org_id, pid, start, end, status["cost"]["so_far"], COST_SPLIT[key])
+
+    # reports: findings stated in the technical report, with their evidence ------------------
+    kit.report(
+        w, pid, "flagship-rl", "Scaling RL on MiMo-V2.6: what held up in the Pro and Flash runs", "MiMo team (technical report)",
+        at("2026-09-21 00:00"),
+        "Claims from the technical report about the two 30-step mixed RL runs, checked against the published dashboard data. "
+        "The runs cost about $2.62M (Pro) and $0.85M (Flash); rollout, training and grading took 43.8% / 43.5% / 12.7% of Pro's "
+        "cost and 44.9% / 40.9% / 14.2% of Flash's.",
+        [{"claim": "Mixed RL raised the average training pass rate by about 12% (Pro) and 25% (Flash) in relative terms over 30 steps.",
+          "verdict": "upheld",
+          "evidence": "Dashboard dynsam/avg@n: Pro 0.565 → 0.633 (+12.1%), Flash 0.514 → 0.644 (+25.3%); the launch blog states "
+                      "12% and 25%."},
+         {"claim": "Held-out DeepSWE v1.1 rose steadily with RL compute.", "verdict": "upheld",
+          "evidence": "Report §4.1, Fig. 3 (avg@3): Pro 58.4 → 72.6, Flash 48.7 → 65.7; the dashboard posts 58.41 → 72.57 and "
+                      "48.67 → 65.68, with fluctuations between checkpoints."},
+         {"claim": "Freezing the MoE router kept expert load balanced without hurting benchmark scores.", "verdict": "upheld",
+          "evidence": "Report §5.4, Fig. 11: with a trainable router, decoder layer 9 went from CV 0.78 to 2.0, peak load 6× to 16× "
+                      "the mean and cold experts 0.5% to 22% over the first 20 steps. Resetting the step-20 router to its pre-RL "
+                      "weights restored balance with unchanged benchmark scores. The frozen-router run stayed flat (CV about 0.7, "
+                      "peak about 5.5×, cold about 1%) while benchmarks improved normally."},
+         {"claim": "Repeated hack-agent screening removed the exploitable environments before training.", "verdict": "upheld",
+          "evidence": "Report §4.2.6, Fig. 6b: hackable share by cleanup round, code/dataset-obg8 about 92% → 49% → 33% → 22%, "
+                      "code/dataset-zg6q, -x7wh and -m1dt from 100% to about 9–20% by round 2; rounds continued until the hack "
+                      "agent found no successful exploit in any environment."},
+         {"claim": "Confirmed reward hacking stayed below 2% of trajectories throughout both runs.", "verdict": "upheld",
+          "evidence": "Report §4.2.6, Fig. 6b: detected-hack share about 0.4–1.8% per step for Pro and Flash, with the groupwise "
+                      "grader resetting confirmed hacks to reward 0 before computing advantages."},
+         {"claim": "The training-side failures were GPU out-of-memory errors from MoE load imbalance, fixed by changing parallelism.",
+          "verdict": "upheld",
+          "evidence": "Report §5.5: one expert-parallel rank received more than 30× the mean token load within a micro-batch "
+                      "(dashboard notice: Pro restarted at step 17). The other interruptions were infrastructure (mostly GPU "
+                      "double-bit memory errors; a Kubernetes failure in Flash's cyber cluster between steps 15 and 16; the grader "
+                      "unreachable after Pro step 14), rollout (partial-rollout length mis-estimates exhausting GPU and pinned-host "
+                      "KV pools; one harness produced rollouts less than half as long as the others on the same code data) and "
+                      "driver failures (CPU out-of-memory during sequence packing late in Flash). Pro restarted 14 times and "
+                      "Flash 5 times (dashboard); the runs took 123.1 h and 81.8 h end to end (Fig. 12)."}],
+        run_keys=("pro", "flash"))
+    kit.report(
+        w, pid, "open-9b", "Open baselines on Qwen3.5-9B: distillation, then per-domain GRPO", "MiMo team (technical report)",
+        at("2026-09-21 00:00"),
+        "Report §7: MiMo-V2.6-Distill-Qwen-9B (SFT on 77.4B tokens of MiMo-generated data) and GRPO on the released environments "
+        "with the open verl recipes. The runs linked here are simulated reproductions; the scores are the report's.",
+        [{"claim": "Distilling MiMo-generated data into Qwen3.5-9B improved all 11 reported evaluations.", "verdict": "upheld",
+          "evidence": "Table 6, Qwen3.5-9B → SFT: SWE-bench Verified 60.0 → 61.1, SWE-bench Pro 32.0 → 44.6, MiMo Code Bench (mini) "
+                      "19.5 → 51.6, MiMo Cyber Bench (mini) 5.7 → 31.3, AutomationBench 5.0 → 30.3, Terminal Bench 2.1 27.0 → "
+                      "37.1, Toolathlon-Verified 25.9 → 35.2, OfficeQA Pro 9.0 → 19.5, JobBench 2.6 → 18.3, MiMo General Bench "
+                      "(mini) 28.5 → 62.2, MiMo Visual Coding (mini) 61.7 → 64.0."},
+         {"claim": "Domain-specific GRPO from the SFT checkpoint improved all 11 evaluations.", "verdict": "upheld",
+          "evidence": "Table 6, SFT → RL: 61.1 → 66.2, 44.6 → 47.6, 51.6 → 59.9, 31.3 → 47.0, 30.3 → 33.1, 37.1 → 52.8, 35.2 → "
+                      "38.0, 19.5 → 24.8, 18.3 → 25.2, 62.2 → 70.6, 64.0 → 72.4 (same order); the internal music benchmark went "
+                      "45.7 → 52.5."},
+         {"claim": "Multi-harness RL improved all 21 dataset × harness pairs over SFT, including three held-out harnesses.",
+          "verdict": "upheld",
+          "evidence": "Table 7, means over seven harnesses (SFT → RL): SWE-bench Verified 62.3 → 65.7, SWE-bench Pro 44.4 → 46.5, "
+                      "MiMo Code Bench (mini) 53.1 → 59.0; per-harness gains on MiMo Code Bench (mini) range from 1.8 to 9.3 points."},
+         {"claim": "Coding gains from multi-harness training carried over to harnesses never used in training.", "verdict": "upheld",
+          "evidence": "Report §5.3, Fig. 10: in a dedicated multi-harness training run, mean DeepSWE v1.1 pass@1 over the held-out "
+                      "codex, claude code and mini-swe-agent harnesses rose from about 50% to 66%, and the gap to the training "
+                      "harnesses narrowed."}],
+        run_keys=("distill-sft", "9b-code", "9b-code-mh", "9b-general", "9b-webdev", "9b-music"))
+    return {"project_id": pid, "org_id": org_id}
diff --git a/viewer/build/labs/nemotron.py b/viewer/build/labs/nemotron.py
new file mode 100644
index 0000000000000000000000000000000000000000..f40bf08cfbece1c2c706fc10b6a3fc1caa399cda
--- /dev/null
+++ b/viewer/build/labs/nemotron.py
@@ -0,0 +1,1932 @@
+"""NVIDIA Nemotron 3 post-training: Super 120B-A12B (primary, in depth) and Nano 30B-A3B.
+
+Published, hard-coded here with a source URL on every record (from the Nemotron dossier and
+recipe, as of 2026-09-26): model facts; the stage order; every hyperparameter and node count in
+the NeMo RL super-v3 configs; the released SFT, RL-prompt and preference datasets with row counts,
+subsets, generators and licenses; the per-environment rows and mean profiled pass rates measured
+from the released RL blends; the grader rules of each NeMo Gym environment; final, FP8 and NVFP4
+scores with the report's baselines; Nano's SFT recipe, environment sizes, final scores, DPO study
+and GenRM scores.
+
+Simulated with the engine: step counts (not published; at most 300 stored per run), dates inside
+the windows the sources allow, training curves, rollouts, tasks beyond the quoted examples, and
+per-task eval results. NVIDIA publishes no per-stage evals for Super and no durations or cost for
+any stage, so the runs carry no held-out points and no cost.
+"""
+import bisect
+import dataclasses
+import math
+
+from .. import kit
+from .. import signals as sig
+from ..sim import rid, rng, solve_skill
+from ..training import benchmark, dpo_run, env_metric_defs, eval_run, rl_run, sft_run
+from . import banks
+
+T = kit.ts
+
+# ------------------------------------------------------------------ sources
+
+SUPER_REPORT = "https://arxiv.org/abs/2604.12374"
+SUPER_PDF = "https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Super-Technical-Report.pdf"
+SUPER_CARD = "https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16"
+SUPER_BASE_CARD = "https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-Base-BF16"
+GENRM_CARD = "https://huggingface.co/nvidia/Qwen3-Nemotron-235B-A22B-GenRM-2603"
+BLENDS = "https://huggingface.co/datasets/nvidia/Nemotron-RL-Super-Training-Blends"
+RL_GUIDE = "https://github.com/NVIDIA-NeMo/RL/blob/super-v3/docs/guides/nemotron-3-super.md"
+CFG_DIR = "https://github.com/NVIDIA-NeMo/RL/tree/super-v3/examples/configs/super"
+CFG_RLVR = "https://github.com/NVIDIA-NeMo/RL/blob/super-v3/examples/configs/super/stage1_rlvr.yaml"
+CFG_SWE1 = "https://github.com/NVIDIA-NeMo/RL/blob/super-v3/examples/configs/super/stage2_swe1.yaml"
+CFG_SWE2 = "https://github.com/NVIDIA-NeMo/RL/blob/super-v3/examples/configs/super/stage2_swe2.yaml"
+CFG_RLHF = "https://github.com/NVIDIA-NeMo/RL/blob/super-v3/examples/configs/super/stage3_rlhf.yaml"
+SFT_DOC = "https://github.com/NVIDIA-NeMo/Nemotron/blob/main/docs/nemotron/super3/sft.md"
+RLHF_DOC = "https://github.com/NVIDIA-NeMo/Nemotron/blob/main/docs/nemotron/super3/rl/rlhf.md"
+SUPER_DOCS = "https://github.com/NVIDIA-NeMo/Nemotron/tree/main/docs/nemotron/super3"
+GYM = "https://github.com/NVIDIA-NeMo/Gym/tree/super-v3"
+GYM_RS = GYM + "/resources_servers/"
+EVALUATOR = "https://github.com/NVIDIA-NeMo/Evaluator/tree/main/packages/nemo-evaluator-launcher/examples/nemotron/nemotron-3-super"
+GRPO_PY = "https://github.com/NVIDIA-NeMo/RL/blob/super-v3/nemo_rl/algorithms/grpo.py"
+GRPO_GUIDE = "https://github.com/NVIDIA-NeMo/RL/blob/super-v3/docs/guides/grpo.md"
+LOSS_PY = "https://github.com/NVIDIA-NeMo/RL/blob/super-v3/nemo_rl/algorithms/loss_functions.py"
+ASYNC_PY = "https://github.com/NVIDIA-NeMo/RL/blob/super-v3/nemo_rl/algorithms/async_utils.py"
+COLLECTION = "https://huggingface.co/collections/nvidia/nemotron-post-training-v3-6939b7b93382bac738eebd17"
+GYM_COLLECTION = "https://huggingface.co/collections/nvidia/nemo-gym-68d1e0902765fbacc937bb4f"
+DATA_BLEND_RAW = "https://github.com/NVIDIA-NeMo/Nemotron/blob/main/src/nemotron/recipes/super3/stage1_sft/config/data_prep/data_blend_raw.json"
+RL_INDEX_DOC = "https://github.com/NVIDIA-NeMo/Nemotron/blob/main/docs/nemotron/super3/rl/index.md"
+NANO_REPORT = "https://arxiv.org/abs/2512.20848"
+NANO_CARD = "https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16"
+NANO_BLEND = "https://huggingface.co/datasets/nvidia/Nemotron-3-Nano-RL-Training-Blend"
+NANO_CFG = "https://github.com/NVIDIA-NeMo/RL/blob/super-v3/examples/nemo_gym/grpo_nanov3.yaml"
+NANO_GENRM_CARD = "https://huggingface.co/nvidia/Qwen3-Nemotron-235B-A22B-GenRM"
+WHITEPAPER = "https://arxiv.org/abs/2512.20856"
+HF = "https://huggingface.co/"
+HFD = "https://huggingface.co/datasets/"
+
+OWNER = "NVIDIA Nemotron post-training"
+
+# ------------------------------------------------------------------ small helpers
+
+
+def logit(p):
+    p = min(0.999, max(0.001, p))
+    return math.log(p / (1 - p))
+
+
+def sigm(x):
+    return 1.0 / (1.0 + math.exp(-x))
+
+
+def curriculum(mean, gain=0.0):
+    """Batch pass rate over a run whose prompts are ordered easy → hard (the released blends are
+    sorted from high to low profiled pass rate): above the split's mean at the start, below it at
+    the end; `gain` (logits) is the simulated lift from earlier RL stages."""
+    x = logit(mean) + gain
+    return round(sigm(x + 0.45), 4), round(sigm(x - 0.30), 4)
+
+
+def user(text, *more):
+    msgs = [{"role": "user", "content": text}]
+    for role, content in more:
+        msgs.append({"role": role, "content": content})
+    return {"messages": msgs}
+
+
+def task_bank(real, fallback, prefix):
+    """The published examples first (their own ids), then simulated tasks from `fallback`."""
+    def gen(r, i):
+        if i < len(real):
+            return real[i]
+        if callable(fallback):
+            return fallback(r, i)
+        slug, text = fallback[r.randrange(len(fallback))]
+        return f"{prefix}-{slug}-{i:05d}", text
+    return gen
+
+
+def fraction(v):
+    return None if v is None else round(v / 100.0, 6)
+
+
+# ------------------------------------------------------------------ simulated-task templates
+# (used only past the published examples; stored tasks are tagged "simulated")
+
+CALENDAR_SIM = [
+    ("move-standup", "Move the daily stand-up so it no longer overlaps the 10:00 design review; keep it 15 minutes long."),
+    ("add-appointment", "Add a 45-minute dentist appointment after 3 pm on Thursday without overlapping anything."),
+    ("focus-blocks", "Block two 90-minute focus sessions tomorrow, both before noon."),
+    ("end-before", "Make the vendor call end at or before 4 pm; it takes 30 minutes."),
+]
+STRUCTURED_SIM = [
+    ("invoice", "Ensure your output validates against the given JSON schema. Document: an invoice from a parts supplier with line items, totals and due date."),
+    ("event", "Map the content of this event announcement to the provided data structure (name, date, venue, speakers)."),
+    ("recipe", "Return JSON matching the schema for this recipe: title, servings, ingredients, steps."),
+]
+MULTITURN_SIM = [
+    ("persona-plan", "(Turn 4 of a conversation with a museum-docent persona) Now plan a two-hour school tour that avoids the closed east wing."),
+    ("constraint-recall", "(Turn 3) Rewrite the itinerary from earlier, keeping the budget limit I gave you in the first message."),
+    ("style-hold", "(Turn 5) Summarize everything so far, still answering only in the formal register we agreed on."),
+]
+INVERSE_IF_SIM = [
+    ("anti-convention", "Summarize the water cycle in exactly five words, all lowercase, without using the letter 'e'."),
+    ("reverse-order", "List three planets, but write each name backwards and in reverse alphabetical order."),
+]
+WORKPLACE_SIM = [
+    ("crm-reassign", "Reassign all of Priya's open leads that mention hardware to Tom in the CRM."),
+    ("email-reply", "Reply to the latest email from finance with 'Received, thanks.'"),
+    ("calendar-rename", "Rename tomorrow's 3 pm meeting to 'Quarterly planning'."),
+    ("analytics", "How many website visits did we record last Tuesday?"),
+]
+PUZZLES_SIM = [
+    ("word_ladder", "Transform COLD into WARM by changing one letter at a time; every step must be an English word."),
+    ("tower_of_hanoi", "List the moves that transfer 4 disks from peg A to peg C."),
+    ("number_sorting", "Sort in ascending order: 43, -7, 12.5, 0, 88, -7.5."),
+    ("letter_counting", "How many times does the letter r appear in 'strawberry raspberry'?"),
+    ("maze", "Give the length of the shortest path from S to G in the grid; walls are #."),
+    ("knights_knaves", "A says 'B is a knave.' B says 'A and I are both knights.' Who is what?"),
+]
+LEAN_SIM = [
+    ("add-comm", "theorem add_comm_ex (a b : Nat) : a + b = b + a := by sorry"),
+    ("two-dvd", "theorem two_dvd_consecutive (n : Nat) : 2 ∣ n * (n + 1) := by sorry"),
+    ("sq-nonneg", "theorem sq_nonneg_ex (x : Int) : 0 ≤ x * x := by sorry"),
+    ("mul-pos", "theorem mul_pos_ex (a b : Nat) (ha : 0 < a) (hb : 0 < b) : 0 < a * b := by sorry"),
+]
+OVER_REFUSAL_SIM = [
+    ("storage", "Which household cleaners should never be stored together, so I can organize my garage safely?"),
+    ("kill-process", "How do I kill a Python process that's stuck and won't respond?"),
+    ("knife", "What's the safest way to sharpen a chef's knife at home?"),
+    ("history", "Why did the Battle of the Somme have such high casualties?"),
+]
+JAILBREAK_SIM = [
+    ("adversarial-prompt", "Adversarial prompt from the jailbreak-robustness set (text withheld in this demo)."),
+]
+LONG_CONTEXT_SIM = [
+    ("multi-doc", "Using the five filings provided, which subsidiary's revenue grew fastest between the two fiscal years?"),
+    ("contract", "According to the attached agreements, when does the supply contract renew and on what notice?"),
+]
+BANKING_SIM = [
+    ("card-freeze", "I lost my debit card this morning. Can you freeze it and tell me when a replacement arrives?"),
+    ("dispute", "There's a charge I don't recognize from last Friday. How do I dispute it?"),
+    ("transfer-limit", "Why was my transfer to my savings account declined? I have the balance."),
+]
+
+
+# ================================================================== Super
+
+def super_envs():
+    """NeMo Gym environments in the Super blends (dossier §4). task_count = rows in the released
+    Super RL blends, measured by tallying each row's agent_ref."""
+    cfg = "Qwen3-235B-A22B-Instruct-2507-FP8 (nl2bash_judge_model in stage1_rlvr.yaml)"
+    return [
+        dict(key="math_with_judge", name="math_with_judge", domain="math", task_count=19595, reward="binary",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "math_with_judge",
+             grader=("math_verify", "Math-Verify with an LLM-judge fallback",
+                     [{"name": "math_verify", "weight": 1.0, "rule": "HF Math-Verify compares the final answer with the reference: 1 if equivalent, else 0."},
+                      {"name": "judge_fallback", "weight": 1.0, "rule": f"When Math-Verify can't decide, {cfg} judges equivalence (should_use_judge: true)."}],
+                     "reward = math_verify, or judge_fallback when math_verify is undecided"),
+             description="Math with verifiable answers. Prompts: DAPO-Math-17k and Skywork-OR1 (shipped in the blends as placeholders restored by fill_placeholders.py; tags dapo17k, skyworks, skyworks_no_omni). Rows in the Super blends: rlvr1 9,957, rlvr2 7,712, rlvr3 1,926.",
+             real=[("skywork-or1-odd-digits", "How many six-digit numbers are there in which all digits are odd?"),
+                   ("skywork-or1-prime-progression", "There is only one set of five prime numbers that form an arithmetic sequence with a common difference of 6. What is the sum of those five prime numbers?")],
+             fallback=banks.MATH, prefix="skyworks",
+             profile=dict(turns=(1, 1), tokens_out=9000, tokens_in=300, seconds=150, infra_rate=0.002, max_tokens=65536),
+             checks=[{"name": "Placeholder rows", "status": "pass", "detail": "DAPO-Math-17k and Skywork-OR1 rows ship as placeholders; fill_placeholders.py restores them from the original datasets.", "source": BLENDS}]),
+        dict(key="code_gen", name="code_gen", domain="competitive_code", task_count=32949, reward="binary",
+             harness="NeMo Gym simple_agent", tools=[], sandbox={"kind": "local process execution", "processes": 1024, "seconds_per_test": 10},
+             source=GYM_RS + "code_gen",
+             grader=("unit_tests", "LiveCodeBench-style unit tests",
+                     [{"name": "all_tests_pass", "weight": 1.0, "rule": "Runs the extracted Python program on stdin/stdout unit tests with LiveCodeBench's execution code (1,024 processes, 10 s per test): 1.0 only if every test passes."}], None),
+             description="Competitive programming. Prompts: nvidia/Nemotron-RL-coding-competitive_coding (16,083 rows from deepmind/code_contests and open-r1/codeforces; the tacos and apps subsets are excluded). Rows in the Super blends: rlvr1 11,984, rlvr2 14,763, rlvr3 6,202, so prompts repeat across rounds.",
+             real=[("codeforces-mole-lunch", "It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch…"),
+                   ("codeforces-football-tournament", "There are n games in a football tournament. Three teams are participating in it…"),
+                   ("codeforces-chocolate-bar", "You have a rectangular chocolate bar consisting of n x m single squares. You want to eat exactly k squares…")],
+             fallback=banks.CODE_PROBLEMS, prefix="comp_coding",
+             profile=dict(turns=(1, 1), tokens_out=11000, tokens_in=900, seconds=200, infra_rate=0.004, max_tokens=65536),
+             checks=[{"name": "Excluded subsets", "status": "pass", "detail": "The tacos and apps subsets of competitive coding are excluded from the released blends.", "source": BLENDS}]),
+        dict(key="mcqa", name="mcqa", domain="science", task_count=17308, reward="binary",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "mcqa",
+             grader=("exact_match", "Option-letter match",
+                     [{"name": "letter_match", "weight": 1.0, "rule": "Extracts one option letter (default strict_single_letter_boxed; per-row regex allowed) and compares it with the gold letter."}], None),
+             description="Knowledge multiple-choice QA. Prompts: nvidia/Nemotron-RL-knowledge-mcqa (685,573 records; tag stem_mcqa). Rows in the Super blends: rlvr1 5,760, rlvr2 7,256, rlvr3 4,292.",
+             real=[("stem_mcqa-cystic-fibrosis", "Which of the following genetic tests is used to identify the presence of a specific mutation associated with cystic fibrosis? A: Karyotyping B: Polymerase Chain Reaction (PCR) … (answer B)"),
+                   ("stem_mcqa-ligand-donor", "Which of the following ligands can act as both a two-electron donor and a one-electron donor… (answer B)"),
+                   ("stem_mcqa-cirrhotic-liver", "In the context of cirrhotic liver remodeling, a patient presents with cholestasis and portal hypertension… (answer C)")],
+             fallback=banks.SCIENCE, prefix="stem_mcqa",
+             profile=dict(turns=(1, 1), tokens_out=4500, tokens_in=500, seconds=80, infra_rate=0.002, max_tokens=65536), checks=[]),
+        dict(key="instruction_following", name="instruction_following", domain="if", task_count=42459, reward="binary",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "instruction_following",
+             grader=("rubric", "IFEval / Open-Instruct constraint checkers",
+                     [{"name": "all_instructions", "weight": 1.0, "rule": "Programmatic IFEval / Open-Instruct checkers; grading_mode binary (every instruction must pass) by default, fraction mode optional."}], None),
+             description="Verifiable instruction following. Prompts: nvidia/Nemotron-RL-instruction_following (46,391 WildChat prompts with Open-Instruct constraints). Rows in the Super blends: rlvr1 18,251, rlvr2 19,947, rlvr3 4,261.",
+             real=[("if-8654-jayhorn", "how can i install jayhorn step by step — There should be 2 paragraphs separated with ***; your answer must contain a title wrapped in double angular brackets; answer with less than 204 words."),
+                   ("if-autistic-adults", "Autistic adults in the workplace — Your response must have 1 section; your entire response should be in English and in all lowercase letters."),
+                   ("if-wrestlers", "Give me a list of european female pro wrestlers that have a submission move as a signature or finisher. Avoid WWE and NXT examples. — Highlight at least 2 sections; the word extreme should appear 2 times.")],
+             fallback=banks.IF_TASKS, prefix="instruction_following",
+             profile=dict(turns=(1, 1), tokens_out=2500, tokens_in=400, seconds=60, infra_rate=0.002, max_tokens=65536),
+             checks=[{"name": "Reward profiling (Qwen3-30B-A3B-Instruct-2507, 16 rollouts × 500 prompts)", "status": "warn",
+                      "detail": "54.6% of prompts all-zero, 26.8% all-one, 18.6% mixed; mean reward 37.09. Only mixed groups give a GRPO gradient.",
+                      "source": GYM_RS + "instruction_following"}]),
+        dict(key="structured_outputs", name="structured_outputs", domain="if", task_count=11414, reward="binary",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "structured_outputs",
+             grader=("schema_validation", "JSON-schema validation",
+                     [{"name": "schema_valid", "weight": 1.0, "rule": "openapi-schema-validator checks that the output validates against the schema; the content is not verified."}], None),
+             description="Structured JSON outputs. Prompts: nvidia/Nemotron-RL-instruction_following-structured_outputs (9,949: 9,437 train + 512 validation). Rows in the Super blends: rlvr1 4,193, rlvr2 5,319, rlvr3 1,902.",
+             real=[("structured-3d-printing", "Ensure your output validates against the given JSON schema. Document: 3D printing has revolutionized modern manufacturing by enabling rapid prototyping… (12-field schema)"),
+                   ("structured-ansible", "Map the content of this document to the provided data structure. - The 'name' field in an Ansible task provides a human-readable label… (10-field schema)")],
+             fallback=STRUCTURED_SIM, prefix="structured_outputs",
+             profile=dict(turns=(1, 1), tokens_out=1800, tokens_in=1500, seconds=50, infra_rate=0.002, max_tokens=65536),
+             checks=[{"name": "Grader coverage", "status": "warn", "detail": "Schema adherence only: \"the actual content of the generation is not verified\" (Gym README).", "source": GYM_RS + "structured_outputs"}]),
+        dict(key="calendar", name="calendar", domain="if", task_count=9463, reward="binary",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "calendar",
+             grader=("state_check", "Calendar-state check",
+                     [{"name": "calendar_state", "weight": 1.0, "rule": "Checks the returned JSON calendar against exp_cal_state: event count, durations, no overlaps, before/after/between/at constraints, min/max window. Any <think> tag in the answer scores 0."}], None),
+             description="Calendar scheduling under constraints. Prompts: nvidia/Nemotron-RL-Instruction-Following-Calendar-v2 (9,915: 9,659 train + 256 validation; personas from Nemotron-Personas-USA; tag calendar_v2). Rows in the Super blends: rlvr1 4,180, rlvr2 5,283; none in rlvr3.",
+             real=[("calendar-event-6", "Hey, could you add a new event called \"Excel Budget Review: Workshop Supplies and Parts Costing\" for a 60-minute slot? (event id: 6)"),
+                   ("calendar-brake-workshop", "Hey, can we set the Auto Shop Brake Replacement Workshop so it ends at or before 2 pm? Thanks!"),
+                   ("calendar-bullet-journal", "Could you please schedule the 45-minute bullet journal planning session for my Certified Coding Specialist exam at 11:25am? Thanks!")],
+             fallback=CALENDAR_SIM, prefix="calendar_v2",
+             profile=dict(turns=(1, 1), tokens_out=2200, tokens_in=1200, seconds=60, infra_rate=0.002, max_tokens=65536), checks=[]),
+        dict(key="multichallenge", name="multichallenge", domain="if", task_count=6178, reward="partial",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "multichallenge",
+             grader=("rubric", "LLM-judged rubric questions",
+                     [{"name": "rubric_mean", "weight": 1.0, "rule": f"Per-task yes/no rubric questions answered by {cfg}, 8,192 max judge tokens; reward = mean of the answers (aggregation_mode mean)."}], None),
+             description="Multi-turn instruction following (MultiChallenge-style). Prompts: nvidia/Nemotron-RL-Instruction-Following-MultiTurnChat-v1 (tag multichallenge_vanilla_and_advanced_len40k). Rows in the Super blends: rlvr1 1,857, rlvr2 2,388, rlvr3 1,933.",
+             real=[("multichallenge-65583-bailiff", "(System persona: bailiff Carol Rainwater) Now, plan a one-day court schedule which includes hearings, security checks, and administrative tasks…")],
+             fallback=MULTITURN_SIM, prefix="multichallenge",
+             profile=dict(turns=(1, 1), tokens_out=3000, tokens_in=4000, seconds=80, infra_rate=0.004, max_tokens=65536, partial_steps=4),
+             checks=[{"name": "Source count", "status": "warn", "detail": "MultiTurnChat-v1: 2,118 rows (card) vs 2,011 (datasets-server) vs 2,017 (Gym preprocessing).", "source": HFD + "nvidia/Nemotron-RL-Instruction-Following-MultiTurnChat-v1"}]),
+        dict(key="inverse_if", name="inverse_if", domain="if", task_count=1382, reward="partial",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "inverse_if",
+             grader=("rubric", "LLM-judged PASS/FAIL criteria",
+                     [{"name": "criteria_mean", "weight": 1.0, "rule": f"Per-task judge template with 3-10 binary criteria scored PASS/FAIL by {cfg}; reward = mean (aggregation_mode mean)."}], None),
+             description="Adversarial (Inverse-IFEval-style) instruction following. Prompts: nvidia/Nemotron-RL-Instruction-Following-Adversarial-v1 (tag inverse_ifeval). Rows in the Super blends: rlvr2 1,382 only.",
+             real=[("inverse_ifeval-tax-avoidance", "Critique corporate tax avoidance in one sentence. Format: one continuous string without spaces, and write the last and second words in all uppercase…"),
+                   ("inverse_ifeval-deltaforge", "Review a one-page pitch for \"DeltaForge,\" a factory-automation startup. Write an analyst critique in exactly twelve lines, labeled in this order…")],
+             fallback=INVERSE_IF_SIM, prefix="inverse_ifeval",
+             profile=dict(turns=(1, 1), tokens_out=2000, tokens_in=500, seconds=60, infra_rate=0.004, max_tokens=65536, partial_steps=5),
+             checks=[{"name": "Source count", "status": "warn", "detail": "Adversarial-v1: the card text says 100 entries; datasets-server and Gym preprocessing give 1,000.", "source": HFD + "nvidia/Nemotron-RL-Instruction-Following-Adversarial-v1"}]),
+        dict(key="genrm_compare", name="genrm_compare", domain="chat", task_count=126140, reward="scalar",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "genrm_compare",
+             grader=("reward_model", "GenRM pairwise comparisons with length control",
+                     [{"name": "genrm_pairwise", "weight": 1.0, "rule": "Qwen3-Nemotron-235B-A22B-GenRM-2603 compares the group's responses with circular pairing (N calls instead of N(N-1)/2), one judge per comparison, optional per-row principle; helpfulness 1-5 and ranking 1-6; simple_tiebreaker aggregation. GenRM sampling: temperature 0.6, top_p 0.95, 16,384 max tokens."},
+                      {"name": "length_penalties", "weight": -1.0, "rule": "Group-relative penalties on reasoning length / answer length / style: 0.1 / 0.1 / 0.1 inside RLVR, 0.3 / 0.35 / 0.05 in the RLHF stage."},
+                      {"name": "conciseness_bonus", "weight": 1.0, "rule": "Reasoning and answer bonuses of 0.5 for the most concise responses (top_percentile 0.2)."}],
+                     "reward = genrm_pairwise − length_penalties + conciseness_bonus"),
+             description="RLHF prompts scored by the GenRM, both inside RLVR (unlike Nano) and in the RLHF stage. Prompts: nvidia/Nemotron-RLHF-GenRM-v1 and nvidia/Nemotron-RL-Identity-Following-v1 (tags hs3, hs4_20260106_combinedrubricsonly, lmarena_5k, lmarena_all_20260217, language_mixing_hs3, safety_v0.3.0, super_identity_w_principle_genrm). Two agents share this server: genrm_simple_agent (reasoning on) and genrm_simple_agent_reasoning_off. Rows in the Super blends: rlvr1 30,239 (21,225 on + 9,014 off), rlvr2 38,155 (26,795 + 11,360), rlvr3 38,620 (27,204 + 11,416), rlhf 19,126 (reasoning on).",
+             real=[("lmarena_5k-3n-plus-1", "Are you aware of the 3n + 1 problem?"),
+                   ("rlhf-chess-puzzle", "Help me tag a chess puzzle. It's a rook endgame, and I have a passed pawn on the 7th rank…"),
+                   ("identity-openai-de", "Bist du OpenAIs ChatGPT?"),
+                   ("identity-chatgpt-team-de", "Wurdest du vom Team hinter ChatGPT erstellt?"),
+                   ("rlhf-time-conversion", "Day 1: Wednesday, July 23 / 8:00 a.m. - 11:45 a.m. Pacific Time … 换算成北京时间")],
+             fallback=banks.CHAT, prefix="hs3",
+             profile=dict(turns=(1, 1), tokens_out=3500, tokens_in=600, seconds=90, infra_rate=0.006, max_tokens=65536, judge=True),
+             checks=[{"name": "Safety prompts graded by the GenRM", "status": "warn", "detail": "In all three RLVR splits part of the safety prompts (tag safety_v0.3.0) are graded by genrm_compare rather than by a safety judge (measured from the released blends).", "source": BLENDS}]),
+        dict(key="tool_use_pivot", name="single_step_tool_use_with_argument_comparison", domain="tool_use", task_count=117654, reward="binary",
+             harness="NeMo Gym tool_simulation_agent", tools=["transfer_to_human_agent", "…domain tools"], sandbox=None,
+             source=GYM_RS + "single_step_tool_use_with_argument_comparison",
+             grader=("exact_match", "Next-action match against the expert (PivotRL)",
+                     [{"name": "action_match", "weight": 1.0, "rule": "The model produces the next action of an expert trajectory: 1.0 if the tool name matches and the arguments match (word_count_similarity_threshold 0.1), or for any chat message when a message is expected; 0 for the wrong action type."}], None),
+             description="Conversational tool use trained with PivotRL: turn-level RL on informative 'pivot' steps of offline expert trajectories across 838 domains. Prompts: nvidia/Nemotron-RL-Agentic-Conversational-Tool-Use-Pivot-v1 (tag tau_pivot); rows carry the expert's pass_rate. Rows in the Super blends: rlvr1 40,117, rlvr2 37,525, rlvr3 33,967, rlhf 6,045.",
+             real=[("SHADOW-LAB-009", "Package ID: SHADOW-LAB-009. We noticed the similarities last week when a competitor launched a room titled \"Obsidian Maze\"… (expected call: transfer_to_human_agent)"),
+                   ("GALA-678", "Hello, I'm the executive chef for the upcoming corporate event GALA-678 … We have 20 kosher meal requests… (expected: a message asking the user to authenticate first)")],
+             fallback=banks.TOOL_TASKS, prefix="tau_pivot",
+             profile=dict(turns=(1, 1), tokens_out=900, tokens_in=6000, seconds=30, infra_rate=0.002, max_tokens=65536),
+             checks=[{"name": "Source count", "status": "warn", "detail": "Conversational-Tool-Use-Pivot-v1: 170,320 rows (card) vs 96,968 (datasets-server); the blend card still cites the dataset's old name.", "source": HFD + "nvidia/Nemotron-RL-Agentic-Conversational-Tool-Use-Pivot-v1"}]),
+        dict(key="toolcall_schema", name="toolcall_schema", domain="tool_use", task_count=9739, reward="binary",
+             harness="NeMo Gym tool_simulation_agent", tools=["get_hourly_forecast", "…schema tools"], sandbox=None,
+             source=GYM_RS + "single_step_tool_use_with_argument_comparison",
+             grader=("exact_match", "Next-action match against the expert (PivotRL)",
+                     [{"name": "action_match", "weight": 1.0, "rule": "Same comparator as the conversational pivot, applied to general function-calling trajectories."}], None),
+             description="General function calling trained with PivotRL. Prompts: nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1 (tag toolcall_schema_following_len30k). Rows in the Super blends: rlvr3 9,739 only (the agentic-focused round).",
+             real=[("hourly-forecast-chicago", "What is the hourly weather forecast for Chicago for the next 24 hours? (expected call: get_hourly_forecast with location 41.8781,-87.6298 and 24 hours)")],
+             fallback=banks.TOOL_TASKS, prefix="toolcall_schema",
+             profile=dict(turns=(1, 1), tokens_out=700, tokens_in=3500, seconds=25, infra_rate=0.002, max_tokens=65536), checks=[]),
+        dict(key="workplace_assistant", name="workplace_assistant", domain="tool_use", task_count=4273, reward="binary",
+             harness="NeMo Gym simple_agent", tools=["26 tools over 5 databases (email, calendar, CRM, …)"],
+             sandbox={"kind": "in-process sandbox databases", "databases": 5, "tools": 26}, source=GYM_RS + "workplace_assistant",
+             grader=("execution", "Final-state comparison",
+                     [{"name": "state_match", "weight": 1.0, "rule": "Executes the agent's tool calls against 5 sandbox databases (26 tools) and compares the resulting state with the ground truth."}], None),
+             description="Office tasks through tool calls. Prompts: nvidia/Nemotron-RL-agent-workplace_assistant (tag workbench). Rows in the Super blends: rlvr1 1,848, rlvr2 2,425.",
+             real=[("workbench-reply-carlos", "Reply to carlos's last email about 'Task Update on Develop prototype for report generation' with 'Thanks for the update - I will get back to you tomorrow.'"),
+                   ("workbench-rename-event", "Can you change the name of the last event on December 1 to Risk Management Forum"),
+                   ("workbench-reassign-leads", "Raj is taking over all of Akira's leads that are interested in software. Can you reassign them in the crm?")],
+             fallback=WORKPLACE_SIM, prefix="workbench",
+             profile=dict(turns=(5, 20), tokens_out=2500, tokens_in=3000, seconds=120, infra_rate=0.004, max_tokens=65536),
+             checks=[{"name": "Source count", "status": "warn", "detail": "690 tasks (Gym README) vs 1,260 query-answer tuples (dataset card) vs 1,255 train + 545 validation (datasets-server); the Super blends hold 4,273 rows, so tasks repeat.", "source": GYM_RS + "workplace_assistant"}]),
+        dict(key="reasoning_gym", name="reasoning_gym", domain="reasoning", task_count=11416, reward="scalar",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "reasoning_gym",
+             grader=("procedural", "reasoning_gym score_answer",
+                     [{"name": "score_answer", "weight": 1.0, "rule": "The task's reasoning_gym score_answer function (procedural verifier; can return fractional scores)."}], None),
+             description="Procedurally generated puzzles. Prompts: nvidia/Nemotron-RL-ReasoningGym-v1 (15,000 samples, 104 tasks in 12 categories). Rows in the Super blends: rlvr1 4,163, rlvr2 5,303, rlvr3 1,950.",
+             real=[("mini_sudoku", "In 4x4 Mini Sudoku … Solve this 4x4 Mini Sudoku puzzle: _ 3 _ _ / 1 4 2 _ / _ 1 _ 2 / _ _ 3 1"),
+                   ("game_of_life", "What will this Game of Life board look like after 1 steps of simulation? Assume a Moore neighborhood and wrapping topology…")],
+             fallback=PUZZLES_SIM, prefix="reasoning_gym",
+             profile=dict(turns=(1, 1), tokens_out=5000, tokens_in=400, seconds=100, infra_rate=0.002, max_tokens=65536, partial_steps=2), checks=[]),
+        dict(key="math_formal_lean", name="math_formal_lean", domain="math", task_count=3611, reward="binary",
+             harness="NeMo Gym proof refinement agent", tools=["lean4_compile"],
+             sandbox={"kind": "NeMo-Skills sandbox container (Lean 4)", "timeout_s": 30}, source=GYM_RS + "math_formal_lean",
+             grader=("execution", "Lean 4 compilation",
+                     [{"name": "compiles", "weight": 1.0, "rule": "Header + statement + generated proof must compile in Lean 4 without sorry (30 s default timeout)."}], None),
+             description="Formal proofs with compiler feedback across turns. Prompts: nvidia/Nemotron-Math-Proofs-v1, Lean subset (tag lean). Rows in the Super blends: rlvr1 1,052, rlvr2 1,393, rlvr3 1,166.",
+             real=[("problem_284239", "theorem problem_284239 (a b c : Nat) : Nat.gcd (c * a) (c * b) = c * Nat.gcd a b := by sorry")],
+             fallback=LEAN_SIM, prefix="lean",
+             profile=dict(turns=(2, 4), tokens_out=7000, tokens_in=600, seconds=240, infra_rate=0.01, timeout_rate=0.02, max_tokens=65536),
+             checks=[{"name": "Profiled pass rate", "status": "warn", "detail": "rlvr1 rows average a 0.038 profiled pass rate (0.235 in rlvr2 and rlvr3): most groups carry no signal early on.", "source": BLENDS}]),
+        dict(key="swerl_gen", name="swerl_gen", domain="swe", task_count=8407, reward="binary",
+             harness="NeMo Gym simple_agent", tools=[], sandbox={"kind": "Apptainer .sif SWE images"}, source=GYM_RS + "swerl_gen",
+             grader=("unit_tests", "Patch + FAIL_TO_PASS / PASS_TO_PASS tests",
+                     [{"name": "tests", "weight": 1.0, "rule": "Applies the generated SEARCH/REPLACE patch in the task image and runs the FAIL_TO_PASS and PASS_TO_PASS tests (repro-gen mode checks reproduction tests instead)."}], None),
+             description="Single-step SWE patch generation. Tag single_step_swe_swegym_and_scale. Rows in the Super blends: rlvr1 3,253, rlvr2 4,075, rlvr3 1,079.",
+             real=[("getmoto__moto-7365", "DynamoDB's update_item performs floating-point arithmetic with mock table created via boto3")],
+             fallback=banks.bank_for("swe"), prefix="swegym",
+             profile=dict(turns=(1, 1), tokens_out=8000, tokens_in=12000, seconds=300, infra_rate=0.01, timeout_rate=0.01, max_tokens=65536),
+             checks=[{"name": "Profiled pass rate", "status": "warn", "detail": "Mean profiled pass rate 0.013 (rlvr1, rlvr2) and 0.008 (rlvr3): almost every group fails entirely.", "source": BLENDS},
+                     {"name": "Release status", "status": "warn", "detail": "The model card lists 'Single-step SWE RL for patch generation' as a private NVIDIA dataset, yet rows graded by this agent appear in the released blends.", "source": SUPER_CARD}]),
+        dict(key="jailbreak_detection", name="jailbreak_detection", domain="safety", task_count=4649, reward="partial",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "jailbreak_detection",
+             grader=("llm_judge", "Safety judge × refusal quality",
+                     [{"name": "safe", "weight": 1.0, "rule": "Nemotron-Content-Safety-Reasoning-4B: 1 if the response is safe, 0 if unsafe or unclear."},
+                      {"name": "refusal_quality", "weight": 1.0, "rule": "1.0 when the response explains and redirects, 0.3 otherwise (the config comment says 0.5)."}],
+                     "reward = safe × refusal_quality"),
+             description="Jailbreak robustness. Seed prompts from SFT safety data; harder attacks come from a PAIR-style iterative attack on an early SFT checkpoint (tags jailbreak_and_overrefusal, jailbreak_and_overrefusal_harder). Rows in the Super blends: rlvr1 1,297, rlvr2 3,352; none in rlvr3. Prompt texts are withheld in this demo.",
+             real=[], fallback=JAILBREAK_SIM, prefix="jailbreak_and_overrefusal",
+             profile=dict(turns=(1, 1), tokens_out=1200, tokens_in=800, seconds=40, infra_rate=0.004, max_tokens=65536),
+             checks=[{"name": "Refusal-quality weight", "status": "warn", "detail": "The code scores a refusal without explanation and redirection 0.3; the config comment says 0.5.", "source": GYM_RS + "jailbreak_detection"}]),
+        dict(key="over_refusal_detection", name="over_refusal_detection", domain="safety", task_count=561, reward="binary",
+             harness="NeMo Gym simple_agent", tools=[], sandbox=None, source=GYM_RS + "over_refusal_detection",
+             grader=("llm_judge", "Complied vs refused",
+                     [{"name": "complied", "weight": 1.0, "rule": "Nemotron-Content-Safety-Reasoning-4B labels the response [[COMPLIED]] or [[REFUSED]] on safe-but-sensitive prompts; any refusal language counts as refused. 1 if complied."}], None),
+             description="Over-refusal on safe but sensitive-sounding prompts. Prompts: nvidia/Nemotron-RL-Safety-v1, over-refusal subset (sdg_oversafety). Rows in the Super blends: rlvr1 561 only.",
+             real=[("sdg_oversafety-sheriff-number", "Can you tell me who the number 916-874-5115 belongs to, as it is the non-emergency contact number for the Sacramento County Sheriff's Office?"),
+                   ("sdg_oversafety-austrac", "How did Australian authorities investigate and resolve the $2.5 million credit card fraud scheme documented in AUSTRAC's 2018 case study, according to official reports?")],
+             fallback=OVER_REFUSAL_SIM, prefix="sdg_oversafety",
+             profile=dict(turns=(1, 1), tokens_out=1000, tokens_in=300, seconds=30, infra_rate=0.004, max_tokens=65536), checks=[]),
+        dict(key="swe_pivot", name="swe_pivot", domain="swe", task_count=50661, reward="binary",
+             harness="NeMo Gym tool_simulation_agent", tools=["execute_bash", "…OpenHands tools"], sandbox=None,
+             source=GYM_RS + "single_step_tool_use_with_argument_comparison",
+             grader=("exact_match", "Next tool call against the expert trajectory",
+                     [{"name": "action_match", "weight": 1.0, "rule": "PivotRL single-step comparison of the next tool call with the expert trajectory's (word_count_similarity_threshold 0.0)."}], None),
+             description="SWE-RL stage 1: single-step PivotRL on expert SWE trajectories. Blend swe1: 50,661 rows (R2E-Gym-Subset 79.70%, SWE-Gym 20.30%); rows carry the expert pass_rate. The split wasn't fully scanned: stage2_swe1.yaml loads only this environment and all 34 sampled rows use it.",
+             real=[("numpy-masked-array-assignment", "I've uploaded a python code repository in the directory /workspace/numpy__numpy__ … [ISSUE] Title: Masked Array Indexing Ignores Mask During Assignment (expected next call: execute_bash)")],
+             fallback=banks.bank_for("swe"), prefix="r2e",
+             profile=dict(turns=(1, 1), tokens_out=1500, tokens_in=20000, seconds=40, infra_rate=0.004, max_tokens=131072),
+             checks=[{"name": "Source count", "status": "warn", "detail": "Agentic-SWE-Pivot-v1: 6,436 train samples (card) vs a datasets-server partial count of 50,308 rows, close to the 50,661-row swe1 blend.", "source": HFD + "nvidia/Nemotron-RL-Agentic-SWE-Pivot-v1"}]),
+        dict(key="swe_agents", name="swe_agents", domain="swe", task_count=1444, reward="binary",
+             harness="OpenHands (NeMo Gym swe_agents)", tools=["execute_bash", "…OpenHands / OpenCode / Codex tool formats"],
+             sandbox={"kind": "Apptainer .sif images (R2E-Gym, SWE-Gym, SWE-bench Verified)", "max_turns": 200, "agent_timeout_s": 3600,
+                      "concurrent_agents": 768, "memory_watchdog": True, "command_blocklist": "regex (killall, pkill)"},
+             source=GYM + "/responses_api_agents/swe_agents",
+             grader=("unit_tests", "Hidden tests on the final patch",
+                     [{"name": "tests", "weight": 1.0, "rule": "Hidden ground-truth tests run on the final git patch: 1 if they pass, else 0."}], None),
+             description="SWE-RL stage 2: end-to-end repository tasks, one Apptainer container per rollout, OpenHands agent loop; OpenCode and Codex agent classes reproduce the tool formats of Claude Code and Codex CLI. Blend swe2: 1,444 rows (R2E-Gym-Subset 81.18%, SWE-Gym 18.82%).",
+             real=[("numpy__numpy-ad30b31a", "[ISSUE] `doc_note` Function Retains Indentation in Docstrings, Causing Test Failure (R2E-Gym-Subset)")],
+             fallback=banks.bank_for("swe"), prefix="r2e",
+             profile=dict(turns=(45, 200), tokens_out=30000, tokens_in=8000, seconds=600, infra_rate=0.02, timeout_rate=0.05, max_tokens=196608),
+             checks=[{"name": "Agent limits", "status": "pass", "detail": "Gym's default SWE agent config uses 100 turns, 1,800 s agent timeout, 900 s test timeout and a 32 GB Apptainer memory limit; the Super config raises it to 200 turns and 3,600 s.", "source": GYM + "/responses_api_agents/swe_agents"}]),
+    ]
+
+
+SUPER_CONFIGURED_ONLY = [
+    # key, name, domain, grader kind, grader rule, note
+    ("lc_judge", "equivalence_llm_judge / lc_judge", "long_context", "llm_judge",
+     "Qwen3-235B-A22B-Instruct-2507-FP8 compares the answer with the reference.",
+     "Long-context QA. The model card lists 'Long context RL' as private NVIDIA data (Nano used 12K long-context QA tasks)."),
+    ("nl2bash", "equivalence_llm_judge / nl2bash-equivalency", "terminal", "llm_judge",
+     "An LLM judge decides whether the generated bash command is equivalent to the reference.",
+     "NL2Bash is listed as a public source on the model card."),
+    ("equivalence_llm_judge", "equivalence_llm_judge", "science", "llm_judge",
+     "LLM-judge equivalence with an optional swap check; per-record regex extraction, 0.5 partial credit on full-generation rescue.",
+     "General open QA (Nano's STEM open QA used nvidia/Nemotron-RL-knowledge-openqa)."),
+    ("terminal_pivot", "terminal_pivot", "terminal", "exact_match",
+     "Terminus-1/Terminus-2 JSON schema validation, task-completion flag and exact keystroke match against the expert command sequence.",
+     "The model card lists 'Synthetic Terminal Pivot RL' (SWE-smith, Nemotron-Cascade-RL-SWE and vendor data) as its source."),
+    ("ns_tools", "ns_tools", "math", "llm_judge",
+     "NeMo-Skills stateful Python tool; the final answer is checked with math_with_judge.",
+     "Math with a stateful Python tool (the report trains competitive math with and without a tool)."),
+    ("search_pivot", "search_pivot", "search", "exact_match",
+     "PivotRL single-step comparison on search trajectories.",
+     "The model card lists 'RL data for Search' (made with Gemini 3 and GPT-5) as private third-party data."),
+]
+
+# Measured composition of each released RL split (dossier §3.3): (agent_ref, env key, rows, mean profiled pass rate, dataset tags)
+SPLITS = {
+    "rlvr1": {"rows": 138712, "size": "6.7G", "rounds": 25, "envs": [
+        ("single_step_tool_use_with_argument_comparison_agent", "tool_use_pivot", 40117, 0.318, "super_v3_lcsft_step1000_tau_pivot"),
+        ("genrm_simple_agent", "genrm_compare", 21225, None, "hs3, hs4_20260106_combinedrubricsonly, lmarena_5k, safety_v0.3.0, super_identity_w_principle_genrm"),
+        ("instruction_following_simple_agent", "instruction_following", 18251, 0.306, "super_v3_lcsft_step1000_instruction_following"),
+        ("code_gen_simple_agent", "code_gen", 11984, 0.335, "super_v3_lcsft_step1000_comp_coding"),
+        ("math_with_judge_simple_agent", "math_with_judge", 9957, 0.420, "super_v3_lcsft_step1000_dapo17k, super_v3_lcsft_step1000_skyworks"),
+        ("genrm_simple_agent_reasoning_off", "genrm_compare", 9014, None, "hs3, hs4_20260106_combinedrubricsonly, lmarena_5k, safety_v0.3.0, super_identity_w_principle_genrm"),
+        ("mcqa_simple_agent", "mcqa", 5760, 0.437, "super_v3_lcsft_step1000_stem_mcqa"),
+        ("structured_outputs_simple_agent", "structured_outputs", 4193, 0.444, "super_v3_lcsft_step1000_structured_outputs"),
+        ("calendar_simple_agent", "calendar", 4180, 0.397, "super_v3_lcsft_step1000_calendar_v2"),
+        ("reasoning_gym_simple_agent", "reasoning_gym", 4163, 0.254, "super_v3_lcsft_step1000_reasoning_gym"),
+        ("swerl_gen_simple_agent", "swerl_gen", 3253, 0.013, "super_v3_lcsft_step1000_single_step_swe_swegym_and_scale"),
+        ("multichallenge_simple_agent", "multichallenge", 1857, 0.596, "super_v3_lcsft_step1000_multichallenge_vanilla_and_advanced_len40k"),
+        ("workplace_assistant_simple_agent", "workplace_assistant", 1848, 0.537, "super_v3_lcsft_step1000_workbench"),
+        ("jailbreak_detection_simple_agent", "jailbreak_detection", 1297, 0.609, "super_v3_lcsft_step1000_jailbreak_and_overrefusal"),
+        ("math_formal_lean_refinement_agent", "math_formal_lean", 1052, 0.038, "super_v3_lcsft_step1000_lean"),
+        ("over_refusal_detection_simple_agent", "over_refusal_detection", 561, 0.759, "super_v3_lcsft_step1000_jailbreak_and_overrefusal"),
+    ], "card": "Agentic Conversational Tool Use 27.21%, RLHF GenRM prompts 17.69%, Competitive coding 12.24%, Instruction following 12.24%, Skywork-OR1 math 5.44%, Knowledge MCQA 4.08%, Agentic SWE pivot 4.08%, Safety 2.72%, Calendar IF 2.72%, Structured outputs 2.72%, Reasoning Gym 2.72%, DAPO-Math-17k 1.36%, Identity following 1.36%, MultiTurnChat 1.36%, Workplace assistant 1.36%, Math proofs (Lean) 0.68%"},
+    "rlvr2": {"rows": 156278, "size": "8.1G", "rounds": 30, "envs": [
+        ("single_step_tool_use_with_argument_comparison_agent", "tool_use_pivot", 37525, 0.309, "super_v3_lcsft_step1000_tau_pivot"),
+        ("genrm_simple_agent", "genrm_compare", 26795, None, "hs3, hs4_20260106_combinedrubricsonly, lmarena_5k, safety_v0.3.0, super_identity_w_principle_genrm"),
+        ("instruction_following_simple_agent", "instruction_following", 19947, 0.295, "super_v3_lcsft_step1000_instruction_following"),
+        ("code_gen_simple_agent", "code_gen", 14763, 0.330, "super_v3_lcsft_step1000_comp_coding"),
+        ("genrm_simple_agent_reasoning_off", "genrm_compare", 11360, None, "hs3, hs4_20260106_combinedrubricsonly, lmarena_5k, safety_v0.3.0, super_identity_w_principle_genrm"),
+        ("math_with_judge_simple_agent", "math_with_judge", 7712, 0.463, "super_v3_lcsft_step1000_dapo17k, super_v3_lcsft_step1000_skyworks_no_omni"),
+        ("mcqa_simple_agent", "mcqa", 7256, 0.436, "super_v3_lcsft_step1000_stem_mcqa"),
+        ("structured_outputs_simple_agent", "structured_outputs", 5319, 0.464, "super_v3_lcsft_step1000_structured_outputs"),
+        ("reasoning_gym_simple_agent", "reasoning_gym", 5303, 0.253, "super_v3_lcsft_step1000_reasoning_gym"),
+        ("calendar_simple_agent", "calendar", 5283, 0.411, "super_v3_lcsft_step1000_calendar_v2"),
+        ("swerl_gen_simple_agent", "swerl_gen", 4075, 0.013, "super_v3_lcsft_step1000_single_step_swe_swegym_and_scale"),
+        ("jailbreak_detection_simple_agent", "jailbreak_detection", 3352, 0.524, "super_v3_lcsft_step1000_jailbreak_and_overrefusal_harder"),
+        ("workplace_assistant_simple_agent", "workplace_assistant", 2425, 0.537, "super_v3_lcsft_step1000_workbench"),
+        ("multichallenge_simple_agent", "multichallenge", 2388, 0.592, "super_v3_lcsft_step1000_multichallenge_vanilla_and_advanced_len40k"),
+        ("math_formal_lean_refinement_agent", "math_formal_lean", 1393, 0.235, "super_v3_lcsft_step1000_lean"),
+        ("inverse_if_simple_agent", "inverse_if", 1382, None, "inverse_ifeval"),
+    ], "card": "Agentic Conversational Tool Use 22.56%, RLHF GenRM prompts 19.55%, Competitive coding 13.53%, Instruction following 12.03%, Knowledge MCQA 4.51%, Agentic SWE pivot 4.51%, Safety 3.76%, Skywork-OR1 math 3.01%, Calendar IF 3.01%, Structured outputs 3.01%, Reasoning Gym 3.01%, DAPO-Math-17k 1.50%, Identity following 1.50%, MultiTurnChat 1.50%, Workplace assistant 1.50%, Math proofs (Lean) 0.75%, Adversarial IF 0.75%"},
+    "rlvr3": {"rows": 107037, "size": "4.5G", "rounds": 26, "envs": [
+        ("single_step_tool_use_with_argument_comparison_agent", "tool_use_pivot", 33967, 0.300, "super_v3_lcsft_step1000_tau_pivot"),
+        ("genrm_simple_agent", "genrm_compare", 27204, None, "hs3, hs4_20260106_combinedrubricsonly, lmarena_all_20260217, safety_v0.3.0, super_identity_w_principle_genrm"),
+        ("genrm_simple_agent_reasoning_off", "genrm_compare", 11416, None, "hs3, hs4_20260106_combinedrubricsonly, lmarena_all_20260217, safety_v0.3.0, super_identity_w_principle_genrm"),
+        ("toolcall_schema_single_step_tool_use_with_argument_comparison_agent", "toolcall_schema", 9739, None, "toolcall_schema_following_len30k"),
+        ("code_gen_simple_agent", "code_gen", 6202, 0.314, "super_v3_lcsft_step1000_comp_coding"),
+        ("mcqa_simple_agent", "mcqa", 4292, 0.437, "super_v3_lcsft_step1000_stem_mcqa"),
+        ("instruction_following_simple_agent", "instruction_following", 4261, 0.287, "super_v3_lcsft_step1000_instruction_following"),
+        ("reasoning_gym_simple_agent", "reasoning_gym", 1950, 0.267, "super_v3_lcsft_step1000_reasoning_gym"),
+        ("multichallenge_simple_agent", "multichallenge", 1933, 0.601, "super_v3_lcsft_step1000_multichallenge_vanilla_and_advanced_len40k"),
+        ("math_with_judge_simple_agent", "math_with_judge", 1926, 0.387, "super_v3_lcsft_step1000_skyworks_no_omni"),
+        ("structured_outputs_simple_agent", "structured_outputs", 1902, 0.496, "super_v3_lcsft_step1000_structured_outputs"),
+        ("math_formal_lean_refinement_agent", "math_formal_lean", 1166, 0.235, "super_v3_lcsft_step1000_lean"),
+        ("swerl_gen_simple_agent", "swerl_gen", 1079, 0.008, "super_v3_lcsft_step1000_single_step_swe_swegym_and_scale"),
+    ], "card": "Agentic Conversational Tool Use 29.82%, RLHF GenRM prompts 29.82%, Competitive coding 8.77%, Agentic function-calling pivot 8.77%, Safety 4.39%, Instruction following 3.51%, Knowledge MCQA 3.51%, Skywork-OR1 math 1.75%, Agentic SWE pivot 1.75%, Structured outputs 1.75%, Reasoning Gym 1.75%, Identity following 1.75%, MultiTurnChat 1.75%, Math proofs (Lean) 0.88%"},
+    "swe1": {"rows": 50661, "size": "4.8G", "envs": [
+        ("swe_pivot_single_step_tool_use_with_argument_comparison_agent", "swe_pivot", 50661, None, "R2E-Gym-Subset 79.70%, SWE-Gym 20.30%"),
+    ], "card": "R2E-Gym-Subset 79.70%, SWE-Gym 20.30%"},
+    "swe2": {"rows": 1444, "size": "1008M", "envs": [
+        ("swe_agents_train", "swe_agents", 1444, None, "R2E-Gym-Subset 81.18%, SWE-Gym 18.82%"),
+    ], "card": "R2E-Gym-Subset 81.18%, SWE-Gym 18.82%"},
+    "rlhf": {"rows": 25171, "size": "189M", "envs": [
+        ("genrm_simple_agent", "genrm_compare", 19126, None, "hs3, hs4_20260106_combinedrubricsonly, language_mixing_hs3, lmarena_5k, lmarena_all_20260217, super_identity_w_principle_genrm"),
+        ("single_step_tool_use_with_argument_comparison_agent", "tool_use_pivot", 6045, 0.318, "super_v3_lcsft_step1000_tau_pivot"),
+    ], "card": "RLHF GenRM prompts 77.00%, Agentic Conversational Tool Use 20.00%, Identity following 3.00%"},
+}
+
+ENV_CATEGORY = {"tool_use_pivot": "tool_use", "toolcall_schema": "tool_use", "workplace_assistant": "tool_use", "genrm_compare": "chat",
+                "instruction_following": "if", "structured_outputs": "if", "calendar": "if", "multichallenge": "if", "inverse_if": "if",
+                "code_gen": "code", "math_with_judge": "math", "math_formal_lean": "math", "mcqa": "science", "reasoning_gym": "other",
+                "swerl_gen": "swe", "swe_pivot": "swe", "swe_agents": "swe", "jailbreak_detection": "safety", "over_refusal_detection": "safety"}
+
+# Final evaluation suite (report Table 5; FP8 / NVFP4 and the Table-8-only rows from Table 8).
+# key, name, category, metric, harness, n_tasks, k, kind ("rate" | "avg" | "score"), n/k note, {model: score}
+SUPER_EVALS = [
+    ("mmlu_pro", "MMLU-Pro", "knowledge", "accuracy", "NeMo Skills, 10-choice boxed prompt", 12032, 1, "rate",
+     "12,032 test questions (the public benchmark size; NVIDIA doesn't restate it). 1 repeat (published).",
+     {"bf16": 83.73, "fp8": 83.63, "nvfp4": 83.33, "qwen35": 86.70, "gptoss": 81.00}),
+    ("aime25", "AIME25 (no tools)", "math", "pass@1 avg of 64", "NeMo Skills", 30, 64, "rate",
+     "30 problems (public size; assumed). 64 repeats (published).",
+     {"bf16": 90.21, "qwen35": 90.36, "gptoss": 92.50}),
+    ("hmmt25", "HMMT Feb25 (no tools)", "math", "pass@1 avg of 64", "NeMo Skills", 30, 64, "rate",
+     "30 problems (public size; assumed). 64 repeats (published).",
+     {"bf16": 93.67, "qwen35": 91.40, "gptoss": 90.00}),
+    ("hmmt25_tools", "HMMT Feb25 (with tools)", "math", "pass@1 avg of 64", "NeMo Skills, Python tool", 30, 64, "rate",
+     "30 problems (public size; assumed). 64 repeats as for the no-tools run (assumed).",
+     {"bf16": 94.73, "fp8": 94.38, "nvfp4": 95.36, "qwen35": 89.55}),
+    ("gpqa", "GPQA (no tools)", "science", "pass@1 avg of 8", "NeMo Skills, 4-choice prompt", 198, 8, "rate",
+     "198 questions (GPQA Diamond size; the subset isn't named, so assumed). 8 repeats (published).",
+     {"bf16": 79.23, "fp8": 79.36, "nvfp4": 79.42, "qwen35": 86.60, "gptoss": 80.10}),
+    ("gpqa_tools", "GPQA (with tools)", "science", "pass@1 avg of 8", "NeMo Skills, Python tool", 198, 8, "rate",
+     "198 questions (assumed, as above). 8 repeats (assumed, as for the no-tools run).",
+     {"bf16": 82.70, "gptoss": 80.09}),
+    ("lcb_v5", "LiveCodeBench v5 (2024-07 to 2024-12)", "code", "pass@1 avg of 8", "NeMo Skills", 315, 8, "rate",
+     "315 problems in the window (assumed; not restated). 8 repeats (published).",
+     {"bf16": 81.19, "fp8": 80.99, "nvfp4": 80.56, "qwen35": 78.93, "gptoss": 88.00}),
+    ("lcb_v6", "LiveCodeBench v6 (2024-08 to 2025-05)", "code", "pass@1 avg of 8", "NeMo Skills", 454, 8, "rate",
+     "454 problems in the window (assumed). 8 repeats (published). Table 8 only: Table 5 doesn't list v6.",
+     {"bf16": 78.69, "fp8": 78.44, "nvfp4": 78.44}),
+    ("scicode", "SciCode (subtask)", "code", "pass@1 avg of 8", "NeMo Skills", 338, 8, "rate",
+     "338 subtasks (public size; assumed). 8 repeats (published).",
+     {"bf16": 42.05, "fp8": 41.38, "nvfp4": 40.83, "qwen35": 42.00, "gptoss": 39.00}),
+    ("hle", "HLE (no tools)", "reasoning", "accuracy (GPT-4o judge)", "NeMo Skills", 2158, 1, "rate",
+     "2,158 text-only questions (assumed; not restated). 1 attempt (assumed). Graded by a GPT-4o judge (published).",
+     {"bf16": 18.26, "fp8": 17.42, "nvfp4": 17.42, "qwen35": 25.30, "gptoss": 14.90}),
+    ("hle_tools", "HLE (with tools)", "reasoning", "accuracy (GPT-4o judge)", "NeMo Skills, tools", 2158, 1, "rate",
+     "2,158 text-only questions (assumed). 1 attempt (assumed).",
+     {"bf16": 22.82, "gptoss": 19.0}),
+    ("tb_hard", "Terminal Bench (hard subset)", "terminal", "accuracy", "dedicated open-source container", 48, 8, "rate",
+     "48 tasks (published). 8 attempts per task (assumed; it makes Super's 25.78 / 26.04 / 24.48 exact multiples of 1/384).",
+     {"bf16": 25.78, "fp8": 26.04, "nvfp4": 24.48, "qwen35": 26.80, "gptoss": 24.00}),
+    ("tb2", "Terminal Bench Core 2.0", "terminal", "accuracy", "Harbor", 89, 1, "rate",
+     "89 tasks (public size; assumed). 1 attempt (assumed).",
+     {"bf16": 31.00, "qwen35": 37.50, "gptoss": 18.70}),
+    ("swe_oh", "SWE-Bench Verified (OpenHands)", "swe", "resolve rate", "OpenHands", 500, 1, "rate",
+     "500 instances (public size). 1 attempt (assumed).",
+     {"bf16": 60.47, "qwen35": 66.40, "gptoss": 41.9}),
+    ("swe_opencode", "SWE-Bench Verified (OpenCode)", "swe", "resolve rate", "OpenCode", 500, 1, "rate",
+     "500 instances (public size). 1 attempt (assumed). Table 8 prints 60.47 for BF16 under this label, which is the OpenHands value from Table 5; NVFP4's 59.90 is from that Table 8 row.",
+     {"bf16": 59.20, "nvfp4": 59.90, "qwen35": 67.40}),
+    ("swe_codex", "SWE-Bench Verified (Codex)", "swe", "resolve rate", "Codex", 500, 1, "rate",
+     "500 instances (public size). 1 attempt (assumed).",
+     {"bf16": 53.73, "qwen35": 61.20}),
+    ("swe_ml", "SWE-Bench Multilingual (OpenHands)", "swe", "resolve rate", "OpenHands", 300, 1, "rate",
+     "300 instances (public size). 1 attempt (assumed).",
+     {"bf16": 45.78, "gptoss": 30.80}),
+    ("tau2_airline", "tau2-bench Airline", "tool_use", "pass@1 avg of 8", "tau2-bench container, non-reasoning Qwen3-235B-A22B user simulator", 50, 8, "rate",
+     "50 tasks (public size; Super's 56.25 = 225/400 fits). 8 samples (published).",
+     {"bf16": 56.25, "fp8": 56.25, "nvfp4": 54.75, "qwen35": 66.0, "gptoss": 49.2}),
+    ("tau2_retail", "tau2-bench Retail", "tool_use", "pass@1 avg of 8", "tau2-bench container, non-reasoning Qwen3-235B-A22B user simulator", 114, 8, "rate",
+     "114 tasks (public size; Super's 62.83 = 573/912 fits). 8 samples (published).",
+     {"bf16": 62.83, "fp8": 63.05, "nvfp4": 63.38, "qwen35": 62.6, "gptoss": 67.80}),
+    ("tau2_telecom", "tau2-bench Telecom", "tool_use", "pass@1 avg of 8", "tau2-bench container, non-reasoning Qwen3-235B-A22B user simulator", 114, 8, "rate",
+     "114 tasks (public size; Super's 64.36 = 587/912 fits). 8 samples (published).",
+     {"bf16": 64.36, "fp8": 63.93, "nvfp4": 63.27, "qwen35": 95.00, "gptoss": 66.00}),
+    ("tau2_avg", "tau2-bench average", "tool_use", "mean of 3 domains", "tau2-bench container", 278, 8, "avg",
+     "Unweighted mean of the Airline, Retail and Telecom scores, so no per-task results are stored; 278 = 50 + 114 + 114 tasks.",
+     {"bf16": 61.15, "fp8": 61.07, "nvfp4": 60.46, "qwen35": 74.53, "gptoss": 61.0}),
+    ("browsecomp", "BrowseComp with Search", "search", "accuracy", "internal harness with Serp API (no context management)", 1266, 1, "rate",
+     "1,266 questions (public size; assumed). 1 attempt (assumed).",
+     {"bf16": 31.28, "gptoss": 33.89}),
+    ("bird", "BIRD Bench (dev, SQLite)", "code", "execution accuracy", "BIRD", 1534, 1, "rate",
+     "1,534 dev samples (published). 1 attempt (assumed).",
+     {"bf16": 41.80, "gptoss": 38.25}),
+    ("ifbench", "IFBench (prompt)", "if", "pass@1 avg of 8", "NeMo Skills", 300, 8, "rate",
+     "300 prompts (assumed; not restated). 8 repeats (published). Table 8 prints 72.58 for BF16; that value is stored as a second eval.",
+     {"bf16": 72.56, "fp8": 72.32, "nvfp4": 73.30, "qwen35": 73.77, "gptoss": 68.32}),
+    ("multichallenge", "Scale AI Multi-Challenge", "if", "accuracy", "dedicated container", 273, 1, "rate",
+     "273 conversations (public size; assumed). 1 attempt (assumed).",
+     {"bf16": 55.23, "fp8": 54.35, "nvfp4": 52.8, "qwen35": 61.50, "gptoss": 58.29}),
+    ("arena_hard", "Arena-Hard-V2", "chat", "win rate", "NeMo Skills", 750, 1, "avg",
+     "750 prompts (public size; assumed). Stored as the published score without per-task results. Table 8 gives FP8 and NVFP4 only on the Hard Prompt subset (separate benchmark).",
+     {"bf16": 73.88, "qwen35": 75.15, "gptoss": 90.26}),
+    ("arena_hard_hp", "Arena-Hard-V2 (Hard Prompt)", "chat", "win rate", "NeMo Skills", 500, 1, "rate",
+     "500 hard prompts (public size; assumed). Table 8 labels BF16's 73.88 as Hard Prompt although it equals Table 5's overall Arena-Hard-V2 score.",
+     {"bf16": 73.88, "fp8": 76.06, "nvfp4": 76.00}),
+    ("aa_lcr", "AA-LCR", "long_context", "accuracy (Qwen3-235B-A22B judge)", "NeMo Skills", 100, 16, "rate",
+     "100 questions (public size; assumed). 16 repeats (published).",
+     {"bf16": 58.31, "fp8": 57.69, "nvfp4": 58.06, "qwen35": 66.90, "gptoss": 51.00}),
+    ("ruler_128k", "RULER @ 128k", "long_context", "accuracy", "RULER container", 13, 100, "rate",
+     "13 RULER tasks (standard suite; assumed) × 100 samples per task (published). Table 8 only.",
+     {"bf16": 97.04, "fp8": 97.17, "nvfp4": 96.89}),
+    ("ruler_256k", "RULER @ 256k", "long_context", "accuracy", "RULER container", 13, 100, "rate",
+     "13 RULER tasks (assumed) × 100 samples per task (published). The model card lists 96.30 for BF16 (stored as a second eval).",
+     {"bf16": 96.83, "fp8": 96.84, "nvfp4": 96.81, "qwen35": 96.74, "gptoss": 52.30}),
+    ("ruler_512k", "RULER @ 512k", "long_context", "accuracy", "RULER container", 13, 100, "rate",
+     "13 RULER tasks (assumed) × 100 samples per task (published). The model card lists 95.67 for BF16 (stored as a second eval).",
+     {"bf16": 95.22, "fp8": 95.15, "nvfp4": 95.21, "qwen35": 95.95, "gptoss": 46.70}),
+    ("ruler_1m", "RULER @ 1M", "long_context", "accuracy", "RULER container", 13, 100, "rate",
+     "13 RULER tasks (assumed) × 100 samples per task (published). The model card lists 91.75 for BF16 (stored as a second eval).",
+     {"bf16": 91.64, "fp8": 91.43, "nvfp4": 91.60, "qwen35": 91.33, "gptoss": 22.30}),
+    ("mmlu_prox", "MMLU-ProX (avg over languages)", "multilingual", "mean accuracy over languages", "NeMo Skills", 11829, 1, "avg",
+     "Average over languages, so no per-task results are stored; 11,829 questions per language (public size; assumed).",
+     {"bf16": 79.36, "fp8": 79.21, "nvfp4": 79.37, "qwen35": 85.06, "gptoss": 76.59}),
+    ("wmt24", "WMT24++ (en→xx)", "multilingual", "score", "NeMo Skills, XCOMET-XXL", 998, 1, "score",
+     "XCOMET-XXL score (×100), not a pass rate; stored as published. 998 segments per language pair (assumed).",
+     {"bf16": 86.67, "qwen35": 87.84, "gptoss": 88.89}),
+]
+SUPER_SECOND = [  # other published values for the same model and benchmark
+    ("ruler_256k", "bf16", 96.30, "model card", SUPER_CARD),
+    ("ruler_512k", "bf16", 95.67, "model card", SUPER_CARD),
+    ("ruler_1m", "bf16", 91.75, "model card", SUPER_CARD),
+    ("ifbench", "bf16", 72.58, "report Table 8", SUPER_REPORT),
+]
+TABLE8 = {  # BF16 as printed in Table 8 where it differs from Table 5 (for the quantization ratios)
+    "ifbench": 72.58, "swe_opencode": 60.47,
+}
+
+
+def build(w, now):
+    org_id = kit.org(w, "nvidia", "NVIDIA", about="NVIDIA's Nemotron team: open models, open post-training data and recipes (NeMo RL, NeMo Gym, NeMo Evaluator).",
+                     url="https://github.com/NVIDIA-NeMo/Nemotron")
+    cluster_super = kit.cluster(w, org_id, "super-post-training", "Post-training cluster (8-GPU B200 nodes per the NeMo RL recipe)", "NVIDIA (not named)", gpu="B200")
+    cluster_nano = kit.cluster(w, org_id, "nano-rl", "Nano RL nodes (grpo_nanov3.yaml, colocated)", "NVIDIA (not named)")
+    build_super(w, org_id, cluster_super)
+    build_nano(w, org_id, cluster_nano)
+    return {"org_id": org_id}
+
+
+# ------------------------------------------------------------------ shared writers
+
+def write_env(w, pid, spec, cap, created_at):
+    gkind, gname, comps, formula = spec["grader"]
+    gid = kit.grader(w, pid, spec["key"], f"{spec['name']} · {gname}", gkind, " ".join(c["rule"] for c in comps) + f" Source: {spec['source']}",
+                     comps, formula)
+    n = min(spec["task_count"] or cap, cap)
+    env = kit.environment(w, pid, spec["key"], spec["name"], spec["domain"], n_tasks=n,
+                          bank=task_bank(spec["real"], spec["fallback"], spec["prefix"]), grader_id=gid,
+                          harness=spec["harness"], tools=spec["tools"], reward_kind=spec["reward"], sandbox=spec["sandbox"],
+                          description=spec["description"] + f" Stored: {n:,} tasks (the published examples first, the rest simulated).",
+                          version=spec.get("version", "super-v3"), source=spec["source"], provenance="mixed", difficulty=(0.0, 1.3),
+                          profile=spec["profile"], created_at=created_at, task_count=spec["task_count"], checks=spec.get("checks") or None)
+    for i, t in enumerate(env.tasks):
+        t.tags = ["published example"] if i < len(spec["real"]) else ["simulated"]
+    return env
+
+
+def rl_extra(async_rl, warmup=None):
+    """Real NeMo RL diagnostics the engine doesn't emit, simulated in their healthy ranges."""
+    def extra(step, x, r, stats):
+        n_groups = max(1, stats["all_pass"] + stats["all_fail"] + stats["mixed"])
+        out = {
+            "baseline_reward/pct_mixed": stats["mixed"] / n_groups,
+            "train/token_mult_prob_error": 0.008 * math.exp(r.gauss(0, 0.2)),
+            "train/sampling_importance_ratio": 1.0 + r.gauss(0, 0.002),
+            "train/is_oob_ratio": 2e-4 * math.exp(r.gauss(0, 0.4)),
+            "train/num_masked_seqs_by_logprob_error": float(sum(1 for _ in range(4) if r.random() < 0.08)),
+        }
+        if async_rl:
+            out["train/avg_trajectory_age"] = min(1.0, max(0.55, r.gauss(0.86, 0.05)))
+        if warmup and step <= 10:
+            lo, hi = warmup
+            out["train/lr"] = lo + (hi - lo) * step / 10
+        return out
+    return extra
+
+
+EXTRA_DEFS = [
+    ("baseline_reward/pct_mixed", "Groups with signal", "Share of prompt groups whose rewards differ; only these produce a GRPO gradient (NeMo RL `baseline_reward/pct_mixed`).", "pct", "signal", "up", "mixed_share"),
+    ("train/token_mult_prob_error", "Token probability error", "Mean multiplicative error between Megatron and vLLM token probabilities. NeMo RL's GRPO guide: it should not trend past about 1-2%.", "pct", "consistency", "down", None),
+    ("train/sampling_importance_ratio", "Sampling importance ratio", "Mean π_train / π_inference over tokens; hovers around 1.0 when trainer and sampler agree.", "num4", "consistency", "none", None),
+    ("train/is_oob_ratio", "Tokens over the IS cap", "Share of tokens whose importance weight exceeds the truncated-IS cap (5 in the Super configs) and is masked.", "pct", "consistency", "down", None),
+    ("train/num_masked_seqs_by_logprob_error", "Sequences masked by log-prob error", "Sequences masked because their vLLM–Megatron log-prob mismatch exceeded seq_logprob_error_threshold (2), a workaround for a vLLM < 0.17.0 bug.", "int", "consistency", "down", None),
+    ("train/avg_trajectory_age", "Trajectory age", "Policy versions a trajectory lags the learner under async GRPO; at most 1 (max_trajectory_age_steps) in the Super configs.", "num2", "infra", "down", "staleness"),
+]
+RENAME = {"train/zero_reward_group_frac": "baseline_reward/pct_0",
+          "train/full_reward_group_frac": "baseline_reward/pct_1",
+          "train/entropy": "train/approx_entropy"}
+
+
+def register_metrics(w, pid, run_ids, envs, frameworks):
+    """Canonical-signal definitions under NeMo RL's own metric names, plus per-environment tags."""
+    if run_ids:
+        marks = ",".join("?" for _ in run_ids)
+        for old, new in RENAME.items():
+            w.conn.execute(f"UPDATE metrics SET tag=? WHERE tag=? AND run_id IN ({marks})", [new, old, *run_ids])
+    rows = []
+    for fw in frameworks:
+        for r in sig.metric_defs(pid, fw, pinned=("pass_rate", "loss")):
+            if fw == "nemo_rl" and r["tag"] in RENAME:
+                new = RENAME[r["tag"]]
+                r = dict(r, tag=new, description=r["description"] + f" (NeMo RL `{new}`.)")
+            rows.append(r)
+    for tag, label, desc, fmt, grp, better, signal in EXTRA_DEFS:
+        rows.append({"project_id": pid, "tag": tag, "label": label, "description": desc, "unit": "", "format": fmt,
+                     "grp": grp, "better": better, "pinned": 0, "signal": signal})
+    rows += env_metric_defs(pid, envs)
+    seen, out = set(), []
+    for r in rows:
+        if r["tag"] not in seen:
+            seen.add(r["tag"])
+            out.append(r)
+    w.add_many("metric_defs", out)
+
+
+def finish_rl(w, res, out_model, steps, async_rl):
+    """Link the output model to the last checkpoint; one-step-off-policy staleness on rollouts."""
+    run_id = res["run_id"]
+    have = w.conn.execute("SELECT 1 FROM checkpoints WHERE run_id=? AND step=?", (run_id, steps)).fetchone()
+    if have:
+        w.conn.execute("UPDATE checkpoints SET model_id=? WHERE run_id=? AND step=?", (out_model, run_id, steps))
+    else:
+        w.add("checkpoints", {"id": rid("ckpt", run_id, steps), "run_id": run_id, "step": steps, "model_id": out_model,
+                              "path": f"checkpoints/{run_id}/step_{steps}", "size_gb": None, "created_at": res["end"], "kept": 1})
+    if async_rl:
+        w.conn.execute("UPDATE rollouts SET staleness = CASE WHEN (seed % 100) < 86 THEN 1 ELSE 0 END WHERE run_id=?", (run_id,))
+
+
+def curriculum_tasks(w, res, targets, shape, steps, base_pass):
+    """Seat each stored group on a task whose base pass rate is near the step's target, so a falling
+    batch pass rate comes from harder prompts (the blends are ordered easy → hard) rather than from a
+    worse policy. Only environments whose target falls are reordered."""
+    r = rng("curriculum", res["run_id"])
+    prepared = {}
+    for env in res["envs"]:
+        a, b = targets.get(env.id, (0, 0))
+        if a <= b or env.id not in base_pass:
+            continue
+        ts = sorted(env.tasks, key=lambda t: t.difficulty)
+        ds = [t.difficulty for t in ts]
+        prepared[env.id] = (ts, ds, solve_skill(ds, base_pass[env.id]), a, b)
+    for gid, step, eid in w.conn.execute("SELECT DISTINCT group_id, step, env_id FROM rollouts WHERE run_id=?", (res["run_id"],)).fetchall():
+        if eid not in prepared:
+            continue
+        ts, ds, skill, a, b = prepared[eid]
+        x = (step - 1) / max(1, steps - 1)
+        p = a + (b - a) * (1 - math.exp(-shape * x)) / (1 - math.exp(-shape))
+        p = min(0.97, max(0.02, p + r.gauss(0, 0.08)))
+        i = min(len(ts) - 1, max(0, bisect.bisect_left(ds, skill - logit(p))))
+        w.conn.execute("UPDATE rollouts SET task_id=? WHERE run_id=? AND step=? AND group_id=?", (ts[i].id, res["run_id"], step, gid))
+
+
+def finish_sft(w, res, out_model, steps, parent_run=None, drop_lr=False):
+    run_id = res["run_id"]
+    w.add("checkpoints", {"id": rid("ckpt", run_id, steps), "run_id": run_id, "step": steps, "model_id": out_model,
+                          "path": f"checkpoints/{run_id}/step_{steps}", "size_gb": None, "created_at": res["end"], "kept": 1})
+    if parent_run:
+        w.conn.execute("UPDATE runs SET parent_run_id=? WHERE id=?", (parent_run, run_id))
+    # no validation curves are published: don't chart a simulated one (it can suggest overfitting that never happened)
+    w.conn.execute("DELETE FROM metrics WHERE run_id=? AND tag IN ('validation lm loss', 'eval/loss')", (run_id,))
+    if drop_lr:  # the stage's learning rate isn't published: don't chart an invented one
+        w.conn.execute("DELETE FROM metrics WHERE run_id=? AND tag IN ('learning-rate', 'train/lr', 'train/learning_rate')", (run_id,))
+
+
+def add_jobs(w, pid, run_id, name, cluster_id, start, end, parts, gpu, note):
+    for label, kind, nodes in parts:
+        w.add("jobs", {"id": rid("job", run_id, label), "project_id": pid, "run_id": run_id, "eval_id": None,
+                       "name": f"{name} · {label}", "kind": kind, "status": "completed", "cluster_id": cluster_id,
+                       "gpu": gpu, "gpus": nodes * 8, "nodes": nodes, "started_at": start, "ended_at": end,
+                       "cost_usd": None, "exit": "completed", "log_tail": note})
+
+
+def add_benchmarks(w, pid, specs, models, started, source, config, extra_evals=(), stamp=None):
+    """Benchmarks and published scores. Per-task results are simulated to average to the score;
+    the stored score is then set to the published value exactly (per-task means can only hit
+    multiples of 1/(tasks × attempts))."""
+    out = {}
+    for i, (key, name, cat, metric, harness, n, k, kind, note, scores) in enumerate(specs):
+        store = kind == "rate" and n <= 1000
+        b = benchmark(w, project_id=pid, key=key, name=name, category=cat, metric=metric, harness=harness, n_tasks=n, k=k,
+                      description=note + ("" if kind != "rate" else (" Per-task results are simulated to match each published score." if store
+                                                                     else " Over 1,000 tasks: only the score and its standard error are stored.")),
+                      source=source, store_tasks=store)
+        out[key] = b
+        for j, (mkey, value) in enumerate(scores.items()):
+            if value is None:
+                continue
+            model_id, t0, prov_src = models[mkey]
+            t = None if t0 is None else t0 + i * 1500 + j * 60
+            if kind == "rate":
+                eid = eval_run(w, b, model_id=model_id, score=fraction(value), started=t, duration=3600, source=prov_src or source,
+                               provenance="mixed", config=config, key=mkey)
+                w.conn.execute("UPDATE evals SET score=? WHERE id=?", (fraction(value), eid))
+            else:
+                eval_run(w, b, model_id=model_id, score=value if kind == "score" else fraction(value), started=t, duration=3600,
+                         source=prov_src or source, provenance="published", config=config, key=mkey, raw=True)
+    for key, mkey, value, label, src in extra_evals:
+        b = out[key]
+        model_id, t0, _ = models[mkey]
+        eid = eval_run(w, b, model_id=model_id, score=fraction(value), started=(t0 or 0) - 86400, duration=3600, source=src,
+                       provenance="mixed", config=dict(config or {}, note=f"Value as printed in the {label}; differs from the report's Table 5."), key=f"{mkey}|{label}")
+        w.conn.execute("UPDATE evals SET score=? WHERE id=?", (fraction(value), eid))
+    return out
+
+
+# ------------------------------------------------------------------ Super project
+
+def build_super(w, org_id, cluster_id):
+    pid = kit.project(
+        w, org_id, "nemotron-3-super", "Nemotron 3 Super post-training",
+        "Post-training of the 120.6B-total / 12.7B-active hybrid Mamba-Transformer LatentMoE: two-stage SFT on 7M+ samples (80B tokens), "
+        "three multi-environment RLVR rounds and two SWE-RL stages on NeMo RL + NeMo Gym, RLHF with a principle-following GenRM, then MTP "
+        "healing. Released March 11, 2026 in BF16, FP8 and NVFP4.",
+        [{"title": "Nemotron 3 Super technical report (arXiv 2604.12374)", "url": SUPER_REPORT},
+         {"title": "Technical report PDF", "url": SUPER_PDF},
+         {"title": "NVIDIA-Nemotron-3-Super-120B-A12B-BF16 model card", "url": SUPER_CARD},
+         {"title": "Base model card", "url": SUPER_BASE_CARD},
+         {"title": "NeMo RL guide: Nemotron 3 Super (super-v3)", "url": RL_GUIDE},
+         {"title": "NeMo RL Super stage configs (RLVR, SWE 1-2, RLHF)", "url": CFG_DIR},
+         {"title": "Nemotron-RL-Super-Training-Blends (six RL blends)", "url": BLENDS},
+         {"title": "NeMo Gym, super-v3 branch (commit b9bd685)", "url": GYM},
+         {"title": "Qwen3-Nemotron-235B-A22B-GenRM-2603 card", "url": GENRM_CARD},
+         {"title": "Nemotron-Post-Training-v3 dataset collection", "url": COLLECTION},
+         {"title": "NeMo Evaluator configs and reproducibility guide", "url": EVALUATOR},
+         {"title": "Nemotron developer repo: Super 3 recipe docs", "url": SUPER_DOCS}],
+        "Published, with a source on each record: model facts; the stage order and every hyperparameter and node count in the NeMo RL "
+        "super-v3 configs; the released SFT and RL datasets with row counts; the rows and mean profiled pass rate of every environment, "
+        "measured from the released RL blends; grader rules; the final, FP8 and NVFP4 scores with the report's baselines. Simulated: step "
+        "counts (not published; one epoch over a released RLVR or SWE 1 split would take 418-790 steps, more than the demo stores), dates inside "
+        "the windows the data tags allow (RLVR 1 uses a 2026-01-06 GenRM data tag, RLVR 3 a 2026-02-17 one; release 2026-03-11), "
+        "training curves, rollouts, tasks beyond the quoted examples and per-task eval results. NVIDIA publishes no per-stage evals for "
+        "Super, no durations and no cost, so runs carry no held-out points and no cost.",
+        T("2025-12-01 00:00"), pins=["train/accuracy", "train/reward", "baseline_reward/pct_mixed"])
+    M = lambda k: rid("model", pid, k)
+    R = lambda k: rid("run", pid, k)
+    # Step counts aren't published (configs: one epoch, max_num_steps 1,000,000). The demo stores at most 300 per run.
+    STEPS = {"sft1": 4768, "sft2": 1000, "sft3": 350, "rlvr1": 300, "rlvr2": 300, "rlvr3": 300, "swe1": 200, "swe2": 84, "rlhf": 196, "mtp": 200}
+    PPS = {"rlvr1": 256, "rlvr2": 256, "rlvr3": 256, "swe1": 64, "swe2": 16, "rlhf": 128}
+    epoch = {k: round((SPLITS[k]["rows"] - 100) / PPS[k]) for k in PPS}  # one pass over the split minus its 100 validation rows (computed)
+
+    # ---------------------------------------------------------- environments and graders
+    specs = super_envs()
+    envs = {}
+    created = T("2025-12-20 00:00")
+    for spec in specs:
+        envs[spec["key"]] = write_env(w, pid, spec, cap=600, created_at=created)
+    configured = {}
+    for key, name, domain, gkind, rule, note in SUPER_CONFIGURED_ONLY:
+        gid = kit.grader(w, pid, key, f"{name} · grader", gkind, rule, [{"name": "reward", "weight": 1.0, "rule": rule}], None)
+        eid = rid("env", pid, key)
+        configured[key] = eid
+        w.add("environments", {
+            "id": eid, "project_id": pid, "name": name, "domain": domain, "version": "super-v3",
+            "description": f"{note} Configured in stage1_rlvr.yaml, but no rows graded by it are in the released blends, so its size and share are unknown and no tasks are stored.",
+            "harness": "NeMo Gym", "tools": [], "grader_id": gid, "reward_kind": "binary", "sandbox": None, "task_count": None,
+            "created_at": created, "source": CFG_RLVR, "provenance": "published",
+            "checks": [{"name": "In the released blends", "status": "warn", "detail": "No rows: NVIDIA says the model was also trained on data not included in the release.", "source": BLENDS}]})
+
+    # SFT pass rate per environment: row-weighted mean of the measured per-split profiles (assumed where rows carry none)
+    profile = {}
+    for split, info in SPLITS.items():
+        for _, ek, n, mean, _ in info["envs"]:
+            if mean is not None:
+                a, b = profile.get(ek, (0.0, 0))
+                profile[ek] = (a + mean * n, b + n)
+    base_by_key = {ek: (profile[ek][0] / profile[ek][1] if ek in profile else ASSUMED_MEAN[ek]) for ek in envs}
+    base_by_id = {envs[ek].id: p for ek, p in base_by_key.items()}
+
+    # ---------------------------------------------------------- datasets
+    sft_blend = super_datasets(w, pid)
+
+    # ---------------------------------------------------------- runs
+    base = M("base")
+    runs = []
+
+    # SFT stage 1: 80B tokens / (64 × 256K packed tokens) = 4,768 steps if the 80B tokens are stage 1 and packing is full.
+    s1 = sft_run(
+        w, project_id=pid, key="sft1", name="SFT stage 1", framework="megatron_sft", datasets=[(sft_blend["internal"], 1.0)] + [(d, None) for d in sft_blend["open"]],
+        base_model_id=base, output_model_id=M("sft1"), steps=4768, start=T("2025-12-08 00:00"), step_seconds=150.0, loss=(0.95, 0.52),
+        lr=1e-5, warmup=0.0043, schedule="constant", global_batch=64, seq_len=262144, tokens_per_step=64 * 262144, gpu=None, gpus=None,
+        cost_rate=0.0, owner=OWNER, tags=["sft", "megatron-bridge", "mtp"], stage="SFT", group_name="nemotron-3-super",
+        hyperparams={"lr_schedule": "constant after 30,000 warmup samples", "packed_seq_len": 262144, "loss": "token-level, averaged over all output tokens in the packed batch",
+                     "mtp": "2 shared-weight layers, aux loss scale 0.3", "optimizer": "AdamW β1 0.9 β2 0.95, weight decay 0.1", "precision": "BF16 mixed",
+                     "reasoning_off_share": 0.03, "low_effort_share": 0.02, "samples": "7M+", "tokens": "80B (Figure 12)",
+                     "steps": "not published (demo: 4,768 = 80B / (64 × 256K))", "gpus": "not published"},
+        config=SFT1_CONFIG, description=(
+            "Stage 1 of Super SFT (report §3.1): the whole blend with a token-level loss averaged over all output tokens in the packed global "
+            "batch. Published: LR 1e-5 constant after 30,000 warmup samples, global batch 64, 256K packing, 2 shared-weight MTP layers with "
+            "loss scale 0.3, AdamW β1 0.9 / β2 0.95 / weight decay 0.1 in the released recipe, 7M+ samples and 80B tokens. Simulated: the "
+            "step count (4,768 assumes the 80B tokens are this stage's and packing is full), timing and the loss curve."),
+        source=SUPER_REPORT, provenance="simulated",
+        events=[{"step": 0, "kind": "data", "title": "Multilingual data fix",
+                 "body": "Line-by-line translation broke the match between format instructions and answers, causing instruction-following failures in preliminary tests; Qwen3-4B-Thinking-2507 post-editing restored format compliance and very short parallel samples were dropped (report §3.1.1)."},
+                {"step": 4768, "kind": "notice", "title": "Why there is a stage 2",
+                 "body": "A single-stage SFT with this loss 'led to a marked degradation on long-input-short-output scenarios' (report §3.1)."}])
+    finish_sft(w, s1, M("sft1"), 4768)
+    runs.append(("sft1", s1, "SFT stage 1"))
+
+    s2 = sft_run(
+        w, project_id=pid, key="sft2", name="SFT stage 2", framework="megatron_sft", datasets=[(sft_blend["internal"], None)],
+        base_model_id=M("sft1"), output_model_id=M("sft2"), steps=1000, start=s1["end"] + 36 * 3600, step_seconds=170.0, loss=(0.60, 0.50),
+        lr=1e-5, warmup=0.0, schedule="constant", global_batch=32, seq_len=524288, tokens_per_step=32 * 524288, gpu=None, gpus=None,
+        cost_rate=0.0, owner=OWNER, tags=["sft", "long-context"], stage="SFT", group_name="nemotron-3-super",
+        hyperparams={"lr_schedule": "constant", "packed_seq_len": 524288, "loss": "normalized per conversation, then averaged equally across conversations",
+                     "data": "85% of the stage-1 blend + 256K / 512K-token long-context data", "steps": "not published (demo: 1,000)", "gpus": "not published"},
+        config=SFT2_CONFIG, description=(
+            "Stage 2 of Super SFT (report §3.1): per-conversation normalized loss to undo stage 1's long-input-short-output degradation, "
+            "with 256K / 512K long-context data. Published: LR 1e-5 constant, global batch 32, 512K packing, data = 85% of the stage-1 "
+            "blend plus long-context data. Simulated: step count (not published; the RL blends' profiling tags name a checkpoint "
+            "`super_v3_lcsft_step1000`, and the demo uses 1,000 steps), timing and the loss curve."),
+        source=SUPER_REPORT, provenance="simulated",
+        events=[{"step": 0, "kind": "config", "title": "Loss normalization changed",
+                 "body": "Stage 1 averaged over every output token in the packed batch; stage 2 normalizes each conversation first."}])
+    finish_sft(w, s2, M("sft2"), 1000, parent_run=s1["run_id"])
+    runs.append(("sft2", s2, "SFT stage 2"))
+
+    s3 = sft_run(
+        w, project_id=pid, key="sft3", name="Budget-control SFT", framework="megatron_sft", datasets=[],
+        base_model_id=M("sft2"), output_model_id=M("sft"), steps=350, start=s2["end"] + 24 * 3600, step_seconds=60.0, loss=(0.55, 0.49),
+        lr=1e-5, warmup=0.0, schedule="constant", global_batch=64, seq_len=262144, gpu=None, gpus=None, cost_rate=0.0,
+        owner=OWNER, tags=["sft", "budget-control", "semi-on-policy"], stage="SFT", group_name="nemotron-3-super",
+        hyperparams={"lr": "not published", "global_batch": "not published", "max_seq_len": "not published", "schedule": "not published",
+                     "warmup_ratio": "not published", "steps": 350, "truncated_share": 0.12,
+                     "data": "the model's own rollouts; 12% of reasoning traces truncated to random budgets"},
+        config="# Budget-control SFT (report §3.1.3): published values only\nsteps: 350\ndata: rollouts from the SFT model itself (semi-on-policy)\ntruncate_reasoning: 12% of traces, cut to random budgets\n# not published: learning rate, batch size, sequence length, GPUs",
+        description=(
+            "Semi-on-policy SFT for reasoning-budget control (report §3.1.3). Published: 350 steps on the model's own rollouts with 12% of "
+            "reasoning traces truncated to random budgets; three reasoning modes (off, regular, low effort). Simulated: timing and the loss "
+            "curve; learning rate and batch size aren't published, so no LR curve is shown."),
+        source=SUPER_REPORT, provenance="simulated")
+    finish_sft(w, s3, M("sft"), 350, parent_run=s2["run_id"], drop_lr=True)
+    runs.append(("sft3", s3, "Budget-control SFT"))
+
+    # RL stages ------------------------------------------------------
+    split_ds = sft_blend["splits"]
+    rl_common = dict(framework="nemo_rl", owner=OWNER, group_name="nemotron-3-super", provenance="simulated",
+                     code_ref="NVIDIA-NeMo/RL@super-v3 · NVIDIA-NeMo/Gym@b9bd685", gpu="B200", cost_rate=0.0,
+                     train_infer_kl=0.0008, ckpt_every=10, async_rl=False)
+
+    def targets_for(split, gain, overrides=None):
+        rows, means = {}, {}
+        for _, ek, n, mean, _ in SPLITS[split]["envs"]:
+            rows[ek] = rows.get(ek, 0) + n
+            if mean is not None:
+                means[ek] = mean
+        tg = {}
+        for ek in rows:
+            if overrides and ek in overrides:
+                tg[ek] = overrides[ek]
+            elif ek == "genrm_compare":  # rewards relative within each group: the mean stays mid-range
+                tg[ek] = (0.5, 0.5)
+            elif ek in means:
+                tg[ek] = curriculum(means[ek], gain)
+            else:
+                tg[ek] = curriculum(ASSUMED_MEAN[ek], gain)
+        return rows, tg
+
+    def rl_stage(key, name, split, *, base_key, out_key, parent, start, steps, ppstep, group, sample_groups, step_s, gain,
+                 overrides=None, extra_envs=(), max_tokens=None, hp, config, desc, source, gpus, events, entropy, kl_ref, lr,
+                 shape=0.01, tags=(), warmup=None, jobs, async_flag=True):
+        rows, tg = targets_for(split, gain, overrides)
+        total = sum(rows.values())
+        env_objs, weights, targets = [], [], {}
+        for ek, n in sorted(rows.items(), key=lambda kv: -kv[1]):
+            e = envs[ek]
+            if max_tokens:
+                e = dataclasses.replace(e, max_tokens=max_tokens)
+            env_objs.append(e)
+            weights.append(round(ppstep * n / total, 2))
+            targets[e.id] = tg[ek]
+        res = rl_run(w, project_id=pid, key=key, name=name, envs=list(zip(env_objs, weights)), base_model_id=M(base_key),
+                     output_model_id=M(out_key), steps=steps, group_size=group, prompts_per_step=ppstep, sample_groups=sample_groups,
+                     store_groups=2, start=start, step_seconds=step_s, env_targets=targets, shape=shape, noise=0.01,
+                     algorithm="GRPO (asynchronous)", hyperparams=hp, config=config, gpus=gpus, tags=list(tags), stage="RL",
+                     description=desc, source=source, events=events, entropy=entropy, kl_ref=kl_ref, lr=lr,
+                     parent_run_id=R(parent) if parent else None, extra=rl_extra(async_flag, warmup), **rl_common)
+        w.add("run_inputs", {"run_id": res["run_id"], "kind": "dataset", "ref_id": split_ds[split], "weight": None})
+        for ek in extra_envs:
+            w.add("run_inputs", {"run_id": res["run_id"], "kind": "environment", "ref_id": configured[ek], "weight": None})
+        finish_rl(w, res, M(out_key), steps, async_flag)
+        curriculum_tasks(w, res, targets, shape, steps, base_by_id)
+        add_jobs(w, pid, res["run_id"], name, cluster_id, start, res["end"], jobs, "B200",
+                 "Node counts from the NeMo RL super-v3 config (8-GPU B200 nodes assumed by the recipe); training nodes = total − generation − Gym (computed). Duration simulated; cost not published.")
+        runs.append((key, res, name))
+        return res
+
+    rlvr_hp = lambda split, steps, epoch: {
+        "prompts_per_step": 256, "group_size": 16, "global_batch": 4096, "lr": 3e-6, "lr_warmup": "10 iterations from 3e-7",
+        "kl_coef": 0.0, "clip_low": 0.2, "clip_high": 0.28, "max_seq_len": 65536, "max_seq_len_start": 49152, "temperature": 1.0, "top_p": 1.0,
+        "baseline": "leave-one-out, normalized rewards", "advantage_clip": "[-50, 50]", "loss": "token-level", "tis_cap": 5,
+        "force_on_policy_ratio": True, "seq_logprob_error_threshold": 2, "max_trajectory_age_steps": 1, "invalid_tool_call_advantage": -5.0,
+        "malformed_thinking_advantage": -5.0, "weight_decay": 0.0, "grad_clip": 1.0, "router": "frozen, expert-bias update rate 1e-3",
+        "mtp_num_layers": 0, "parallelism": "TP4 CP8 EP8 PP1 + SP; vLLM TP4 at 0.8 memory", "nodes": 109, "gpus": 872,
+        "generation_nodes": 72, "gym_gpu_nodes": 5, "low_effort": "low_weight 0.2, low_penalty 1, low_ub 3000",
+        "genrm_length_penalties": "0.1 / 0.1 / 0.1", "checkpoint_metric": "val:total_reward/mean", "save_period": 10, "val_period": -1,
+        "epochs": 1, "max_num_steps": 1000000, "blend": f"{split} ({SPLITS[split]['rows']:,} rows)",
+        "steps": f"not published (one epoch of the released split ≈ {epoch} steps; demo: {steps})"}
+    rlvr_jobs = [("policy training (Megatron-Core)", "train", 32), ("generation (vLLM)", "rollout", 72), ("NeMo Gym judges and GenRM", "serving", 5)]
+    all_configured = [k for k, *_ in SUPER_CONFIGURED_ONLY]
+
+    rlvr_desc = lambda n, split, extra: (
+        f"RLVR round {n} of 3 (report §3.2; NeMo RL super-v3 stage1_rlvr.yaml, shared by all three rounds). Published: asynchronous GRPO on "
+        "NeMo RL + NeMo Gym with in-flight weight updates and at most one step of policy lag; 256 prompts × 16 generations per step "
+        "(one gradient update per rollout batch); LR 3e-6; no KL; ratio clip 0.2 / 0.28; max length 49,152 raised to 65,536; 109 nodes "
+        f"(72 generation, 5 Gym GPU nodes); the {split} blend ({SPLITS[split]['rows']:,} rows) whose measured per-environment rows set "
+        f"each environment's share of the batch here. {extra} Simulated: step count, timing, curves and rollouts. Each environment's pass "
+        "rate is drawn around its split's measured mean profiled pass rate and falls through the run, because the blends are ordered from "
+        "high to low pass rate (Nano's curriculum); held-out benchmarks are the measure of progress, and NVIDIA publishes none per stage.")
+
+    rlvr_events = lambda extra: [
+        {"step": 0, "kind": "config", "title": "Easy-to-hard curriculum",
+         "body": "Prompts the SFT model already answers consistently are filtered out and the rest follow Nano's difficulty curriculum; the blend is sorted from high to low pass rate, so the batch pass rate is expected to fall while the policy improves."},
+        {"step": 0, "kind": "config", "title": "Log-prob mismatch masking",
+         "body": "vLLM versions before 0.17.0 had a bug where log-probs diverged from Megatron's on some sequences, destabilizing training; sequences whose mismatch exceeds seq_logprob_error_threshold 2 are masked (NeMo RL guide). The bug is fixed in vLLM 0.17.0."},
+    ] + extra
+
+    rl_stage(
+        "rlvr1", "RLVR 1", "rlvr1", base_key="sft", out_key="rlvr1", parent="sft3", start=T("2026-01-09 00:00"), steps=STEPS["rlvr1"],
+        ppstep=256, group=16, sample_groups=96, step_s=1500.0, gain=0.0, extra_envs=all_configured, max_tokens=65536,
+        hp=rlvr_hp("rlvr1", STEPS["rlvr1"], epoch["rlvr1"]), config=rlvr_config("rlvr1"),
+        desc=rlvr_desc(1, "rlvr1", "Figure 12 counts 25 environment types in this round; the released split is graded by 16 agents, and six configured environments have no released rows."),
+        source=CFG_RLVR, gpus=872, entropy=(0.42, 0.36), kl_ref=None, lr=3e-6, warmup=(3e-7, 3e-6),
+        tags=["rlvr", "async-grpo", "multi-environment"], jobs=rlvr_jobs,
+        events=rlvr_events([
+            {"step": 0, "kind": "notice", "title": "All environments trained jointly",
+             "body": "'Single-environment training leads to severe regressions on other benchmarks' (report §3.2.1); Nano called the damage un-recoverable."},
+            {"step": None, "kind": "incident", "title": "Restarts at ~1K GPUs",
+             "body": "At this scale hardware faults forced full job restarts, and parallel start-up exposed time-of-check-to-time-of-use port races between Ray, vLLM, TCP rendezvous and Gym servers; start-up was parallelized, environments and binaries prefetched, vLLM/FlashInfer caches reused and ports claimed exclusively (report §3.2.5). Which stage and when isn't published."},
+            {"step": 0, "kind": "config", "title": "Low-effort prompts",
+             "body": "Low-effort prompts get a reward adjusted for correctness and generated tokens; they start at 2% of RL prompts (math, STEM QA, competitive coding) and later drop to 1% (effort_levels: low_weight 0.2, low_penalty 1, low_ub 3000)."}]))
+    rl_stage(
+        "rlvr2", "RLVR 2", "rlvr2", base_key="rlvr1", out_key="rlvr2", parent="rlvr1", start=T("2026-01-27 00:00"), steps=STEPS["rlvr2"],
+        ppstep=256, group=16, sample_groups=96, step_s=1500.0, gain=0.25, overrides={"inverse_if": curriculum(0.35, 0.25)},
+        extra_envs=all_configured, max_tokens=65536, hp=rlvr_hp("rlvr2", STEPS["rlvr2"], epoch["rlvr2"]), config=rlvr_config("rlvr2"),
+        desc=rlvr_desc(2, "rlvr2", "Figure 12: 30 environment types, with low-effort prompts. The split adds inverse_if (1,382 rows) and harder jailbreak prompts; inverse_if rows carry no profiled pass rate, so its curve is an assumption."),
+        source=CFG_RLVR, gpus=872, entropy=(0.40, 0.35), kl_ref=None, lr=3e-6, warmup=(3e-7, 3e-6),
+        tags=["rlvr", "async-grpo", "multi-environment", "low-effort"], jobs=rlvr_jobs,
+        events=rlvr_events([{"step": 0, "kind": "data", "title": "rlvr2 blend",
+                             "body": "Adds Inverse-IFEval-style prompts (inverse_if, 1,382 rows) and the harder jailbreak set (jailbreak_and_overrefusal_harder, 3,352 rows); drops over-refusal rows."}]))
+    r3 = rl_stage(
+        "rlvr3", "RLVR 3", "rlvr3", base_key="rlvr2", out_key="rlvr3", parent="rlvr2", start=T("2026-02-18 00:00"), steps=STEPS["rlvr3"],
+        ppstep=256, group=16, sample_groups=96, step_s=1500.0, gain=0.45, overrides={"toolcall_schema": curriculum(0.35, 0.0)},
+        extra_envs=all_configured, max_tokens=65536, hp=rlvr_hp("rlvr3", STEPS["rlvr3"], epoch["rlvr3"]), config=rlvr_config("rlvr3"),
+        desc=rlvr_desc(3, "rlvr3", "Figure 12: 26 environment types, with low effort, agentic-focused. The split adds the function-calling pivot (9,739 rows), has no jailbreak or over-refusal rows, and its GenRM prompts include lmarena_all_20260217, so the round started after February 17, 2026. toolcall_schema rows carry no profiled pass rate, so its curve is an assumption."),
+        source=CFG_RLVR, gpus=872, entropy=(0.39, 0.34), kl_ref=None, lr=3e-6, warmup=(3e-7, 3e-6),
+        tags=["rlvr", "async-grpo", "multi-environment", "agentic"], jobs=rlvr_jobs,
+        events=rlvr_events([{"step": 0, "kind": "data", "title": "rlvr3 blend",
+                             "body": "Agentic-focused: adds toolcall_schema (9,739 rows); no jailbreak_detection or over_refusal_detection rows; GenRM prompts include the lmarena_all_20260217 set."}]))
+    sw1 = rl_stage(
+        "swe1", "SWE-RL 1 (SWE pivot)", "swe1", base_key="rlvr3", out_key="swe1", parent="rlvr3", start=r3["end"] + 6 * 3600, steps=STEPS["swe1"],
+        ppstep=64, group=16, sample_groups=64, step_s=700.0, gain=0.0, overrides={"swe_pivot": curriculum(0.375, 0.0)},
+        hp={"prompts_per_step": 64, "group_size": 16, "global_batch": 1024, "lr": 1e-6, "kl_coef": 0.0, "clip_low": 0.2, "clip_high": 0.28,
+            "max_seq_len": 131072, "temperature": 1.0, "overlong_filtering": True, "advantage_clip": "[-100, 100]", "tis_cap": 5.0,
+            "word_count_similarity_threshold": 0.0, "prefix_caching": True, "parallelism": "TP8 CP8 EP8", "nodes": 64, "gpus": 512,
+            "generation_nodes": 32, "blend": "swe1 (50,661 rows)", "steps": f"not published (one epoch of the released split ≈ {epoch['swe1']} steps; demo: {STEPS['swe1']})"},
+        config=SWE1_CONFIG,
+        desc=("SWE-RL stage 1 (NeMo RL super-v3 stage2_swe1.yaml): single-step PivotRL on expert SWE trajectories, run separately from RLVR "
+              "because SWE rollouts are slower and need longer contexts (report §3.2). Published: 64 prompts × 16 generations; LR 1e-6; no KL; "
+              "max length 131,072; overlong filtering; 64 nodes (32 generation); the swe1 blend (50,661 rows: R2E-Gym-Subset 79.70%, SWE-Gym "
+              "20.30%). Simulated: step count, timing, curves and rollouts; the pass rate starts near 0.375 (a quoted row's expert pass rate), "
+              "an assumption."),
+        source=CFG_SWE1, gpus=512, entropy=(0.36, 0.32), kl_ref=None, lr=1e-6, tags=["swe", "pivotrl", "async-grpo"],
+        jobs=[("policy training (Megatron-Core)", "train", 32), ("generation (vLLM)", "rollout", 32)],
+        events=[{"step": 0, "kind": "notice", "title": "SWE runs separately", "body": "SWE rollouts are slower and need longer contexts than the RLVR environments (report §3.2)."}])
+    sw2 = rl_stage(
+        "swe2", "SWE-RL 2 (OpenHands)", "swe2", base_key="swe1", out_key="swe2", parent="swe1", start=sw1["end"] + 6 * 3600, steps=STEPS["swe2"],
+        ppstep=16, group=32, sample_groups=16, step_s=4000.0, gain=0.0, overrides={"swe_agents": (0.28, 0.40)}, shape=2.5,
+        hp={"prompts_per_step": 16, "group_size": 32, "global_batch": 512, "lr": 1e-6, "kl_coef": 0.0, "clip_low": 0.2, "clip_high": 0.28,
+            "max_seq_len": 196608, "temperature": 1.0, "overlong_filtering": True, "agent_max_turns": 200, "agent_timeout_s": 3600,
+            "agent_concurrency": 768, "thinking": "enabled", "run_with_mixed_prompts": True, "parallelism": "TP8 CP8 EP8", "nodes": 64,
+            "gpus": 512, "generation_nodes": 32, "blend": "swe2 (1,444 rows)", "tokens_figure_12": "20B (SWE RL box)",
+            "steps": f"not published (demo: one epoch of the released split, {epoch['swe2']} steps)"},
+        config=SWE2_CONFIG,
+        desc=("SWE-RL stage 2 (NeMo RL super-v3 stage2_swe2.yaml): end-to-end SWE-RL; each rollout launches an Apptainer container, runs "
+              "an OpenHands agent loop to produce a patch and is scored by ground-truth tests (binary reward). Published: 16 prompts × 32 "
+              "generations; LR 1e-6; no KL; max length 196,608; 200 agent turns; 3,600 s timeout; 768 concurrent agents; 64 nodes (32 "
+              f"generation); the swe2 blend (1,444 rows). Figure 12 gives 20B tokens for SWE RL. Simulated: the steps (one epoch over the "
+              f"released split minus 100 validation rows = {epoch['swe2']}), timing, curves and rollouts; the pass-rate curve is an assumption (swe2 rows "
+              "carry no profiled pass rate)."),
+        source=CFG_SWE2, gpus=512, entropy=(0.34, 0.30), kl_ref=None, lr=1e-6, tags=["swe", "openhands", "apptainer", "async-grpo"],
+        jobs=[("policy training (Megatron-Core)", "train", 32), ("generation (vLLM) + OpenHands agents", "rollout", 32)],
+        events=[{"step": None, "kind": "incident", "title": "Sandboxes without root",
+                 "body": "No Docker on the cluster: Apptainer containers share host memory and kernel, so runaway agent processes could exhaust node memory and killall/pkill could hit training or vLLM processes. Fixes: .sif images with a tmpfs overlay, a memory watchdog on the agent's process tree, and a regex command blocklist that returns safer alternatives (report §3.2.5)."},
+                {"step": None, "kind": "incident", "title": "Slow payloads",
+                 "body": "HTTP payloads between Gym and the model server carry token IDs and log-probs per turn; Python json was replaced with orjson (report §3.2.5)."}])
+    rh = rl_stage(
+        "rlhf", "RLHF", "rlhf", base_key="swe2", out_key="rlhf", parent="swe2", start=sw2["end"] + 6 * 3600, steps=STEPS["rlhf"],
+        ppstep=128, group=16, sample_groups=96, step_s=900.0, gain=0.55, overrides={"genrm_compare": (0.5, 0.5)}, max_tokens=49152,
+        hp={"prompts_per_step": 128, "group_size": 16, "global_batch": 2048, "lr": 1e-6, "kl_coef": 1e-4, "kl_type": "k3",
+            "clip_low": 0.2, "clip_high": 0.28, "max_seq_len": 49152, "temperature": 1.0, "overlong_filtering": False,
+            "genrm": "Qwen3-Nemotron-235B-A22B-GenRM-2603, 8 routers, TP8", "comparison": "circular",
+            "genrm_sampling": "temperature 0.6, top_p 0.95, 16,384 max tokens", "length_penalties": "reasoning 0.3, answer 0.35, style 0.05",
+            "conciseness_bonus": "0.5 (top_percentile 0.2)", "parallelism": "TP4 CP4 EP8", "nodes": 72, "gpus": 576, "generation_nodes": 32,
+            "gym_gpu_nodes": 8, "blend": "rlhf (25,171 rows)", "tokens_figure_12": "18B (RLHF box)",
+            "steps": f"not published (demo: one epoch of the released split, {epoch['rlhf']} steps)"},
+        config=RLHF_CONFIG,
+        desc=("RLHF (NeMo RL super-v3 stage3_rlhf.yaml; 'RLHF with length penalty to reduce verbosity'). Published: GRPO with GenRM "
+              "pairwise rewards; 128 prompts × 16 generations; LR 1e-6; KL 1e-4 (k3) 'to prevent the model from drifting too far from the "
+              "reference policy'; max length 49,152; GenRM length penalties 0.3 / 0.35 / 0.05 (RLVR used 0.1 / 0.1 / 0.1); 72 nodes (32 "
+              "generation, 8 Gym GPU nodes); the rlhf blend (25,171 rows, measured 76.0% GenRM prompts and 24.0% conversational tool-use "
+              f"pivot). Figure 12 gives 18B tokens. Simulated: the steps (one epoch over the released split ≈ {epoch['rlhf']}), timing, curves and "
+              "rollouts. GenRM rewards are relative within each group, so their mean stays near the middle."),
+        source=CFG_RLHF, gpus=576, entropy=(0.38, 0.35), kl_ref=0.004, lr=1e-6, tags=["rlhf", "genrm", "length-control", "async-grpo"],
+        jobs=[("policy training (Megatron-Core)", "train", 32), ("generation (vLLM)", "rollout", 32), ("NeMo Gym GenRM (8 routers, TP8)", "serving", 8)],
+        events=[{"step": 0, "kind": "config", "title": "Length control tightened",
+                 "body": "Group-relative length penalties rise from 0.1 / 0.1 / 0.1 in RLVR to 0.3 (reasoning) / 0.35 (answer) / 0.05 (style), and a KL penalty of 1e-4 (k3) is added."}])
+    mtp_start = rh["end"] + 8 * 3600
+    mt = sft_run(
+        w, project_id=pid, key="mtp", name="MTP healing", framework="megatron_sft", datasets=[(split_ds["rlvr1"], None), (split_ds["rlvr2"], None), (split_ds["rlvr3"], None)],
+        base_model_id=M("rlhf"), output_model_id=M("bf16"), steps=STEPS["mtp"], start=mtp_start, step_seconds=45.0, loss=(1.6, 1.1),
+        lr=1e-5, warmup=0.0, schedule="constant", global_batch=64, seq_len=65536, gpu=None, gpus=None, cost_rate=0.0,
+        owner=OWNER, tags=["mtp", "sft"], stage="MTP healing", group_name="nemotron-3-super", algorithm="SFT (MTP heads only)",
+        hyperparams={"lr": "not published", "global_batch": "not published", "max_seq_len": "not published", "schedule": "not published",
+                     "warmup_ratio": "not published", "steps": f"not published (demo: {STEPS['mtp']})", "trainable": "MTP heads only (backbone frozen)",
+                     "loss": "NLL on the model's own responses to RLVR prompts"},
+        config="# MTP healing (report §3.2): published facts only\ntrainable: MTP heads only\nloss: SFT-style NLL on the model's responses to RLVR prompts\n# not published: steps, learning rate, batch, acceptance-rate gains",
+        description=("MTP healing (report §3.2): only the two shared-weight MTP heads are trained, with an SFT-style NLL loss on the model's "
+                     "own responses to RLVR prompts (MTP is off during RL: mtp_num_layers 0). The report says it 'significantly improves MTP "
+                     "accuracy' but gives no numbers or hyperparameters, so everything here except the method is simulated. A later MTPv2 "
+                     "head was released on its own on 2026-05-24."),
+        source=SUPER_REPORT, provenance="simulated")
+    finish_sft(w, mt, M("bf16"), STEPS["mtp"], parent_run=rh["run_id"], drop_lr=True)
+    runs.append(("mtp", mt, "MTP healing"))
+
+    # ---------------------------------------------------------- models
+    ends = {k: res["end"] for k, res, _ in runs}
+    arch = "Hybrid Mamba-2 + attention, LatentMoE (512 experts, top-22, latent 1024), 2 shared-weight MTP layers"
+    common = dict(arch=arch, params_total=120.6, params_active=12.7, context_len=1048576)
+    kit.model(w, pid, "base", "NVIDIA-Nemotron-3-Super-120B-A12B-Base-BF16", "base", hf_repo="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-Base-BF16",
+              stage="pretrained", created_at=T("2025-12-01 00:00"), status="released", source=SUPER_BASE_CARD,
+              notes="88 layers, d_model 4096, 32 query / 2 KV heads, Mamba state 128 (8 groups, 128 heads of dim 64), expert hidden 2688, shared expert 5376, 512 experts top-22, MoE latent 1024; 12.1B active without embeddings. ~25T pretraining tokens in NVFP4, then a long-context phase: 34B tokens at 1,048,576 context and 17B alternating 1M / 4K (LR 4.5e-6, batch 16, GB200, CP64 TP2 EP64). Card date 03/04/2026; created_at here is simulated (before SFT).",
+              **common)
+    stages = [("sft1", "Super SFT stage 1", "sft1", "base", "SFT"), ("sft2", "Super SFT stage 2", "sft2", "sft1", "SFT"),
+              ("sft", "Super SFT, budget control (RL start)", "sft3", "sft2", "SFT"), ("rlvr1", "Super after RLVR 1", "rlvr1", "sft", "RL"),
+              ("rlvr2", "Super after RLVR 2", "rlvr2", "rlvr1", "RL"), ("rlvr3", "Super after RLVR 3", "rlvr3", "rlvr2", "RL"),
+              ("swe1", "Super after SWE-RL 1", "swe1", "rlvr3", "RL"), ("swe2", "Super after SWE-RL 2", "swe2", "swe1", "RL"),
+              ("rlhf", "Super after RLHF", "rlhf", "swe2", "RL")]
+    steps_of = STEPS
+    for key, name, run_key, parent, stage in stages:
+        kit.model(w, pid, key, name, run_key=run_key, parent_id=M(parent), step=steps_of[run_key], stage=stage, created_at=ends[run_key],
+                  status="internal", source=SUPER_REPORT, notes="Intermediate checkpoint (not released); date simulated.", **common)
+    kit.model(w, pid, "bf16", "NVIDIA-Nemotron-3-Super-120B-A12B-BF16", hf_repo="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16", run_key="mtp",
+              parent_id=M("rlhf"), step=STEPS["mtp"], stage="Final (after MTP healing)", created_at=T("2026-03-11 00:00"), status="released", source=SUPER_CARD,
+              notes="Released 2026-03-11. Card rounds to 120B / 12B. Reasoning off / regular / low effort via enable_thinking and budget control; languages en, fr, de, it, ja, es, zh; February 2026 post-training data cutoff; minimum 8× H100-80GB; NVIDIA Nemotron Open Model License.",
+              **common)
+    kit.model(w, pid, "fp8", "NVIDIA-Nemotron-3-Super-120B-A12B-FP8", hf_repo="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-FP8", parent_id=M("bf16"),
+              stage="PTQ FP8 (W8A8)", created_at=T("2026-03-11 00:00"), status="released", source=SUPER_REPORT,
+              notes="FP8 (W8A8) post-training quantization for Hopper; calibrated on 256 samples at 65,536 context (report §4).", **common)
+    kit.model(w, pid, "nvfp4", "NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4", hf_repo="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-NVFP4", parent_id=M("bf16"),
+              stage="PTQ NVFP4 (W4A4)", created_at=T("2026-03-11 00:00"), status="released", source=SUPER_REPORT,
+              notes="NVFP4 mixed-precision PTQ for Blackwell in under 2 hours on one 8× B200 node with 512 SFT samples at 4,096 tokens; 99.8% median accuracy relative to BF16 (report §4). Casting the Mamba SSM cache to FP16 raised verbosity up to 37% (BF16 weights) and 40% (W8A8); stochastic rounding (Philox, 5 rounds) restored FP32-level accuracy and length (§4.3).",
+              **common)
+    kit.model(w, pid, "mtpv2", "Nemotron-3-Super-120B-A12B-BF16-MTPv2", parent_id=M("bf16"), stage="MTP head update",
+              created_at=T("2026-05-24 00:00"), status="released", source=SUPER_CARD, arch=arch, context_len=1048576,
+              notes="Updated MTP head; HF repo created 2026-05-24 and linked from the BF16 card. Parameters and training not stated.")
+    kit.model(w, pid, "genrm_init", "Qwen3-235B-A22B-Thinking-2507", "base", params_total=235, params_active=22, arch="Qwen3 MoE",
+              stage="pretrained (Qwen)", source=GENRM_CARD, notes="Initialization of the GenRM. Parameters from the A22B name.")
+    kit.model(w, pid, "genrm", "Qwen3-Nemotron-235B-A22B-GenRM-2603", "reward", hf_repo="nvidia/Qwen3-Nemotron-235B-A22B-GenRM-2603",
+              parent_id=M("genrm_init"), params_total=235, params_active=22, arch="Qwen3 MoE", context_len=131072, stage="GenRM",
+              created_at=T("2026-01-05 00:00"), status="released", source=GENRM_CARD,
+              notes="Principle-following (RLBFF-style) pairwise GenRM: given a conversation and two responses it returns helpfulness scores (1-5) and a ranking (1-6). RL-trained on HelpSteer3, commercially friendly lmarena-140k subsets and newly collected human preferences; hyperparameters and scores not published for Super. Served with TP8 (2 routers in RLVR, 8 in RLHF), max_model_len 60,000. Released 2026-03-11 (created_at simulated: it scores prompts from RLVR 1 on).")
+    kit.model(w, pid, "judge_qwen", "Qwen3-235B-A22B-Instruct-2507-FP8", "judge", hf_repo="Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
+              params_total=235, params_active=22, arch="Qwen3 MoE", context_len=131072, stage="judge", source=CFG_RLVR,
+              notes="LLM judge for the math fallback, open QA, long-context QA, NL2Bash, multichallenge and inverse_if (served as nl2bash_judge_model: TP8, 2 routers, max_model_len 131,072, 8,192 max judge tokens).")
+    kit.model(w, pid, "judge_safety", "Nemotron-Content-Safety-Reasoning-4B", "judge", hf_repo="nvidia/Nemotron-Content-Safety-Reasoning-4B",
+              params_total=4, context_len=96000, stage="judge", source=CFG_RLVR,
+              notes="Safety judge for jailbreak_detection and over_refusal_detection (TP1, 8 routers, max_model_len 96,000, judge temperature 0.0).")
+    teachers = [("t_qwen_coder", "Qwen3-Coder-480B-A35B-Instruct", "Qwen/Qwen3-Coder-480B-A35B-Instruct", 480, 35, "SWE (OpenHands) and agentic-CLI trajectories; regenerated R2E-Gym problem statements."),
+                ("t_deepseek", "DeepSeek-V3.2", "deepseek-ai/DeepSeek-V3.2", None, None, "Refreshed math, code, conversational tool use, multilingual and science (with Kimi K2); terminal-use traces; general tool calling (with GLM-4.7)."),
+                ("t_kimi", "Kimi K2", None, None, None, "Refreshed math, code, tool use, multilingual and science (with DeepSeek-V3.2)."),
+                ("t_minimax_m2", "MiniMax-M2", "MiniMaxAI/MiniMax-M2", None, None, "Search trajectories (Wikidata-walk riddles through Tavily MCP)."),
+                ("t_minimax_m25", "MiniMax M2.5", None, None, None, "Agentic CLI interactions (with Qwen3-Coder-480B)."),
+                ("t_glm", "GLM-4.7", None, None, None, "General-purpose tool calling (with DeepSeek-V3.2).")]
+    for key, name, repo, pt, pa, note in teachers:
+        kit.model(w, pid, key, name, "teacher", hf_repo=repo, params_total=pt, params_active=pa, stage="SFT teacher", source=SUPER_REPORT,
+                  notes=note + " (report §3.1.1)")
+    kit.model(w, pid, "qwen35", "Qwen3.5-122B-A10B", "external", params_total=122, params_active=10, stage="reported baseline", source=SUPER_REPORT,
+              notes="Baseline in the report's Table 5. Parameters from the name.")
+    kit.model(w, pid, "gptoss", "GPT-OSS-120B", "external", hf_repo="openai/gpt-oss-120b", stage="reported baseline", source=SUPER_REPORT,
+              notes="Baseline in the report's Table 5; also an SFT teacher (low-effort reasoning samples, agentic-CLI task filtering judge, financial QA answers).")
+
+    # ---------------------------------------------------------- tasks: base = measured profile, latest = simulated
+    for ek, env in envs.items():
+        latest = {"genrm_compare": 0.5, "swe_agents": 0.40}.get(ek, sigm(logit(base_by_key[ek]) + 0.7))
+        kit.write_tasks(w, env, base_pass=base_by_key[ek], latest_pass=latest)
+
+    # ---------------------------------------------------------- metrics definitions
+    rl_ids = [res["run_id"] for k, res, _ in runs if k not in ("sft1", "sft2", "sft3", "mtp")]
+    register_metrics(w, pid, rl_ids, list(envs.values()), ["nemo_rl", "megatron_sft"])
+
+    # ---------------------------------------------------------- evals
+    t_eval = T("2026-03-06 00:00")
+    models = {"bf16": (M("bf16"), t_eval + 2 * 86400, SUPER_REPORT), "fp8": (M("fp8"), t_eval + 86400, SUPER_REPORT),
+              "nvfp4": (M("nvfp4"), t_eval, SUPER_REPORT), "qwen35": (M("qwen35"), None, SUPER_REPORT),
+              "gptoss": (M("gptoss"), None, SUPER_REPORT)}
+    config = {"harness": "NeMo Evaluator SDK + NeMo Skills", "thinking": True, "temperature": 1.0, "top_p": 0.95,
+              "max_new_tokens": 131072, "request_timeout_s": 3600, "source": EVALUATOR}
+    add_benchmarks(w, pid, SUPER_EVALS, models, t_eval, SUPER_REPORT, config, extra_evals=SUPER_SECOND)
+
+    # ---------------------------------------------------------- jobs outside runs
+    q0 = T("2026-03-05 09:00")
+    w.add("jobs", {"id": rid("job", pid, "nvfp4-ptq"), "project_id": pid, "run_id": None, "eval_id": None,
+                   "name": "NVFP4 mixed-precision PTQ (512 SFT samples at 4,096 tokens)", "kind": "quantize", "status": "completed",
+                   "cluster_id": cluster_id, "gpu": "B200", "gpus": 8, "nodes": 1, "started_at": q0, "ended_at": q0 + 2 * 3600,
+                   "cost_usd": None, "exit": "completed",
+                   "log_tail": "Published: under 2 hours on one 8× B200 node (report §4). Date simulated; the 2-hour span is the published upper bound."})
+
+    # ---------------------------------------------------------- report
+    super_report(w, pid)
+    w.conn.execute("UPDATE runs SET cost_usd=NULL, cost_rate=NULL WHERE project_id=?", (pid,))
+
+
+ASSUMED_MEAN = {"genrm_compare": 0.5, "inverse_if": 0.35, "toolcall_schema": 0.35, "swe_pivot": 0.375, "swe_agents": 0.28}
+
+
+def rlvr_config(split):
+    return f"""# NeMo RL super-v3 examples/configs/super/stage1_rlvr.yaml: the published values, as listed in the
+# Nemotron dossier (not the verbatim file). RLVR 1, 2 and 3 all use it, with the rlvr1 / rlvr2 / rlvr3 blend.
+data: nvidia/Nemotron-RL-Super-Training-Blends/{split}.jsonl   # {SPLITS[split]['rows']:,} rows; last 100 held out for validation
+algorithm: GRPO, asynchronous (training and generation on separate GPUs, in-flight weight updates, KV cache not recomputed)
+prompts_per_step: 256
+generations_per_prompt: 16          # 4,096 rollouts, one gradient update per rollout batch
+max_trajectory_age_steps: 1
+epochs: 1
+max_num_steps: 1000000
+val_period: -1
+baseline: leave-one-out, normalized rewards
+advantage_clip: [-50, 50]
+invalid_tool_call_advantage: -5.0
+malformed_thinking_advantage: -5.0
+loss: token-level
+kl_penalty: 0.0
+ratio_clip: [0.2, 0.28]
+kl_approximation: on-policy
+truncated_importance_sampling_cap: 5
+force_on_policy_ratio: true
+seq_logprob_error_threshold: 2       # masks sequences hit by the vLLM < 0.17.0 log-prob bug
+max_total_sequence_length: 65536     # started at 49,152
+temperature: 1.0
+top_p: 1.0
+learning_rate: 3.0e-6                # constant after 10 warmup iterations from 3.0e-7
+adam: {{beta1: 0.9, beta2: 0.999, eps: 1.0e-8}}
+weight_decay: 0.0
+grad_clip: 1.0
+moe: {{router: frozen, expert_bias_update_rate: 1.0e-3}}
+mtp_num_layers: 0                    # no MTP loss during RL
+parallelism: {{tp: 4, cp: 8, ep: 8, pp: 1, sequence_parallel: true}}
+vllm: {{tp: 4, gpu_memory_utilization: 0.8}}
+effort_levels: {{low_weight: 0.2, low_penalty: 1, low_ub: 3000}}
+genrm_compare: {{comparison: circular, temperature: 0.6, top_p: 0.95, reasoning_bonus: 0.5, answer_bonus: 0.5, top_percentile: 0.2,
+                length_penalty: {{reasoning: 0.1, answer: 0.1, style: 0.1}}}}
+judges:
+  nl2bash_judge_model: Qwen3-235B-A22B-Instruct-2507-FP8   # TP8, 2 routers, max_model_len 131072
+  safety: Nemotron-Content-Safety-Reasoning-4B             # TP1, 8 routers, max_model_len 96000
+  genrm: Qwen3-Nemotron-235B-A22B-GenRM-2603               # TP8, 2 routers, max_model_len 60000
+resources_servers: 23 configs (math_with_judge, code_gen, workplace_assistant, mcqa, instruction_following,
+  structured_outputs, lc_judge, calendar, genrm_compare, nl2bash-equivalency, equivalence_llm_judge,
+  single_step_tool_use_with_argument_comparison, reasoning_gym, terminal_pivot, ns_tools, math_formal_lean,
+  swerl_gen, jailbreak_detection, over_refusal_detection, multichallenge, inverse_if, search_pivot, toolcall_schema)
+checkpointing: {{metric_name: "val:total_reward/mean", higher_is_better: true, save_period: 10}}
+cluster: {{nodes: 109, generation_nodes: 72, gym_gpu_nodes: 5}}   # 8-GPU B200 nodes per the NeMo RL guide
+"""
+
+
+SFT1_CONFIG = """# Super SFT stage 1: published values (report §3.1; Nemotron repo super3/sft.md), not a verbatim file
+recipe: Megatron-Bridge (released recipe)
+data: Nemotron 3 Super SFT blend, 7M+ samples, 80B tokens (Figure 12)
+learning_rate: 1.0e-5          # constant after 30,000 warmup samples
+global_batch_size: 64
+packed_sequence_length: 262144 # 256K
+loss: token-level average over all output tokens in the packed global batch
+mtp: {layers: 2, shared_weights: true, loss_scale: 0.3}
+optimizer: {name: AdamW, beta1: 0.9, beta2: 0.95, weight_decay: 0.1}
+precision: bf16-mixed
+reasoning_off: traces stripped from a random 3% of samples
+low_effort: gpt-oss-120b low-effort samples, 2% of samples
+# not published: steps, GPUs, wall-clock
+"""
+
+SFT2_CONFIG = """# Super SFT stage 2: published values (report §3.1), not a verbatim file
+data: 85% of the stage-1 blend + 256K / 512K-token long-context SFT data
+learning_rate: 1.0e-5          # constant
+global_batch_size: 32
+packed_sequence_length: 524288 # 512K
+loss: normalized per conversation, averaged equally across conversations
+# not published: steps, GPUs, wall-clock
+"""
+
+SWE1_CONFIG = """# NeMo RL super-v3 examples/configs/super/stage2_swe1.yaml: published values (not the verbatim file)
+data: nvidia/Nemotron-RL-Super-Training-Blends/swe1.jsonl   # 50,661 rows (R2E-Gym-Subset 79.70%, SWE-Gym 20.30%)
+environment: swe_pivot_single_step_tool_use_with_argument_comparison   # the only resources server loaded
+algorithm: GRPO, asynchronous, PivotRL single-step rewards
+prompts_per_step: 64
+generations_per_prompt: 16
+learning_rate: 1.0e-6
+kl_penalty: 0.0
+ratio_clip: [0.2, 0.28]
+max_total_sequence_length: 131072
+overlong_filtering: true
+advantage_clip: [-100, 100]
+truncated_importance_sampling_cap: 5.0
+word_count_similarity_threshold: 0.0
+prefix_caching: true
+parallelism: {tp: 8, cp: 8, ep: 8}
+cluster: {nodes: 64, generation_nodes: 32}
+"""
+
+SWE2_CONFIG = """# NeMo RL super-v3 examples/configs/super/stage2_swe2.yaml: published values (not the verbatim file)
+data: nvidia/Nemotron-RL-Super-Training-Blends/swe2.jsonl   # 1,444 rows (R2E-Gym-Subset 81.18%, SWE-Gym 18.82%)
+environment: swe_agents (OpenHands in Apptainer; OpenCode and Codex agent classes)
+algorithm: GRPO, asynchronous, binary test reward
+prompts_per_step: 16
+generations_per_prompt: 32
+learning_rate: 1.0e-6
+kl_penalty: 0.0
+ratio_clip: [0.2, 0.28]
+max_total_sequence_length: 196608
+overlong_filtering: true
+agent: {max_turns: 200, timeout_s: 3600, concurrency: 768, thinking: enabled}
+run_with_mixed_prompts: true
+parallelism: {tp: 8, cp: 8, ep: 8}
+cluster: {nodes: 64, generation_nodes: 32}
+images: Apptainer .sif conversions of the R2E-Gym, SWE-Gym and SWE-bench Verified Docker images
+"""
+
+RLHF_CONFIG = """# NeMo RL super-v3 examples/configs/super/stage3_rlhf.yaml: published values (not the verbatim file)
+data: nvidia/Nemotron-RL-Super-Training-Blends/rlhf.jsonl   # 25,171 rows
+algorithm: GRPO, asynchronous, GenRM pairwise rewards with group-relative length control
+prompts_per_step: 128
+generations_per_prompt: 16
+learning_rate: 1.0e-6
+kl_penalty: 1.0e-4             # k3
+ratio_clip: [0.2, 0.28]
+max_total_sequence_length: 49152
+overlong_filtering: false
+genrm_compare:
+  model: Qwen3-Nemotron-235B-A22B-GenRM-2603   # 8 routers, TP8
+  comparison: circular
+  judges_per_comparison: 1
+  principles: true
+  sampling: {temperature: 0.6, top_p: 0.95, max_tokens: 16384}
+  aggregation: simple_tiebreaker
+  reasoning_bonus: 0.5
+  answer_bonus: 0.5
+  top_percentile: 0.2
+  length_penalty: {reasoning: 0.3, answer: 0.35, style: 0.05}
+parallelism: {tp: 4, cp: 4, ep: 8}
+cluster: {nodes: 72, generation_nodes: 32, gym_gpu_nodes: 8}
+"""
+
+
+def super_datasets(w, pid):
+    rep = SUPER_REPORT
+    slices = [("Agent", 36.0, "agentic"), ("Reasoning", 31.0, "reasoning"), ("Chat", 23.0, "chat"), ("Long Context", 8.0, "long_context"), ("Misc.", 2.0, "other")]
+    comps = [
+        ("Component · conversational tool use (838 domains, six-stage synthetic pipeline)", "tool_use", 279116, "Qwen3-235B-A22B-Thinking-2507, Qwen3-32B, Qwen3-235B-A22B-Instruct-2507, DeepSeek-R1-0528, DeepSeek-V3.2, gpt-oss-120b"),
+        ("Component · general-purpose tool calling (User / Assistant / Tool-LLM simulation)", "tool_use", 1500000, "DeepSeek-V3.2, GLM-4.7"),
+        ("Component · agentic programming, CLI (~15K synthesis + ~3K SWE + 10K Node.js web-dev tasks; ~28K per the Nemotron repo)", "agentic", 28000, "Qwen3-Coder-480B, MiniMax M2.5 (Codex, OpenCode, Qwen Code CLI, Stirrup)"),
+        ("Component · software engineering (OpenHands on SWE-Gym, R2E-Gym, SWE-rebench issues)", "swe", None, "Qwen3-Coder-480B-A35B-Instruct"),
+        ("Component · terminal use (68,924 synthetic + 8,125 Nemotron-Cascade-Math + 7,815 Nemotron-Cascade-Code)", "terminal", 84864, "DeepSeek-V3.2 (Terminus 2 harness)"),
+        ("Component · financial reasoning (SecQue seeds × S&P 500 × 2019-2024, GenSelect)", "other", 366243, "gpt-oss-120b answers; Qwen3-235B-A22B selector; Qwen3-30B-A3B filter"),
+        ("Component · CUDA kernels (generation, repair, optimization)", "code", 100000, "DeepSeek-R1, gpt-oss-120b"),
+        ("Component · text-to-SQL (MySQL, PostgreSQL, SQLite; 60 sectors, ~700 topics, 90 concept buckets)", "code", 96500, "NeMo Data Designer"),
+        ("Component · search (Wikidata 4-8 hop walks, obfuscated questions, Tavily MCP; ~7K per the Nemotron repo)", "agentic", 7000, "MiniMax-M2"),
+        ("Component · long context (clustered documents to 128K / 256K / 512K, multi-hop QA)", "long_context", None, "Qwen3-235B-A22B-Thinking-2507 (snippets)"),
+        ("Component · safety (policy classification, two-stage deliberative responses)", "safety", None, None),
+        ("Component · multilingual (de/es/fr/it/ja/zh translation + parallel corpus)", "multilingual", None, "Qwen2.5-Instruct-14B; Qwen3-4B-Thinking-2507 post-edit"),
+        ("Component · refreshed competition math and code, tool use, multilingual, science", "reasoning", None, "DeepSeek-V3.2, Kimi K2"),
+        ("Component · reused from Nano: chat, InfiniByte, formal proofs", "other", None, None),
+        ("Component · low-effort reasoning samples (2% of SFT by sample count)", "reasoning", None, "gpt-oss-120b (low-effort mode)"),
+    ]
+    sources = [{"name": f"{n} — {p:.1f}% of the stage-1 blend (Figure 16; unit not stated)", "category": c, "rows": None, "synthetic": None, "url": rep}
+               for n, p, c in slices]
+    sources += [{"name": n, "category": c, "rows": r, "synthetic": True, "generator": g, "url": rep} for n, c, r, g in comps]
+    internal = kit.dataset(
+        w, pid, "sft_blend", "Nemotron 3 Super SFT blend (internal)", "sft", rows=7000000, tokens=80000000000, sources=sources,
+        processing=[{"step": "LLM-judge filter (agentic CLI)", "rows_in": 20000, "rows_out": 15000, "note": "~20K Data Designer queries from a 24-action taxonomy, filtered by a gpt-oss-120b judge to ~15K tasks that need no pre-existing codebase."},
+                    {"step": "Difficulty filter (conversational tool use)", "rows_in": None, "rows_out": None, "note": "16 simulations per policy-scenario pair; keep successful trajectories, drop all-success and all-failure scenarios."},
+                    {"step": "Majority vote (long-context QA)", "rows_in": None, "rows_out": None, "note": "8 reasoning traces per context-question pair, semantic majority vote, shortest trace in the majority kept."},
+                    {"step": "GenSelect (finance)", "rows_in": None, "rows_out": 366243, "note": "5 candidate answers per question; Qwen3-235B-A22B selects; Qwen3-30B-A3B drops unanswerable pairs; outlier removal and dedup."},
+                    {"step": "Safety classifier", "rows_in": None, "rows_out": None, "note": "A content-moderation classifier removes any response flagged unsafe."},
+                    {"step": "Translation filter + post-edit", "rows_in": None, "rows_out": None, "note": "Wrong-language and failure-mode samples removed; Qwen3-4B-Thinking-2507 restores format compliance; very short parallel samples excluded."},
+                    {"step": "Reasoning-off strip", "rows_in": None, "rows_out": None, "note": "Reasoning traces stripped from a random 3% of samples."},
+                    {"step": "Stage-2 subset", "rows_in": None, "rows_out": None, "note": "SFT stage 2 uses 85% of the stage-1 blend plus 256K / 512K long-context data."}],
+        license=None, description=(
+            "The internal stage-1 SFT blend: 'over 7M total samples' (Figure 16) and 80B tokens (Figure 12). Composition as published: "
+            "Agent 36.0%, Reasoning 31.0%, Chat 23.0%, Long Context 8.0%, Misc 2.0%; the report doesn't say whether the shares count "
+            "samples or tokens, so the slices carry no row counts. The components below are the data pipelines report §3.1.1 describes, "
+            "with their published sizes. The card's language table lists 13.48M English samples, more than this 7M total, so it likely "
+            "counts more than SFT. The released Super SFT data-prep config still points at the Nano 3 blend (marked TODO)."),
+        created_at=T("2025-12-05 00:00"), source=rep, provenance="published")
+
+    def row(src, cat, text, reply=None):
+        d = user(text) if reply is None else user(text, ("assistant", reply))
+        return {"source": src, "category": cat, "data": d}
+
+    opens = []
+    open_specs = [
+        ("sft_agentic_v2", "Nemotron-SFT-Agentic-v2", 991900, "cc-by-4.0; apache-2.0; mit (HF tags)", "field absent",
+         [("tool_calling", "tool_use", 707052, "DeepSeek-V3.2, GLM-4.6"), ("customer_service_838_domains", "tool_use", 278880, None), ("search_graph_walk", "agentic", 5968, None)],
+         [{"step": "LLM-judge filter", "rows_in": None, "rows_out": None, "note": "Trajectories filtered by an LLM judge for inconsistent, incoherent or incorrect tool use."}],
+         [row("customer_service_838_domains", "tool_use", "Hello, I need assistance with an issue regarding my recent order. I received a crushed cereal box (Order #FM2025-5550)…"),
+          row("customer_service_838_domains", "tool_use", "Hello, I'm reaching out from a 501(c)(3) nonprofit organization, and we have a collection of 15 antiques valued at $22,000 that we'd like to consign with your auction house. Given our nonprofit status, I was wondering if…",
+              "Thank you for reaching out from your nonprofit organization. Heritage Auction House appreciates your interest in consigning your collection.…"),
+          row("customer_service_838_domains", "tool_use", "Hello, this is Officer Mark Thompson from the Department of Food Safety Inspection. I'm calling from the government number 202-555-0198, and my office is based in ZIP code 20005. I need to request comprehensive audit doc…",
+              "I apologize, but I'm unable to assist with this type of request. As a customer service agent for FreshHarvest Produce Subscription, my capab…"),
+          row("customer_service_838_domains", "tool_use", "Hi, I'm reaching out to learn more about the regenerative farming practices you use. I'm particularly interested in how these methods impact soil health, especially regarding the recent delivery I received. Could you pro…")],
+         "Search subset: 6,977 in the card text vs 5,968 in its table."),
+        ("sft_opencode_v1", "Nemotron-SFT-OpenCode-v1", 459000, "cc-by-4.0", "field absent",
+         [("general", "agentic", 90000, "GPT-OSS-120B questions; Qwen3-Coder-480B-A35B-Instruct traces"), ("bash_only_tool", "agentic", 97000, None),
+          ("bash_only_tool_skills", "agentic", 96000, None), ("question_tool", "agentic", 76000, None), ("agent_skills", "agentic", 67000, None),
+          ("agent_skills_question_tool", "agentic", 33000, None)], [], [], "Row counts are the card's rounded figures."),
+        ("sft_swe_v2", "Nemotron-SFT-SWE-v2", 256254, "cc-by-4.0; apache-2.0; mit; bsd-3-clause; bsd-2-clause (HF tags)", "yes",
+         [("agentless_swe (localization, repair, test generation)", "swe", 209976, "DeepSeek-R1-0528"), ("openhands_swe (SWE-Gym and R2E-Gym-Subset trajectories)", "swe", 46278, "Qwen3-Coder-480B-A35B-Instruct")],
+         [], [row("agentless_swe", "swe", "Please look through a given GitHub issue and repository structure and provide a list of files that one would need to edit or look at to solve the issue. ### GitHub Problem Description ### [ISSUE] **Title:** Preserve key …",
+                  "Based on the issue description and repository structure, the following files are most relevant for addressing the key order preservation in …"),
+              row("agentless_swe", "swe", "We are currently solving the following issue within our repository. Here is the issue text: --- BEGIN ISSUE --- ValueError raised when plottting reversed fixed-frequency TimedeltaIndex When plotting with a `TimedeltaInde…",
+                  "The issue occurs when plotting a `TimedeltaIndex` with a fixed frequency and reversed `xlim` (i.e., `xmin > xmax`). The error happens becaus…"),
+              row("agentless_swe", "swe", "Please look through a given GitHub issue and repository structure and provide a list of files that one would need to edit or look at to solve the issue. ### GitHub Problem Description ### # Debug flag not working with sc…",
+                  "Based on the issue description and repository structure, here are the key files to examine: ``` safety/scan/decorators.py safety/cli.py …")], ""),
+        ("sft_safety_v1", "Nemotron-SFT-Safety-v1", 45145, "cc-by-4.0; apache-2.0; mit (HF tags)", "yes",
+         [("content safety (Nemotron Content Safety v2, Gretel Safety Alignment v1, sdg_sensitive_categories)", "safety", 25536, None),
+          ("jailbreak robustness", "safety", 9653, None), ("over-refusal robustness (sdg_oversafety)", "safety", 7023, None),
+          ("demographic bias (sdg_bias_mitigation)", "safety", 2000, None), ("sensitive-content leakage (sdg_leakreplay)", "safety", 933, None)],
+         [{"step": "Regenerate responses", "rows_in": None, "rows_out": None, "note": "Only prompts are sourced; original responses are discarded and regenerated."}],
+         [row("over-refusal", "safety", "I am trying to locate the keynote address given by Eric Schmidt, the former CEO of Google.",
+              "Sure! Eric Schmidt has given a number of public keynote talks over the years (e.g., at Google I/O, TechCrunch Disrupt, TED, the World Econom…")],
+         "Only a benign sample row is shown; refused and partially refused examples are not reproduced."),
+        ("sft_comp_prog_v2", "Nemotron-SFT-Competitive-Programming-v2", 844935, "cc-by-4.0; odc-by; mit (HF tags)", "yes",
+         [("competitive_coding_cpp", "code", 332559, None), ("competitive_coding_python", "code", 336568, None),
+          ("exercism (115 Python problems; Aider benchmark decontaminated)", "code", 79244, None), ("text_to_sql", "code", 96564, "NeMo Data Designer")],
+         [], [row("competitive_coding_cpp", "code", "You are a helpful and harmless assistant. You should think step-by-step before responding to the instruction below. Please use C++ programming language only. You must use ```cpp for just the final solution code block with the following format: ```cpp // Your…",
+                  "```cpp #include <bits/stdc++.h> using namespace std; const int MOD = 998244353; int main() { ios::sync_with_stdio(false); cin.tie(nullptr); …"),
+              row("competitive_coding_cpp", "code", "You are a helpful and harmless assistant. You should think step-by-step before responding to the instruction below. Please use C++ programming language only. …",
+                  "```cpp #include <cstdio> #include <vector> #include <algorithm> using namespace std; int main() { int n; scanf(\"%d\", &n); vector<int> a(n); …")],
+         "Competitive coding spans 34,799 unique questions; generators aren't named on the card."),
+        ("finance_v1", "Nemotron-SpecializedDomains-Finance-v1", 326698, "cc-by-4.0", "empty list",
+         [("SEC 10-K / 10-Q grounded QA, S&P 500, 2019-2024 (565 SecQue seed questions)", "other", 326698, "GPT-OSS-120B, 5 candidates, GenSelect")],
+         [], [row("train", "finance", "You are given a financial text extracted from 10-K or 10-Q files and a question written by domain experts. Your task is to answer the question based only on the provided context. Do not use any additional context. …",
+                  "**Answer:** - **General Dynamics:** Net interest expense fell from $‑239 million in the first half of 2020 to $‑232 million in the first hal…"),
+              row("train", "finance", "You are given a financial text extracted from 10-K or 10-Q files and a question written by domain experts. …",
+                  "AT&T's 2020 balance sheet shows a mixed picture of solvency: * **Capital structure** – Total assets are $525.8 billion, total liabilities $3…"),
+              row("train", "finance", "You are given a financial text extracted from 10-K or 10-Q files and a question written by domain experts. …",
+                  "**EBITDA calculation (Operating Income + Depreciation & Amortization)** - **FY 2019** - Operating income: $14,219 million - Depreciation, am…")],
+         "Card count 326,698 vs 366,243 pairs in the Super report."),
+        ("if_chat_v2", "Nemotron-SFT-Instruction-Following-Chat-v2", 1998568, "odc-by", "yes",
+         [("chat", "chat", 1998568, "Kimi-K2-Thinking, GLM-4.6, Qwen3-235B-A22B-Thinking-2507, GPT-OSS-120b, Kimi-K2-Instruct-0905, Qwen3-235B-A22B-Instruct-2507")],
+         [], [row("chat", "chat", "How do I use flags like -march=native and -mtune=native to improve the performance of my Linux computer?",
+                  "The `-march=native` and `-mtune=native` compiler flags are used to optimize compiled programs for the specific CPU on which they're being bu…"),
+              row("chat", "chat", "polish the sentences: It is good that if Vivey could bring more synergy between App 1 and App 2 by identifying the common areas in business opportunities, risks and GTM strategies, so that we could leverage more resource…",
+                  "Certainly! Here's a more polished and professional version of your sentences: --- It would be valuable if Vivey could foster greater synergy…"),
+              row("chat", "chat", "Productivity: Describe what NAME_1 does")], ""),
+        ("multilingual_v1", "Nemotron-SFT-Multilingual-v1", 3065255, "cc-by-4.0; cc-by-sa-4.0 (HF tags)", "yes",
+         [("code_{de,es,fr,it,ja,zh}", "multilingual", 825113, "Qwen2.5-14B-Instruct translation"), ("math_{de,es,fr,it,ja,zh}", "multilingual", 668430, "Qwen2.5-14B-Instruct translation"),
+          ("stem_{de,es,fr,it,ja,zh}", "multilingual", 1571712, "Qwen2.5-14B-Instruct translation; Qwen3-4B-Thinking-2507 post-edit")],
+         [{"step": "Translation filters", "rows_in": None, "rows_out": None, "note": "Heuristic filters for translation failures and hallucinations; STEM subsets post-edited for format. Prompt and final answer translated, reasoning kept in English."}],
+         [row("math_de", "multilingual", "Betrachte die modifizierte Collatz-Folge, in der gerene Begriffe durch 2 geteilt (D-Schritt) und ungerene Begriffe durch (3x + 1)/2 transformiert werden (U-Schritt). Gegeben eine positive Ganzzahl n und eine Zeichenkette…",
+              "Um dieses Problem zu lösen, müssen wir die kleinste ganze Zahl \\( x \\geq n \\) finden, die zwei Bedingungen erfüllt: Die modifizierte Collatz…"),
+          row("code_de", "multilingual", "Sie erhalten zwei Strings A und B der Länge N und eine Konstante β > 0. Die Strings werden entlang eines linearen optischen Mediums ausgerichtet, wobei jeder Position i (0 ≤ i < N) ein radialer Abstand r_i = |i - (N-1)/2…",
+              "Um dieses Problem zu lösen, müssen wir die minimal mögliche absolute Gesamtpunktzahl finden, die durch die Umwandlung zweier Strings `A` und…"),
+          row("code_de", "multilingual", "Sie sind ein Geheimagent des Friedenskomitees Intelligenzcentrums, der sich einer geheimen Laboranlage auf dem Mars eingeschlichen hat, die von den Automatischen Kriminellen Maschinen betrieben wird. Ihre Mission besteht…",
+              "Um dieses Problem zu lösen, müssen wir überprüfen, ob es möglich ist, genau `N` Knöpfe (jeder mit einer bestimmten Schrittgröße) zu drücken,…")],
+         "Subset totals are sums of the card's per-language rows (computed). Typos as in the data."),
+        ("math_v3", "Nemotron-SFT-Math-v3", 3638783, "cc-by-4.0; cc-by-sa-4.0 (HF tags)", "empty list",
+         [("CoT and Python-TIR solutions to Nemotron-Math-v2 problems (AoPS, Math StackExchange / MathOverflow)", "math", 3638783, "DeepSeek-V3.2-Speciale (CoT), DeepSeek-V3.2 (TIR)")],
+         [{"step": "Answer verification", "rows_in": None, "rows_out": None, "note": "Only solutions whose final answer matches the verified Nemotron-Math-v2 reference are kept."}],
+         [row("train", "math", "Solve the following math problem. Make sure to put the answer (and only answer) inside \\boxed{}. Find the minimal polynomial of the matrix \\( A = \\begin{bmatrix} 0 & 4 & 1 & -2 \\\\ -1 & 4 & 0 & -1 \\\\ 0 & 0 & 1 & 0 \\\\ -1 &…",
+              "The characteristic polynomial of \\(A\\) is \\((\\lambda-1)^3(\\lambda-2)\\). The geometric multiplicity of \\(\\lambda=1\\) is \\(2\\), so the Jordan …"),
+          row("train", "math", "Solve the following math problem. Make sure to put the answer (and only answer) inside \\boxed{}. Find a polynomial $\\phi \\in K[X_1, X_2, \\ldots, X_n]$ whose only zero is $(0,0,\\ldots,0)$, given that $K$ is not algebraica…",
+              "Since \\(K\\) is not algebraically closed, there exists an irreducible polynomial \\(f(T) \\in K[T]\\) of degree \\(n > 1\\). Let \\(\\alpha\\) be a r…"),
+          row("train", "math", "Solve the following math problem. Make sure to put the answer (and only answer) inside \\boxed{}. Given that the probability of a child being a boy or a girl is equal, and a student picked at random from a large class is …",
+              "We assume that the number of children in a family is independent of their genders and that each child is equally likely to be a boy or a gir…")],
+         "The card notes a 2026-04-27 formatting fix."),
+    ]
+    for key, name, rows_, lic, used, subs, proc, samples, note in open_specs:
+        url = HFD + "nvidia/" + name
+        did = kit.dataset(
+            w, pid, key, name, "sft", rows=rows_, sources=[{"name": s, "category": c, "rows": r, "synthetic": True, "generator": g, "license": lic, "url": url} for s, c, r, g in subs],
+            processing=proc, samples=samples, license=lic, hf_repo="nvidia/" + name, source=url, provenance="published",
+            description=(f"Released SFT data in the Nemotron-Post-Training-v3 collection ('major portions of the fine-tuning corpus are released'). "
+                         f"used_in ['super_v3'] on sampled rows: {used}. {note}").strip())
+        opens.append(did)
+
+    # RL blends: the umbrella dataset and one per stage
+    umbrella = kit.dataset(
+        w, pid, "rl_blends", "Nemotron-RL-Super-Training-Blends", "rl", rows=479303, license="cc-by-4.0", hf_repo="nvidia/Nemotron-RL-Super-Training-Blends",
+        sources=[{"name": f"{k}.jsonl ({v['size']})", "category": "rl_split", "rows": v["rows"], "synthetic": None, "license": "cc-by-4.0", "url": f"{BLENDS}/blob/main/{k}.jsonl"} for k, v in SPLITS.items()],
+        processing=[{"step": "Filter by pass rate", "rows_in": None, "rows_out": None, "note": "Prompts the SFT model already answers consistently are removed (report §3.2.1)."},
+                    {"step": "Curriculum order", "rows_in": None, "rows_out": None, "note": "Each blend is sorted from high to low pass rate; rows carry pass_rate, pass_rate_total and pass_rate_passed."},
+                    {"step": "Placeholders", "rows_in": None, "rows_out": None, "note": "DAPO-Math-17k and Skywork-OR1 rows ship as placeholders restored by fill_placeholders.py; competitive coding excludes tacos and apps."},
+                    {"step": "Validation split", "rows_in": None, "rows_out": None, "note": "The recipe holds out the last 100 rows of each blend for validation."}],
+        description=("One RL blend per Super RL stage, 479,303 rows in six files. The card says 'the model was also trained on additional data not "
+                     "included in this release'. It calls the dataset 'Nemotron-3-Super-RL-Training-Blends', a repo name that doesn't resolve "
+                     "(the Super RL docs download it too); the published repo is nvidia/Nemotron-RL-Super-Training-Blends. Per-environment rows "
+                     "of each split are measured from the released files (agent_ref), with swe1 inferred from its config and a 34-row sample."),
+        source=BLENDS, provenance="published")
+    splits = {}
+    for k, v in SPLITS.items():
+        srcs = []
+        for agent, ek, n, mean, tags in v["envs"]:
+            label = f"{agent} → {envs_label(ek)}"
+            if mean is not None:
+                label += f" · mean profiled pass rate {mean:.3f}"
+            srcs.append({"name": label + f" · tags: {tags}", "category": ENV_CATEGORY[ek], "rows": n, "synthetic": None, "license": "cc-by-4.0", "url": f"{BLENDS}/blob/main/{k}.jsonl"})
+        samples = []
+        if k == "rlhf":
+            samples = [{"source": "genrm_simple_agent · lmarena_5k", "category": "chat", "data": user("Are you aware of the 3n + 1 problem?")},
+                       {"source": "genrm_simple_agent", "category": "chat", "data": user("Help me tag a chess puzzle. It's a rook endgame, and I have a passed pawn on the 7th rank…")},
+                       {"source": "genrm_simple_agent", "category": "chat", "data": user("Day 1: Wednesday, July 23 / 8:00 a.m. - 11:45 a.m. Pacific Time … 换算成北京时间")}]
+        elif k == "swe1":
+            samples = [{"source": "swe_pivot · R2E-Gym-Subset", "category": "swe",
+                        "data": user("I've uploaded a python code repository in the directory /workspace/numpy__numpy__ … [ISSUE] Title: Masked Array Indexing Ignores Mask During Assignment", ("grader", "expected next call: execute_bash (row pass_rate 0.375)"))}]
+        elif k == "swe2":
+            samples = [{"source": "swe_agents_train · R2E-Gym-Subset", "category": "swe",
+                        "data": user("numpy__numpy-ad30b31a… [ISSUE] `doc_note` Function Retains Indentation in Docstrings, Causing Test Failure", ("grader", "hidden tests on the final git patch"))}]
+        measured = "measured from the released file" if k != "swe1" else "inferred: stage2_swe1.yaml loads only swe_pivot and all 34 sampled rows use it"
+        extra = ""
+        if k == "rlhf":
+            extra = " Measured shares (76.0% GenRM prompts, 729 of them identity prompts, and 24.0% tool-use pivot = 73.1 / 24.0 / 2.9%) differ from the card's 77 / 20 / 3%."
+        splits[k] = kit.dataset(
+            w, pid, f"rl_{k}", f"Nemotron-RL-Super-Training-Blends · {k}", "rl", rows=v["rows"], sources=srcs, samples=samples,
+            license="cc-by-4.0", hf_repo="nvidia/Nemotron-RL-Super-Training-Blends", source=f"{BLENDS}/blob/main/{k}.jsonl",
+            provenance="published", version=k,
+            description=(f"The {k} split ({v['rows']:,} rows, {v['size']}). Rows per grading environment are {measured}. Card mixing ratios: {v['card']}.{extra}"))
+
+    prompt_sets = [
+        ("ds_tool_pivot", "nvidia/Nemotron-RL-Agentic-Conversational-Tool-Use-Pivot-v1", 170320, "cc-by-4.0",
+         "Each assistant step of expert trajectories across 838 domains becomes a single-step task with a per-row pass_rate. Card: 170,320 train rows (renamed from …-Conversational-Tool-Use-v1, which the blend card still cites); datasets-server reports 96,968.",
+         "tool_use", "DeepSeek-R1-0528, DeepSeek-V3.2, Qwen3-235B-A22B-Thinking-2507, Qwen3-32B",
+         [user("Package ID: SHADOW-LAB-009. We noticed the similarities last week when a competitor launched a room titled \"Obsidian Maze\",…", ("grader", "expected function_call transfer_to_human_agent")),
+          user("Hello, I'm the executive chef for the upcoming corporate event GALA-678 … We have 20 kosher meal requests…", ("grader", "expected message: authenticate the user first (pass_rate 0.375)"))]),
+        ("ds_fc_pivot", "nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1", 8458, "cc-by-4.0", "Card: 8,458 train rows plus a validation file; datasets-server reports 9,620.",
+         "tool_use", "DeepSeek-V3.2, GLM-4.6, gpt-oss-120b, Kimi-K2-Instruct",
+         [user("What is the hourly weather forecast for Chicago for the next 24 hours?", ("grader", "expected function_call get_hourly_forecast {location: 41.8781,-87.6298, hours: 24}"))]),
+        ("ds_swe_pivot", "nvidia/Nemotron-RL-Agentic-SWE-Pivot-v1", 6436, "cc-by-4.0", "Card: 6,436 train samples derived from SWE-Gym and R2E-Gym; datasets-server partial count 50,308 rows, close to the 50,661-row swe1 blend.",
+         "swe", None, []),
+        ("ds_identity", "nvidia/Nemotron-RL-Identity-Following-v1", 21660, "cc-by-4.0", "Human seed data expanded into prompts that probe model identity; served through genrm_compare with identity principles.",
+         "chat", None, [user("Bist du OpenAIs ChatGPT?"), user("Wurdest du vom Team hinter ChatGPT erstellt?")]),
+        ("ds_calendar", "nvidia/Nemotron-RL-Instruction-Following-Calendar-v2", 9915, "cc-by-4.0", "9,659 train + 256 validation; personas from Nemotron-Personas-USA; verified against exp_cal_state.",
+         "if", None, [user("Hey, could you add a new event called \"Excel Budget Review: Workshop Supplies and Parts Costing\" for a 60-minute slot? (event id: 6)"),
+                      user("Hey, can we set the Auto Shop Brake Replacement Workshop so it ends at or before 2 pm? Thanks!"),
+                      user("Could you please schedule the 45-minute bullet journal planning session for my Certified Coding Specialist exam at 11:25am? Thanks!")]),
+        ("ds_multiturn", "nvidia/Nemotron-RL-Instruction-Following-MultiTurnChat-v1", 2118, "cc-by-4.0",
+         "Card: advanced 1,068 + vanilla 1,050; datasets-server 2,011; Gym preprocessing 994 + 1,023. Kept only if at most 1 of 4 responses from Nemotron-Nano-V2 / Qwen3-235B-A22B-Thinking-2507 passes human + GPT-5 evaluation.",
+         "if", None, [user("(System persona: bailiff Carol Rainwater) Now, plan a one-day court schedule which includes hearings, security checks, and administrative tasks…", ("grader", "graded by rubric questions"))]),
+        ("ds_adversarial", "nvidia/Nemotron-RL-Instruction-Following-Adversarial-v1", 1000, "cc-by-4.0", "Inverse-IFEval-style anti-convention prompts across 8 patterns; card text says 100 entries, datasets-server and Gym preprocessing give 1,000.",
+         "if", None, [user("Critique corporate tax avoidance in one sentence. Format: one continuous string without spaces, and write the last and second words in all uppercase…"),
+                      user("Review a one-page pitch for \"DeltaForge,\" a factory-automation startup. Write an analyst critique in exactly twelve lines, labeled in this order…")]),
+        ("ds_reasoning_gym", "nvidia/Nemotron-RL-ReasoningGym-v1", 15000, "cc-by-4.0", "15,000 samples across 104 Reasoning Gym tasks in 12 categories.",
+         "other", None, [user("In 4x4 Mini Sudoku … Solve this 4x4 Mini Sudoku puzzle: _ 3 _ _ / 1 4 2 _ / _ 1 _ 2 / _ _ 3 1", ("grader", "2 3 1 4 / 1 4 2 3 / 3 1 4 2 / 4 2 3 1")),
+                         user("What will this Game of Life board look like after 1 steps of simulation? Assume a Moore neighborhood and wrapping topology…")]),
+        ("ds_rl_safety", "nvidia/Nemotron-RL-Safety-v1", 44941, "cc-by-4.0",
+         "44,941 prompts (content safety 25,517; jailbreak 9,587; over-refusal 7,023; bias 2,000; leakage 933; these sum to 45,060) giving 89,882 chosen / rejected pairs (datasets-server shows 89,068 rows). Chosen responses in sampled rows come from nemotron-nano-v2-9b or gpt-oss-120b-medium, rejected ones from qwen3_32b, qwen3_8b or nemotron-nano-v3-30b-chunked. Only benign over-refusal prompts are shown here.",
+         "safety", None, [user("Can you tell me who the number 916-874-5115 belongs to, as it is the non-emergency contact number for the Sacramento County Sheriff's Office?", ("grader", "sdg_oversafety: should be answered")),
+                          user("How did Australian authorities investigate and resolve the $2.5 million credit card fraud scheme documented in AUSTRAC's 2018 case study, according to official reports?", ("grader", "sdg_oversafety: should be answered"))]),
+        ("ds_workplace", "nvidia/Nemotron-RL-agent-workplace_assistant", 1260, "cc-by-4.0", "Sandbox with 5 databases, 26 tools, 690 tasks; the card counts 1,260 query-answer tuples; datasets-server 1,255 train + 545 validation.",
+         "tool_use", None, [user("Reply to carlos's last email about 'Task Update on Develop prototype for report generation' with 'Thanks for the update - I will get back to you tomorrow.'"),
+                            user("Can you change the name of the last event on December 1 to Risk Management Forum"),
+                            user("Raj is taking over all of Akira's leads that are interested in software. Can you reassign them in the crm?")]),
+        ("ds_comp_coding", "nvidia/Nemotron-RL-coding-competitive_coding", 16083, "cc-by-sa-4.0 (repo tag; card body says CC-BY-4.0)",
+         "Python problems with unit tests from deepmind/code_contests and open-r1/codeforces; the blends exclude the tacos and apps subsets. Nano capped unit tests at 50 per problem (22K tasks).",
+         "code", None, [user("It is lunch time for Mole. His friend, Marmot, prepared him a nice game for lunch. Marmot brought Mole n ordered piles of worms…"),
+                        user("There are n games in a football tournament. Three teams are participating in it. Currently k games had already been played…"),
+                        user("You have a rectangular chocolate bar consisting of n x m single squares. You want to eat exactly k squares…")]),
+        ("ds_structured", "nvidia/Nemotron-RL-instruction_following-structured_outputs", 9949, "cc-by-4.0", "9,437 train + 512 validation prompts; JSON-schema adherence only (content not verified).",
+         "if", None, [user("Ensure your output validates against the given JSON schema. Document: 3D printing has revolutionized modern manufacturing by enabling rapid prototyping…", ("grader", "schema_type json, 12 fields")),
+                      user("Map the content of this document to the provided data structure. - The 'name' field in an Ansible task provides a human-readable label…", ("grader", "schema_type json, 10 fields"))]),
+        ("ds_if", "nvidia/Nemotron-RL-instruction_following", 46391, "odc-by", "WildChat-1M prompts combined with Open-Instruct verifiable constraints (46,391 question-instruction tuples).",
+         "if", None, [user("how can i install jayhorn step by step -- 1. There should be 2 paragraphs separated with *** 2. Your answer must contain a title, wrapped in double angular brackets 3. Answer with less than 204 words."),
+                      user("Autistic adults in the workplace -- Your response must have 1 sections… Your entire response should be in English, and in all lowercase letters.")]),
+        ("ds_mcqa", "nvidia/Nemotron-RL-knowledge-mcqa", 685573, "cc-by-4.0 (card body; no repo license tag)",
+         "617,020 train + 68,553 validation; multi-domain synthetic MCQA from OpenScienceReasoning-2 and books / articles. The Nano report cites 135K STEM MCQA tasks.",
+         "science", "Qwen3-32B, Qwen3-235B-A22B-Instruct-2507, DeepSeek-R1-0528",
+         [user("Which of the following genetic tests is used to identify the presence of a specific mutation associated with cystic fibrosis? A: Karyotyping B: Polymerase Chain Reaction (PCR) …", ("grader", "B")),
+          user("Which of the following ligands can act as both a two-electron donor and a one-electron donor…", ("grader", "B"))]),
+        ("ds_math_proofs", "nvidia/Nemotron-Math-Proofs-v1", None, "cc-by-sa-4.0",
+         "Lean 4 subset (lean.jsonl, 29.5 GB); datasets-server partial count 243,314 rows. Nano report: 580k natural-language theorems → 550k Lean 4 statements → 920k proof traces → 300k SFT examples.",
+         "math", None, [user("theorem problem_284239 (a b c : Nat) : Nat.gcd (c * a) (c * b) = c * Nat.gcd a b := by sorry", ("grader", "reward = Lean compiles without sorry"))]),
+    ]
+    for key, repo, n, lic, note, cat, gen, samples in prompt_sets:
+        kit.dataset(w, pid, key, repo.split("/")[1], "rl", rows=n, license=lic, hf_repo=repo,
+                    sources=[{"name": repo.split("/")[1], "category": cat, "rows": n, "synthetic": True if gen else None, "generator": gen, "license": lic, "url": HFD + repo}],
+                    samples=[{"source": repo.split("/")[1], "category": cat, "data": d} for d in samples],
+                    description="Prompt source for a NeMo Gym environment (Nemotron-Post-Training-v3 / NeMo Gym collections). " + note,
+                    source=HFD + repo, provenance="published")
+    kit.dataset(w, pid, "ds_genrm_v1", "Nemotron-RLHF-GenRM-v1", "preference", rows=299517, license="odc-by", hf_repo="nvidia/Nemotron-RLHF-GenRM-v1",
+                sources=[{"name": "preference data across domains + synthetic safety blend in a judge meta-prompt format (scores 1-5, ranking 1-6)", "category": "chat", "rows": 299517, "license": "odc-by", "url": HFD + "nvidia/Nemotron-RLHF-GenRM-v1"}],
+                description="GenRM data: context, two responses, rubric and JSON output. Card: 299,517 train samples (~5 GB); datasets-server partial count 273,038. Sampled rows carry used_in ['super_v3']. In the RL blends these prompts drive genrm_compare (tags hs3, lmarena_5k, lmarena_all_20260217, hs4_20260106_combinedrubricsonly, language_mixing_hs3).",
+                source=HFD + "nvidia/Nemotron-RLHF-GenRM-v1", provenance="published")
+    kit.dataset(w, pid, "ds_helpsteer3", "HelpSteer3", "preference", rows=132937, license="cc-by-4.0", hf_repo="nvidia/HelpSteer3",
+                sources=[{"name": n, "category": "chat", "rows": r, "license": "cc-by-4.0", "url": HFD + "nvidia/HelpSteer3"} for n, r in
+                         (("preference (train 38,459 / validation 2,017)", 40476), ("edit (13,740 / 721)", 14461), ("edit_quality (3,111 / 163)", 3274),
+                          ("feedback (38,782 / 2,039)", 40821), ("principle (32,881 / 1,024)", 33905))],
+                description="GenRM training data for Nano and Super, with commercially friendly lmarena-140k subsets and newly collected human preferences (report §3.2.3). Row counts from datasets-server (train + validation per config).",
+                source=HFD + "nvidia/HelpSteer3", provenance="published")
+    return {"internal": internal, "open": opens, "splits": splits, "umbrella": umbrella}
+
+
+def envs_label(ek):
+    return {"tool_use_pivot": "single_step_tool_use_with_argument_comparison"}.get(ek, ek)
+
+
+def super_report(w, pid):
+    by = {k: scores for k, _, _, _, _, _, _, _, _, scores in SUPER_EVALS}
+    skip = {"tau2_avg", "arena_hard_hp", "lcb_v6", "ruler_128k"}
+
+    names = {k: name for k, name, *_ in SUPER_EVALS}
+
+    def compare(other):
+        shared = [(k, s["bf16"], s[other]) for k, s in by.items() if k not in skip and s.get("bf16") is not None and s.get(other) is not None]
+        ahead = [names[k] for k, a, b in shared if a > b]
+        behind = [names[k] for k, a, b in shared if a < b]
+        return ahead, behind, len(shared)
+
+    ahead_g, behind_g, n_g = compare("gptoss")
+    ahead_q, behind_q, n_q = compare("qwen35")
+    ratios = {"fp8": [], "nvfp4": []}
+    drops = []
+    for k, s in by.items():
+        b = TABLE8.get(k, s.get("bf16"))
+        for q in ratios:
+            if s.get(q) is not None and b:
+                ratios[q].append(s[q] / b)
+                if q == "nvfp4":
+                    drops.append((s[q] / b, f"{names[k]} ({s[q]:g} vs {b:g})"))
+
+    def median(xs):
+        xs = sorted(xs)
+        m = len(xs) // 2
+        return xs[m] if len(xs) % 2 else (xs[m - 1] + xs[m]) / 2
+    med4, med8 = median(ratios["nvfp4"]) * 100, median(ratios["fp8"]) * 100
+    worst = ", ".join(label for _, label in sorted(drops)[:3])
+    claims = [
+        {"claim": "NVFP4 keeps 99.8% median accuracy relative to BF16 (report §4).",
+         "verdict": "upheld" if med4 >= 99.5 else "open",
+         "evidence": f"Computed from the {len(ratios['nvfp4'])} benchmarks with an NVFP4 score in Table 8: median NVFP4 / BF16 = {med4:.1f}% (FP8: {med8:.1f}% over {len(ratios['fp8'])}). The report's 99.8% may use a different benchmark set. Largest drops: {worst}. {SUPER_REPORT}"},
+        {"claim": "Super BF16 scores above GPT-OSS-120B on most of the benchmarks Table 5 reports for both.",
+         "verdict": "upheld" if len(ahead_g) * 2 > n_g else "rejected",
+         "evidence": f"Higher on {len(ahead_g)} of {n_g} shared rows; lower on {', '.join(behind_g)}. {SUPER_REPORT}"},
+        {"claim": "Super BF16 scores above Qwen3.5-122B-A10B on most of the benchmarks Table 5 reports for both.",
+         "verdict": "upheld" if len(ahead_q) * 2 > n_q else "rejected",
+         "evidence": f"Higher on only {len(ahead_q)} of {n_q} shared rows: {', '.join(ahead_q)}. {SUPER_REPORT}"},
+        {"claim": "Joint training across all RLVR environments gives stable gains, while single-environment training causes severe regressions on other benchmarks (report §3.2.1).",
+         "verdict": "open", "evidence": f"Stated without numbers for Super; Nano's report calls the regressions un-recoverable, also without a table. {SUPER_REPORT}"},
+        {"claim": "Stage-2 SFT with per-conversation normalized loss fixes stage 1's long-input-short-output degradation (report §3.1).",
+         "verdict": "open", "evidence": f"No before / after numbers are published. {SUPER_REPORT}"},
+        {"claim": "Per-stage contributions (SFT → RLVR → SWE-RL → RLHF) can be read from the release.",
+         "verdict": "rejected", "evidence": f"Super publishes only final and quantized scores; the only per-stage table in the family is Ultra's (arXiv 2606.15007, Table 5). {SUPER_REPORT}"},
+        {"claim": "The released RL blends contain Super's RL training data.",
+         "verdict": "rejected",
+         "evidence": f"The blend card says the model 'was also trained on additional data not included in this release'; six environments configured in stage1_rlvr.yaml (lc_judge, nl2bash-equivalency, equivalence_llm_judge, terminal_pivot, ns_tools, search_pivot) have no rows, and Figure 12 counts 25 / 30 / 26 environment types per round against 16 / 16 / 13 grading agents in the files. {BLENDS}"},
+        {"claim": "The RLHF blend is 77% GenRM prompts, 20% conversational tool use and 3% identity following (blend card).",
+         "verdict": "rejected", "evidence": f"Counting agent_ref in rlhf.jsonl gives 73.1% GenRM, 24.0% tool-use pivot and 2.9% identity prompts (729 rows). {BLENDS}"},
+        {"claim": "Casting the Mamba SSM cache to FP16 makes the model more verbose, and stochastic rounding fixes it (report §4.3).",
+         "verdict": "upheld", "evidence": f"Verbosity rose by up to 37% with BF16 weights and 40% with W8A8; stochastic rounding (Philox, 5 rounds) restored FP32-level accuracy and length. {SUPER_REPORT}"},
+        {"claim": "MTP healing significantly improves MTP accuracy (report §3.2).",
+         "verdict": "open", "evidence": f"No acceptance rates or hyperparameters are published. {SUPER_REPORT}"},
+        {"claim": "Masking sequences at seq_logprob_error_threshold 2 keeps training stable on vLLM < 0.17.0.",
+         "verdict": "open", "evidence": f"The NeMo RL guide describes the bug and the mask; no before / after training curves are published. {RL_GUIDE}"},
+    ]
+    kit.report(
+        w, pid, "super-report", "What the Nemotron 3 Super release establishes", "Summary of NVIDIA's report, configs and data cards",
+        T("2026-09-25 12:00"),
+        "Every post-training stage of Super is described and has a public config and public data, but the release carries no per-stage "
+        "evals, no step counts, durations or cost, and only part of the RL data. The final model beats GPT-OSS-120B on most shared "
+        "benchmarks, trails Qwen3.5-122B-A10B on most, and loses little under FP8 or NVFP4.",
+        claims, run_keys=("rlvr1", "rlvr2", "rlvr3", "swe1", "swe2", "rlhf", "mtp"),
+        body=("Pipeline (Figure 12): base (1M context) → SFT (7M samples, 80B tokens) → RLVR 1 (25 environment types) → RLVR 2 (30, with low "
+              "effort) → RLVR 3 (26, agentic-focused) → SWE-RL (20B tokens) → RLHF (18B tokens) → MTP healing. The report's text says 21 "
+              "environments and 37 datasets; Figure 12 says 37 environment types and up to 4,000 environment instances per batch; "
+              "stage1_rlvr.yaml loads 23 resources-server configs. Documentation drift found while assembling this project: the Super SFT "
+              f"data-prep config still points at the Nano 3 blend and labels Nano's ratios as Super's ({DATA_BLEND_RAW}); the Super RL docs "
+              f"download nvidia/Nemotron-3-Super-RL-Training-Blends, which doesn't resolve ({RL_INDEX_DOC})."))
+
+
+# ================================================================== Nano
+
+NANO_EVALS = [
+    ("mmlu_pro", "MMLU-Pro", "knowledge", "accuracy", "NeMo Skills", 12032, 1, "rate", "12,032 test questions (public size; assumed). 1 repeat (assumed, as for Super).", {"final": 78.3}),
+    ("aime25", "AIME25 (no tools)", "math", "pass@1", "NeMo Skills", 30, 64, "rate", "30 problems (public size; assumed). 64 repeats (assumed, as for Super).", {"final": 89.06}),
+    ("aime25_tools", "AIME25 (with tools)", "math", "pass@1", "NeMo Skills, Python tool", 30, 64, "rate", "30 problems (assumed). 64 repeats (assumed).", {"final": 99.17}),
+    ("gpqa", "GPQA (no tools)", "science", "pass@1", "NeMo Skills", 198, 8, "rate", "198 questions (Diamond size; assumed). 8 repeats (assumed, as for Super).", {"final": 73.04}),
+    ("gpqa_tools", "GPQA (with tools)", "science", "pass@1", "NeMo Skills, Python tool", 198, 8, "rate", "198 questions (assumed). 8 repeats (assumed).", {"final": 75.0}),
+    ("lcb_v6", "LiveCodeBench v6", "code", "pass@1", "NeMo Skills", 454, 8, "rate", "454 problems (assumed). 8 repeats (assumed).", {"final": 68.25}),
+    ("scicode", "SciCode (subtask)", "code", "pass@1", "NeMo Skills", 338, 8, "rate", "338 subtasks (public size; assumed). 8 repeats (assumed).", {"final": 33.28}),
+    ("hle", "HLE (no tools)", "reasoning", "accuracy", "NeMo Skills", 2158, 1, "rate", "2,158 text-only questions (assumed). 1 attempt (assumed).", {"final": 10.57}),
+    ("hle_tools", "HLE (with tools)", "reasoning", "accuracy", "NeMo Skills, tools", 2158, 1, "rate", "2,158 text-only questions (assumed). 1 attempt (assumed).", {"final": 15.48}),
+    ("minif2f", "MiniF2F pass@1", "math", "pass@1 avg of 32", "NeMo Skills, Lean 4", 244, 32, "rate", "244 test problems (public size; 50.03 fits 3,906 / 7,808). 32 attempts (assumed from the pass@32 row).", {"final": 50.03}),
+    ("minif2f_32", "MiniF2F pass@32", "math", "pass@32", "NeMo Skills, Lean 4", 244, 1, "rate", "244 test problems (public size; 79.92 = 195 / 244 fits). One row per problem: solved within 32 attempts.", {"final": 79.92}),
+    ("tb_hard", "Terminal Bench (hard subset)", "terminal", "accuracy", "dedicated container", 48, 8, "rate", "48 tasks (published for Super's evaluation). 8 attempts (assumed, as for Super).", {"final": 8.51}),
+    ("swe_oh", "SWE-Bench Verified (OpenHands)", "swe", "resolve rate", "OpenHands", 500, 1, "rate", "500 instances (public size). 1 attempt (assumed).", {"final": 38.76}),
+    ("tau2_airline", "tau2-bench Airline", "tool_use", "pass@1 avg of 8", "tau2-bench container", 50, 8, "rate", "50 tasks (public size; 48.0 = 192 / 400 fits). 8 samples (assumed, as for Super).", {"final": 48.0}),
+    ("tau2_retail", "tau2-bench Retail", "tool_use", "pass@1 avg of 8", "tau2-bench container", 114, 8, "rate", "114 tasks (public size; 56.91 = 519 / 912 fits). 8 samples (assumed).", {"final": 56.91}),
+    ("tau2_telecom", "tau2-bench Telecom", "tool_use", "pass@1 avg of 8", "tau2-bench container", 114, 8, "rate", "114 tasks (public size; 42.21 = 385 / 912 fits). 8 samples (assumed).", {"final": 42.21}),
+    ("tau2_avg", "tau2-bench average", "tool_use", "mean of 3 domains", "tau2-bench container", 278, 8, "avg", "Unweighted mean of the three domains; no per-task results stored.", {"final": 49.04}),
+    ("bfcl_v4", "BFCL v4", "tool_use", "accuracy", "NeMo Skills", 5000, 1, "avg", "Overall BFCL v4 accuracy is a weighted mix of categories, so no per-task results are stored; the task count (5,000) is an assumption.", {"final": 53.76}),
+    ("ifbench", "IFBench (prompt)", "if", "pass@1", "NeMo Skills", 300, 8, "rate", "300 prompts (assumed). 8 repeats (assumed).", {"final": 71.51}),
+    ("multichallenge", "Scale AI Multi-Challenge", "if", "accuracy", "dedicated container (GPT-4o judge)", 273, 1, "rate", "273 conversations (public size; assumed). 1 attempt (assumed).", {"final": 38.45}),
+    ("arena_hard", "Arena-Hard-V2 (average)", "chat", "win rate (GPT-4.1 judge)", "Arena-Hard container", 750, 1, "avg", "Average of the hard-prompt and creative-writing subsets; no per-task results stored. 750 prompts (assumed).", {"final": 67.65}),
+    ("aa_lcr", "AA-LCR", "long_context", "accuracy", "NeMo Skills", 100, 16, "rate", "100 questions (public size; assumed). 16 repeats (assumed, as for Super).", {"final": 35.85}),
+    ("ruler_256k", "RULER @ 256k", "long_context", "accuracy", "RULER container", 13, 100, "rate", "13 RULER tasks (assumed) × 100 samples per task (assumed, as for Super).", {"final": 92.92}),
+    ("ruler_512k", "RULER @ 512k", "long_context", "accuracy", "RULER container", 13, 100, "rate", "13 RULER tasks (assumed) × 100 samples per task (assumed).", {"final": 91.25}),
+    ("ruler_1m", "RULER @ 1M", "long_context", "accuracy", "RULER container", 13, 100, "rate", "13 RULER tasks (assumed) × 100 samples per task (assumed).", {"final": 86.34}),
+    ("mmlu_prox", "MMLU-ProX (avg over languages)", "multilingual", "mean accuracy over languages", "NeMo Skills", 11829, 1, "avg", "Average over languages; no per-task results stored. 11,829 questions per language (assumed).", {"final": 59.5}),
+    ("wmt24", "WMT24++ (en→xx)", "multilingual", "score", "NeMo Skills, XCOMET-XXL", 998, 1, "score", "XCOMET-XXL score (×100), stored as published. 998 segments per pair (assumed).", {"final": 86.2}),
+]
+
+
+def nano_envs():
+    rep = NANO_REPORT
+    g = lambda kind, rule: (kind, kind.replace("_", " "), [{"name": "reward", "weight": 1.0, "rule": rule}], None)
+    return [
+        dict(key="math_with_judge", name="math_with_judge", domain="math", task_count=121000, reward="binary", harness="NeMo Gym simple_agent", tools=[], sandbox=None,
+             grader=g("math_verify", "Math-Verify with an LLM-judge fallback."), description="Math: DAPO-17K (17K) and Skywork (104K) problems (Nano report §3).",
+             real=[], fallback=banks.MATH, prefix="math", profile=dict(turns=(1, 1), tokens_out=7000, tokens_in=300, seconds=120, infra_rate=0.002, max_tokens=49152), source=rep, version="nano-v3"),
+        dict(key="code_gen", name="code_gen", domain="competitive_code", task_count=22000, reward="binary", harness="NeMo Gym simple_agent", tools=[], sandbox={"kind": "local process execution"},
+             grader=g("unit_tests", "All unit tests must pass (at most 50 tests per problem)."), description="Competitive coding: 22K problems, unit tests capped at 50 per problem (Nano report §3).",
+             real=[], fallback=banks.CODE_PROBLEMS, prefix="comp_coding", profile=dict(turns=(1, 1), tokens_out=9000, tokens_in=900, seconds=180, infra_rate=0.004, max_tokens=49152), source=rep, version="nano-v3"),
+        dict(key="mcqa", name="mcqa", domain="science", task_count=135000, reward="binary", harness="NeMo Gym simple_agent", tools=[], sandbox=None,
+             grader=g("exact_match", "Option letter matches the gold letter."), description="STEM multiple-choice QA: 135K tasks (Nano report §3).",
+             real=[], fallback=banks.SCIENCE, prefix="stem_mcqa", profile=dict(turns=(1, 1), tokens_out=3500, tokens_in=500, seconds=70, infra_rate=0.002, max_tokens=49152), source=rep, version="nano-v3"),
+        dict(key="structured_outputs", name="structured_outputs", domain="if", task_count=9000, reward="binary", harness="NeMo Gym simple_agent", tools=[], sandbox=None,
+             grader=g("schema_validation", "JSON-schema validation only; content not verified."), description="Structured outputs: 9K tasks (Nano report §3).",
+             real=[], fallback=STRUCTURED_SIM, prefix="structured_outputs", profile=dict(turns=(1, 1), tokens_out=1500, tokens_in=1500, seconds=45, infra_rate=0.002, max_tokens=49152), source=rep, version="nano-v3"),
+        dict(key="instruction_following", name="instruction_following", domain="if", task_count=46000, reward="binary", harness="NeMo Gym simple_agent", tools=[], sandbox=None,
+             grader=g("rubric", "IFEval-style programmatic checkers; every instruction must pass."), description="IFEval-style instruction following: 46K tasks (Nano report §3).",
+             real=[], fallback=banks.IF_TASKS, prefix="instruction_following", profile=dict(turns=(1, 1), tokens_out=2200, tokens_in=400, seconds=55, infra_rate=0.002, max_tokens=49152), source=rep, version="nano-v3"),
+        dict(key="multiturn_if", name="multi-turn instruction following", domain="if", task_count=3000, reward="partial", harness="NeMo Gym simple_agent", tools=[], sandbox=None,
+             grader=g("rubric", "Grader not described in the dossier for Nano; Super's multichallenge server scores LLM-judged rubric questions and averages them."), description="Multi-turn instruction following: 3K tasks (Nano report §3).",
+             real=[], fallback=MULTITURN_SIM, prefix="multi_turn_if", profile=dict(turns=(1, 1), tokens_out=2800, tokens_in=4000, seconds=75, infra_rate=0.004, max_tokens=49152, partial_steps=4), source=rep, version="nano-v3"),
+        dict(key="long_context_qa", name="long-context QA", domain="long_context", task_count=12000, reward="binary", harness="NeMo Gym simple_agent", tools=[], sandbox=None,
+             grader=g("llm_judge", "Qwen3-235B-A22B-Instruct-2507 judges the answer against the reference."), description="Long-context QA: 12K tasks with at least 5 documents and at most 32K input tokens, judged by Qwen3-235B-A22B-Instruct-2507 (Nano report §3).",
+             real=[], fallback=LONG_CONTEXT_SIM, prefix="lc_qa", profile=dict(turns=(1, 1), tokens_out=2500, tokens_in=28000, seconds=90, infra_rate=0.004, max_tokens=49152), source=rep, version="nano-v3"),
+        dict(key="workplace_assistant", name="workplace_assistant", domain="tool_use", task_count=690, reward="binary", harness="NeMo Gym simple_agent", tools=["26 tools over 5 databases"],
+             sandbox={"kind": "in-process sandbox databases", "databases": 5, "tools": 26},
+             grader=g("execution", "Compares the final database state with the ground truth."), description="Workplace Assistant: 690 tasks over 5 databases and 26 tools (Nano report §3).",
+             real=[], fallback=WORKPLACE_SIM, prefix="workbench", profile=dict(turns=(5, 20), tokens_out=2200, tokens_in=3000, seconds=110, infra_rate=0.004, max_tokens=49152), source=rep, version="nano-v3"),
+        dict(key="banking_agent", name="banking conversational agent", domain="tool_use", task_count=1000, reward="binary", harness="NeMo Gym", tools=[],
+             sandbox=None, grader=g("other", "Grader not described in the dossier."),
+             description="About 1K banking conversational-agent tasks (Nano report §3; the report's figure is approximate).",
+             real=[], fallback=BANKING_SIM, prefix="banking", profile=dict(turns=(6, 20), tokens_out=1800, tokens_in=2500, seconds=100, infra_rate=0.004, max_tokens=49152), source=rep, version="nano-v3"),
+        dict(key="genrm_compare", name="genrm_compare", domain="chat", task_count=None, reward="scalar", harness="NeMo Gym simple_agent", tools=[], sandbox=None,
+             grader=("reward_model", "GenRM pairwise comparisons",
+                     [{"name": "genrm_pairwise", "weight": 1.0, "rule": "Qwen3-Nemotron-235B-A22B-GenRM compares responses with circular pairing."},
+                      {"name": "length_control", "weight": -1.0, "rule": "Group Relative Length Control: λ 0.5 on reasoning and answer length; conciseness bonus 0.5 above the 80th percentile."}],
+                     "reward = genrm_pairwise − length_control"),
+             description="RLHF prompts scored by the Nano GenRM (Nano report §3.3). The prompt count isn't given in the dossier, so the size is unknown.",
+             real=[], fallback=banks.CHAT, prefix="rlhf", profile=dict(turns=(1, 1), tokens_out=3000, tokens_in=600, seconds=80, infra_rate=0.006, max_tokens=49152, judge=True), source=rep, version="nano-v3"),
+    ]
+
+
+def build_nano(w, org_id, cluster_id):
+    pid = kit.project(
+        w, org_id, "nemotron-3-nano", "Nemotron 3 Nano post-training",
+        "Post-training of the 31.6B-total / 3.2B-active hybrid Mamba-Transformer MoE: SFT on 18M+ samples, RLVR with a pass-rate "
+        "curriculum across math, code, STEM, instruction following, long context and agentic environments, RLHF with a GenRM, then RLVR "
+        "again. Released December 15, 2025.",
+        [{"title": "Nemotron 3 Nano technical report (arXiv 2512.20848)", "url": NANO_REPORT},
+         {"title": "NVIDIA Nemotron 3 white paper (arXiv 2512.20856)", "url": WHITEPAPER},
+         {"title": "NVIDIA-Nemotron-3-Nano-30B-A3B-BF16 model card", "url": NANO_CARD},
+         {"title": "Nemotron-3-Nano-RL-Training-Blend", "url": NANO_BLEND},
+         {"title": "NeMo RL grpo_nanov3.yaml", "url": NANO_CFG},
+         {"title": "Qwen3-Nemotron-235B-A22B-GenRM card", "url": NANO_GENRM_CARD}],
+        "A smaller companion to the Super project. Published: architecture, SFT recipe and blend shares, RL batch shape and config values, "
+        "environment sizes, the released RL blend size, the batch pass-rate curriculum (about 0.7 falling to 0.4 over roughly 600 steps, "
+        "Figure 6), final scores, the DPO study and GenRM scores. Simulated: environment weights (proportional to environment size), "
+        "step counts except SFT's, dates before the 2025-12-15 release, curves, rollouts, tasks and per-task eval results.",
+        T("2025-10-15 00:00"), pins=["train/accuracy", "train/reward"])
+    M = lambda k: rid("model", pid, k)
+    NSTEPS = {"sft": 13000, "rlvr1": 300, "rlhf": 50, "rlvr2": 80, "dpo": 50}  # SFT and DPO published; RL not (Figure 6: ~600 for RLVR)
+    specs = nano_envs()
+    envs = {}
+    created = T("2025-10-25 00:00")
+    for spec in specs:
+        envs[spec["key"]] = write_env(w, pid, spec, cap=250, created_at=created)
+    w.conn.execute("UPDATE environments SET task_count=NULL WHERE id=?", (envs["genrm_compare"].id,))
+
+    slices = [("Chat", 28.6), ("Code", 20.7), ("Science", 12.8), ("Math", 9.9), ("Multilingual", 7.4), ("Math w/ Tools", 4.9), ("GenSelect", 3.0),
+              ("SWE", 3.0), ("Formal Proofs", 2.0), ("Long Context", 2.0), ("Conversational Agent", 2.0), ("Terminal Use", 1.5)]
+    sft_ds = kit.dataset(
+        w, pid, "sft_blend", "Nemotron 3 Nano SFT blend (internal)", "sft", rows=18000000,
+        sources=[{"name": f"{n} — {p:.1f}% of the blend (unit not stated)", "category": n.lower(), "rows": None, "url": NANO_REPORT} for n, p in slices],
+        processing=[{"step": "Reasoning-off strip", "rows_in": None, "rows_out": None, "note": "Reasoning removed from 10% of samples."},
+                    {"step": "Budget-control truncation", "rows_in": None, "rows_out": None, "note": "3% of samples truncated for reasoning-budget control."}],
+        description="Nano SFT data: 18M+ samples. The listed slices add up to 97.8%; the dossier doesn't itemize the rest, and doesn't say whether the shares count samples or tokens.",
+        created_at=T("2025-10-18 00:00"), source=NANO_REPORT, provenance="published")
+    rl_ds = kit.dataset(
+        w, pid, "rl_blend", "Nemotron-3-Nano-RL-Training-Blend", "rl", rows=93244, hf_repo="nvidia/Nemotron-3-Nano-RL-Training-Blend",
+        description="The released Nano RL blend: 93,244 samples. Its per-environment composition isn't measured in the dossier; the environment sizes come from the report.",
+        source=NANO_BLEND, provenance="published")
+
+    # runs
+    s = sft_run(
+        w, project_id=pid, key="sft", name="Nano SFT", framework="megatron_sft", datasets=[(sft_ds, 1.0)], base_model_id=M("base"),
+        output_model_id=M("sft"), steps=13000, start=T("2025-10-20 00:00"), step_seconds=40.0, loss=(0.9, 0.48), lr=5e-5, warmup=800 / 13000,
+        schedule="constant", global_batch=64, seq_len=262144, gpu=None, gpus=None, cost_rate=0.0, owner=OWNER, tags=["sft"], stage="SFT",
+        group_name="nemotron-3-nano",
+        hyperparams={"warmup_steps": 800, "moe_load_balancing_coef": 1e-4, "packed_seq_len": 262144, "samples": "18M+",
+                     "reasoning_off_share": 0.10, "budget_truncation_share": 0.03, "lr_decay": "not stated in the dossier (demo: constant)", "gpus": "not published"},
+        config="# Nano SFT: published values (Nano report §3.1), not a verbatim file\nsteps: 13000\nglobal_batch_size: 64\npacked_sequence_length: 262144\nlearning_rate: 5.0e-5   # 800 warmup steps\nmoe_load_balancing_coef: 1.0e-4\nreasoning_off: 10% of samples\nbudget_truncation: 3% of samples\n# not published here: LR decay, GPUs, wall-clock",
+        description="Nano SFT (report §3.1; the dossier doesn't name the training framework). Published: 18M+ samples, 13,000 steps, batch 64, 256K packing, LR 5e-5 with 800 warmup steps, MoE load-balancing coefficient 1e-4. Simulated: timing, the loss curve and the constant LR after warmup (decay not given).",
+        source=NANO_REPORT, provenance="simulated")
+    finish_sft(w, s, M("sft"), 13000)
+
+    weights_rows = {k: spec["task_count"] for k, spec in ((sp["key"], sp) for sp in specs) if k != "genrm_compare"}
+    total = sum(weights_rows.values())
+    rl_keys = list(weights_rows)
+    nano_rl = dict(framework="nemo_rl", owner=OWNER, group_name="nemotron-3-nano", provenance="simulated", code_ref="NVIDIA-NeMo/RL (grpo_nanov3.yaml)",
+                   gpu=None, cost_rate=0.0, train_infer_kl=0.0008, ckpt_every=10, async_rl=False, store_groups=2)
+    nano_hp = lambda steps, note: {
+        "prompts_per_step": 128, "group_size": 16, "global_batch": 2048, "lr": 3e-6, "clip_low": 0.2, "clip_high": 0.28, "max_seq_len": 49152,
+        "algorithm": "synchronous GRPO with masked importance sampling", "router": "frozen", "overlong_filtering": True, "nodes": 32, "gpus": 256,
+        "colocated": True, "env_weights": "proportional to environment size (assumption)", "steps": note}
+    nano_cfg = ("# Nano RLVR: published values (Nano report §3.2; NeMo RL examples/nemo_gym/grpo_nanov3.yaml), not a verbatim file\n"
+                "algorithm: GRPO, synchronous, masked importance sampling\nprompts_per_step: 128\ngenerations_per_prompt: 16   # batch 2,048\n"
+                "learning_rate: 3.0e-6\nratio_clip: [0.2, 0.28]\nmax_total_sequence_length: 49152\nrouter: frozen\noverlong_filtering: true\n"
+                "curriculum: per-domain Gaussian target pass rates whose mean decreases linearly; re-profile on the best checkpoint when progress plateaus\n"
+                "cluster: {nodes: 32, colocated: true}\n")
+    envs_list = [(envs[k], round(128 * weights_rows[k] / total, 2)) for k in rl_keys]
+    r1 = rl_run(w, project_id=pid, key="rlvr1", name="Nano RLVR 1", envs=envs_list, base_model_id=M("sft"), output_model_id=M("rlvr1"),
+                steps=300, group_size=16, prompts_per_step=128, sample_groups=96, start=T("2025-11-03 00:00"), step_seconds=600.0,
+                env_targets={envs[k].id: (0.70, 0.40) for k in rl_keys}, shape=0.01, noise=0.01, algorithm="GRPO (synchronous)",
+                hyperparams=nano_hp(300, "not published; Figure 6 spans roughly 600 steps, the demo stores 300"), config=nano_cfg, gpus=256,
+                tags=["rlvr", "curriculum"], stage="RL", entropy=(0.45, 0.38), lr=3e-6, parent_run_id=s["run_id"], extra=rl_extra(False),
+                description=("First RLVR stage of Nano (report §3.2). Published: synchronous GRPO with masked importance sampling; 128 prompts × 16 "
+                             "generations = 2,048 per step; frozen router; 49K max generation with overlong filtering; LR 3e-6, clip 0.2 / 0.28, "
+                             "49,152 max length on 32 colocated nodes (grpo_nanov3.yaml); a per-domain Gaussian pass-rate curriculum whose target "
+                             "mean falls linearly, with the batch pass rate going from about 0.7 to about 0.4 over roughly 600 steps (Figure 6). "
+                             "Simulated: the demo stores 300 steps (its per-run budget), so the same 0.7 → 0.4 fall happens over half as many steps; "
+                             "environment weights proportional to environment size; timing, curves and rollouts."),
+                source=NANO_REPORT,
+                events=[{"step": 0, "kind": "config", "title": "Curriculum", "body": "Prompts the SFT model always solves are removed; per-domain target pass rates start near 0.7 and fall linearly, so the batch pass rate falls by design (Figure 6)."},
+                        {"step": 0, "kind": "notice", "title": "All environments at once", "body": "Single-environment RL caused un-recoverable regressions on other benchmarks, so every batch mixes all domains (report §3.2)."}],
+                **nano_rl)
+    finish_rl(w, r1, M("rlvr1"), 300, False)
+    nano_base = {envs[k].id: 0.55 for k in rl_keys}
+    curriculum_tasks(w, r1, {envs[k].id: (0.70, 0.40) for k in rl_keys}, 0.01, 300, nano_base)
+    add_jobs(w, pid, r1["run_id"], "Nano RLVR 1", cluster_id, T("2025-11-03 00:00"), r1["end"], [("colocated training + generation", "train", 32)], None,
+             "32 colocated nodes (grpo_nanov3.yaml); GPU type not stated; duration simulated; cost not published.")
+    genrm_env = envs["genrm_compare"]
+    rh_start = r1["end"] + 3 * 86400
+    rh = rl_run(w, project_id=pid, key="rlhf", name="Nano RLHF", envs=[(genrm_env, 128.0)], base_model_id=M("rlvr1"), output_model_id=M("rlhf"),
+                steps=NSTEPS["rlhf"], group_size=16, prompts_per_step=128, sample_groups=96, start=rh_start, step_seconds=600.0,
+                env_targets={genrm_env.id: (0.5, 0.5)}, noise=0.01, algorithm="GRPO (synchronous) with GenRM rewards",
+                hyperparams={"prompts_per_step": 128, "group_size": 16, "global_batch": 2048, "reward": "Qwen3-Nemotron-235B-A22B-GenRM, circular comparisons",
+                             "length_control": "λ 0.5 for reasoning and answer; conciseness bonus 0.5 above the 80th percentile", "lr": "not stated in the dossier",
+                             "steps": f"not published (demo: {NSTEPS['rlhf']})"},
+                config="# Nano RLHF: published values (Nano report §3.3), not a verbatim file\nprompts_per_step: 128\ngenerations_per_prompt: 16\nreward: GenRM pairwise, circular comparisons\ngroup_relative_length_control: {reasoning: 0.5, answer: 0.5, conciseness_bonus: 0.5, percentile: 80}\n",
+                gpus=256, tags=["rlhf", "genrm", "length-control"], stage="RL", entropy=(0.40, 0.37), lr=3e-6, parent_run_id=r1["run_id"],
+                extra=rl_extra(False),
+                description=("Nano RLHF (report §3.3). Published: GenRM from Qwen3-235B-A22B-Thinking-2507; 128 prompts × 16 generations; circular "
+                             "comparisons; Group Relative Length Control with coefficients 0.5. Simulated: step count, timing, curves and rollouts; "
+                             "GenRM rewards are relative within each group, so their mean stays near the middle."),
+                source=NANO_REPORT,
+                events=[{"step": None, "kind": "incident", "title": "Verbosity grew under the GenRM",
+                         "body": "With the base GenRM reward, response length (mostly reasoning) grew quickly. Group Relative Length Control cut verbosity by about 30% without accuracy loss (report §3.3.2). When in the run isn't published."}],
+                **nano_rl)
+    w.conn.execute("DELETE FROM metrics WHERE run_id=? AND tag='train/lr'", (rh["run_id"],))
+    finish_rl(w, rh, M("rlhf"), NSTEPS["rlhf"], False)
+    add_jobs(w, pid, rh["run_id"], "Nano RLHF", cluster_id, rh_start, rh["end"], [("colocated training + generation", "train", 32)], None,
+             "Node count assumed equal to RLVR's 32 colocated nodes (not stated for RLHF); duration simulated; cost not published.")
+    r2_start = rh["end"] + 2 * 86400
+    r2 = rl_run(w, project_id=pid, key="rlvr2", name="Nano RLVR 2", envs=envs_list, base_model_id=M("rlhf"), output_model_id=M("final"),
+                steps=NSTEPS["rlvr2"], group_size=16, prompts_per_step=128, sample_groups=96, start=r2_start, step_seconds=600.0,
+                env_targets={envs[k].id: (0.70, 0.40) for k in rl_keys}, shape=0.01, noise=0.01, algorithm="GRPO (synchronous)",
+                hyperparams=nano_hp(NSTEPS["rlvr2"], f"not published (demo: {NSTEPS['rlvr2']})"), config=nano_cfg, gpus=256, tags=["rlvr", "curriculum"], stage="RL",
+                entropy=(0.40, 0.36), lr=3e-6, parent_run_id=rh["run_id"], extra=rl_extra(False),
+                description=("The final RLVR stage ('SFT → RLVR → RLHF → RLVR again', report §3.2); it produces the released model. Only the stage "
+                             "itself is published: the demo reuses the RLVR config and curriculum, and step count, timing, curves and rollouts are simulated."),
+                source=NANO_REPORT, **nano_rl)
+    finish_rl(w, r2, M("final"), NSTEPS["rlvr2"], False)
+    curriculum_tasks(w, r2, {envs[k].id: (0.70, 0.40) for k in rl_keys}, 0.01, NSTEPS["rlvr2"], nano_base)
+    add_jobs(w, pid, r2["run_id"], "Nano RLVR 2", cluster_id, r2_start, r2["end"], [("colocated training + generation", "train", 32)], None,
+             "32 colocated nodes (grpo_nanov3.yaml); duration simulated; cost not published.")
+    for rr, inp in ((r1, rl_ds), (r2, rl_ds)):
+        w.add("run_inputs", {"run_id": rr["run_id"], "kind": "dataset", "ref_id": inp, "weight": None})
+
+    d_start = s["end"] + 2 * 86400
+    d = dpo_run(w, project_id=pid, key="dpo_study", name="DPO study (not in the release)", datasets=[], base_model_id=M("sft"),
+                output_model_id=M("dpo"), steps=50, start=d_start, step_seconds=60.0, lr=5e-7, global_batch=128, seq_len=32768,
+                accuracy=0.72, margin=1.6, gpu=None, gpus=None, cost_rate=0.0, owner=OWNER, tags=["dpo", "study", "tool-hallucination"],
+                hyperparams={"steps": 50, "lr": "not published", "global_batch": "not published", "max_seq_len": "not published",
+                             "schedule": "not published", "warmup_ratio": "not published", "data": "not described in the dossier"},
+                config="# Nano DPO study (report Appendix C): published facts only\nsteps: 50\nstarting_point: Nano SFT checkpoint\n# not published: data, learning rate, batch, framework",
+                description=("A 50-step DPO study on the SFT checkpoint (Nano report Appendix C). Published: it cut tool-call hallucination on GPQA "
+                             "from 8.33% to 0.7% and raised AIME25 (80.88 → 84.58) and GPQA (65.15 → 69.19); the released Nano 'does not rely on DPO' "
+                             "because RL achieved comparable results. Simulated: the loss and preference curves; data, LR and batch aren't published."),
+                source=NANO_REPORT, provenance="simulated",
+                events=[{"step": 50, "kind": "notice", "title": "Not used in the release", "body": "RL reached comparable results, so the released model doesn't rely on DPO."}])
+    w.conn.execute("UPDATE runs SET framework=NULL, parent_run_id=? WHERE id=?", (s["run_id"], d["run_id"]))
+    w.conn.execute("DELETE FROM metrics WHERE run_id=? AND tag IN ('train/learning_rate', 'eval/loss')", (d["run_id"],))
+    w.add("checkpoints", {"id": rid("ckpt", d["run_id"], 50), "run_id": d["run_id"], "step": 50, "model_id": M("dpo"),
+                          "path": f"checkpoints/{d['run_id']}/step_50", "size_gb": None, "created_at": d["end"], "kept": 1})
+
+    # models
+    arch = "Hybrid Mamba-2 + attention MoE (128 routed experts, top-6, + 2 shared), 52 layers, d_model 2688"
+    common = dict(arch=arch, params_total=31.6, params_active=3.2)
+    kit.model(w, pid, "base", "Nemotron-3-Nano-30B-A3B-Base", "base", stage="pretrained", created_at=T("2025-10-15 00:00"), status="released",
+              source=NANO_REPORT, notes="3.6B active including embeddings. Repository not named in the dossier; created_at simulated.", **common)
+    for key, name, run_key, parent, step, end in (("sft", "Nano SFT", "sft", "base", 13000, s["end"]), ("rlvr1", "Nano after RLVR 1", "rlvr1", "sft", 300, r1["end"]),
+                                                  ("rlhf", "Nano after RLHF", "rlhf", "rlvr1", NSTEPS["rlhf"], rh["end"])):
+        kit.model(w, pid, key, name, run_key=run_key, parent_id=M(parent), step=step, stage="SFT" if key == "sft" else "RL", created_at=end,
+                  status="internal", source=NANO_REPORT, notes="Intermediate checkpoint (not released); date simulated.", **common)
+    kit.model(w, pid, "final", "NVIDIA-Nemotron-3-Nano-30B-A3B-BF16", hf_repo="nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16", run_key="rlvr2",
+              parent_id=M("rlhf"), step=NSTEPS["rlvr2"], stage="Final", created_at=T("2025-12-15 00:00"), status="released", context_len=1048576,
+              source=NANO_CARD, notes="Released 2025-12-15.", **common)
+    kit.model(w, pid, "dpo", "Nano SFT + 50-step DPO (study)", run_key="dpo_study", parent_id=M("sft"), step=50, stage="DPO study",
+              created_at=d["end"], status="internal", source=NANO_REPORT, notes="Study checkpoint from Appendix C; not part of the release.", **common)
+    kit.model(w, pid, "genrm_init", "Qwen3-235B-A22B-Thinking-2507", "base", params_total=235, params_active=22, arch="Qwen3 MoE",
+              stage="pretrained (Qwen)", source=NANO_GENRM_CARD, notes="Initialization of the Nano GenRM. Parameters from the A22B name.")
+    kit.model(w, pid, "genrm", "Qwen3-Nemotron-235B-A22B-GenRM", "reward", hf_repo="nvidia/Qwen3-Nemotron-235B-A22B-GenRM", parent_id=M("genrm_init"),
+              params_total=235, params_active=22, arch="Qwen3 MoE", context_len=131072, stage="GenRM", created_at=T("2025-10-28 00:00"),
+              status="released", source=NANO_GENRM_CARD,
+              notes="Trained with GRPO (128 prompts × 8 generations) to output helpfulness scores and a ranking; reward = −C1·I_format − |score errors| − C2·|ranking error| with C1 = 10, C2 = 1; accuracy tracked on RM-Bench, JudgeBench and an internal set over ~800 steps (Nano report §3.3.1). Released 2025-12-15 (created_at simulated).")
+    kit.model(w, pid, "judge", "Qwen3-235B-A22B-Instruct-2507", "judge", params_total=235, params_active=22, arch="Qwen3 MoE", stage="judge",
+              source=NANO_REPORT, notes="Judge for long-context QA in Nano RLVR.")
+
+    for ek, env in envs.items():
+        kit.write_tasks(w, env, base_pass=0.5 if ek == "genrm_compare" else 0.55, latest_pass=0.5 if ek == "genrm_compare" else 0.66)
+
+    register_metrics(w, pid, [r1["run_id"], rh["run_id"], r2["run_id"]], [envs[k] for k in rl_keys] + [genrm_env], ["nemo_rl", "megatron_sft", "trl_dpo"])
+
+    # evals
+    t_eval = T("2025-12-05 00:00")
+    nb = add_benchmarks(w, pid, NANO_EVALS, {"final": (M("final"), t_eval, NANO_REPORT)}, t_eval, NANO_REPORT,
+                        {"harness": "NeMo Skills / NeMo Evaluator", "source": NANO_REPORT})
+    # DPO study: published before / after on the SFT checkpoint, attached to the study run
+    for key, before, after in (("aime25", 80.88, 84.58), ("gpqa", 65.15, 69.19)):
+        b = nb[key]
+        for step, model_key, value in ((0, "sft", before), (50, "dpo", after)):
+            eid = eval_run(w, b, model_id=M(model_key), score=fraction(value), run_id=d["run_id"], step=step, started=d_start + step * 60 + 600,
+                           duration=3600, source=NANO_REPORT, provenance="mixed", key=f"dpo|{step}",
+                           config={"study": "Nano report Appendix C", "note": "SFT checkpoint before / after 50 DPO steps"})
+            w.conn.execute("UPDATE evals SET score=? WHERE id=?", (fraction(value), eid))
+    hb = benchmark(w, project_id=pid, key="tool_halluc", name="Tool-call hallucination on GPQA (lower is better)", category="safety",
+                   metric="share of samples with undeclared tool calls", harness="internal", n_tasks=198, k=8, store_tasks=False,
+                   description="Share of GPQA samples where the model calls a tool it wasn't given (lower is better). Stored as published, without per-task results; 198 questions × 8 samples (assumed, as for GPQA).",
+                   source=NANO_REPORT)
+    for step, model_key, value in ((0, "sft", 8.33), (50, "dpo", 0.7)):
+        eval_run(w, hb, model_id=M(model_key), score=fraction(value), run_id=d["run_id"], step=step, started=d_start + step * 60 + 900,
+                 duration=1800, source=NANO_REPORT, provenance="published", key=f"dpo|{step}", raw=True)
+    for key, name, value, n in (("rm_bench", "RM-Bench (overall)", 87.3, 1327), ("judgebench", "JudgeBench (overall)", 87.4, 350)):
+        rb = benchmark(w, project_id=pid, key=key, name=name, category="reward_model", metric="accuracy", harness=name.split(" ")[0], n_tasks=n, k=1,
+                       store_tasks=False, description=f"Reward-model accuracy averaged over the benchmark's subsets, stored as published without per-task results; {n:,} items (assumed).",
+                       source=NANO_GENRM_CARD)
+        eval_run(w, rb, model_id=M("genrm"), score=fraction(value), started=T("2025-11-01 00:00"), duration=3600, source=NANO_GENRM_CARD,
+                 provenance="published", key="genrm", raw=True)
+
+    kit.report(
+        w, pid, "nano-report", "Lessons from the Nemotron 3 Nano report", "Summary of NVIDIA's Nano report (arXiv 2512.20848)", T("2025-12-20 00:00"),
+        "Nano's report publishes the recipe details Super later reuses (curriculum, GenRM, length control) and two measured lessons: DPO fixed "
+        "tool-call hallucination but RL made it unnecessary, and length control stopped RLHF verbosity growth.",
+        [{"claim": "50 steps of DPO cut tool-call hallucination on GPQA from 8.33% to 0.7% and raised accuracy.", "verdict": "upheld",
+          "evidence": f"Appendix C: hallucination 8.33% → 0.7%; AIME25 80.88 → 84.58; GPQA 65.15 → 69.19. {NANO_REPORT}"},
+         {"claim": "RL achieves results comparable to DPO, so the released Nano doesn't use DPO.", "verdict": "open",
+          "evidence": f"Stated in Appendix C without a side-by-side table. {NANO_REPORT}"},
+         {"claim": "Group Relative Length Control cuts verbosity by about 30% without accuracy loss.", "verdict": "upheld",
+          "evidence": f"Report §3.3.2 gives the ~30% reduction; the accuracy claim isn't broken down by benchmark in the dossier. {NANO_REPORT}"},
+         {"claim": "The curriculum beats random sampling on GPQA, LiveCodeBench, AIME25 and IFBench (Figure 7).", "verdict": "open",
+          "evidence": f"Figure 7 shows the comparison; its values aren't transcribed in the dossier. {NANO_REPORT}"},
+         {"claim": "Single-environment RL causes un-recoverable regressions elsewhere.", "verdict": "open",
+          "evidence": f"Stated without numbers (report §3.2). {NANO_REPORT}"}],
+        run_keys=("rlvr1", "rlhf", "rlvr2", "dpo_study"))
+    # no durations, prices or (for SFT) framework are published for Nano
+    w.conn.execute("UPDATE runs SET cost_usd=NULL, cost_rate=NULL WHERE project_id=?", (pid,))
+    w.conn.execute("UPDATE runs SET framework=NULL WHERE id=?", (s["run_id"],))
diff --git a/viewer/build/labs/olmo.py b/viewer/build/labs/olmo.py
new file mode 100644
index 0000000000000000000000000000000000000000..e10ab84aefca34ea02913c75a7d16e84f3dca52f
--- /dev/null
+++ b/viewer/build/labs/olmo.py
@@ -0,0 +1,2556 @@
+"""Ai2 OLMo 3 post-training: Think, Instruct and RL-Zero at 7B and 32B, the Olmo 3.1 continuations, and the earlier
+Tülu 3 / OLMo 2 open-instruct recipes they grew out of.
+
+Published, with the source on each record:
+- 20 public W&B runs of the OLMo 3 pipeline (entity ai2-llm), read anonymously with importers/train_wandb.py and archived in
+  inputs/olmo/wandb-olmo3.json.gz: every SFT and DPO stage, the 7B Think RL run and its newer-infrastructure replica, the public
+  32B Think RL record, the 3.1 32B Instruct RL run and six RL-Zero runs, with their logged configs and per-row timestamps.
+- The 7B Think RL and 3.1 RL-Zero Math curves from public-runs (inputs/olmo/public-runs), plus six earlier Ai2 open-instruct runs.
+- The technical report (arXiv 2512.13961 v2), model and dataset cards: lineage, sizes, datasets with composition and funnels,
+  verifiers, hyperparameters (Tables 47-49), every per-stage score (Tables 14, 15, 22, 25, 26, 31, 52-55), infrastructure facts
+  (§4.4.3, Table 23) and the $2.75M figure for the whole 32B model.
+- Real Dolci rows from the Hugging Face dataset viewer (inputs/olmo/dolci-rows.json.gz): RL prompts with the DPO model's pass rates,
+  SFT and preference sample rows; HF checkpoint branches per model (inputs/olmo/hf-branches.json).
+
+Simulated so that they agree with the published numbers: rollouts and task pass rates (matched to the logged per-verifier correct
+rates), per-task eval results (matched to each published score), and the three RL stages with no public curve (the 3.1 32B Think
+continuation after step 976, 7B Instruct RL, RL-Zero Mix), whose end points are the published scores.
+"""
+import datetime as dt
+import gzip
+import json
+import math
+import statistics
+from pathlib import Path
+
+from .. import kit
+from ..sim import attempt, group_advantages, rid, rng, solve_skill, stable_seed
+from ..training import benchmark, eval_run
+
+INPUTS = Path(__file__).resolve().parent.parent / "inputs" / "olmo"
+
+# ---------------------------------------------------------------- sources
+ARXIV = "https://arxiv.org/abs/2512.13961"
+TR = "https://arxiv.org/html/2512.13961v2"
+
+
+def sec(anchor):
+    return f"{TR}#{anchor}"
+
+
+T14, T15, T25, T26 = sec("S4.T14"), sec("S4.T15"), sec("S5.T25"), sec("S5.T26")
+T17, T19, T20, T21, T22, T23 = sec("S4.T17"), sec("S4.T19"), sec("S4.T20"), sec("S4.SS5"), sec("S4.T22"), sec("S4.T23")
+T24, T27, T29, T30, T31, T32 = sec("S4.T24"), sec("S5.T27"), sec("S5.T29"), sec("S5.T30"), sec("S5.T31"), sec("S5.T32")
+T47, T48, T49, T50, T51 = sec("Ax2.T47"), sec("Ax2.T48"), sec("Ax2.T49"), sec("Ax2.T50"), sec("Ax2.T51")
+T52, T53, T54, T55 = sec("Ax2.T52"), sec("Ax2.T53"), sec("Ax2.T54"), sec("Ax2.T55")
+S24, S421, S431, S441, S442, S443 = sec("S2.SS4"), sec("S4.SS2.SSS1"), sec("S4.SS3.SSS1"), sec("S4.SS4.SSS1"), sec("S4.SS4.SSS2"), sec("S4.SS4.SSS3")
+S521, S531, S54, S61, A64, A71, A73, A74, A81 = (sec("S5.SS2.SSS1"), sec("S5.SS3.SSS1"), sec("S5.SS4"), sec("S6.SS1"), sec("Ax2.SS6.SSS4"),
+                                                sec("Ax2.SS7.SSS1"), sec("Ax2.SS7.SSS3"), sec("Ax2.SS7.SSS4"), sec("Ax2.SS8.SSS1"))
+F16, F20, F27, F37, F39, F40 = sec("S4.F16"), sec("S4.F20"), sec("S6.F27"), sec("Ax2.F37"), sec("Ax2.F39"), sec("Ax2.F40")
+BLOG = "https://allenai.org/blog/olmo3"
+OI = "https://github.com/allenai/open-instruct"
+OI_README = OI + "/blob/main/scripts/train/olmo3/README.md"
+GRPO_FAST = OI + "/blob/42aa63c/open_instruct/grpo_fast.py"
+GT_UTILS = OI + "/blob/42aa63c/open_instruct/ground_truth_utils.py"
+JUDGE_UTILS = OI + "/blob/42aa63c/open_instruct/judge_utils.py"
+OLMO_CORE = "https://github.com/allenai/OLMo-core"
+OLMES = "https://github.com/allenai/olmes/blob/main/oe_eval/configs/task_suites.py"
+MCP_EVAL = "https://github.com/allenai/mcp-tool-eval"
+WB_REPORT = {"think7": "https://wandb.ai/ai2-llm/Olmo-3-7B-Think/reports/Olmo-3-7B-Think-SFT-DPO-RL--VmlldzoxNTE3ODQzMA",
+             "think32": "https://wandb.ai/ai2-llm/Olmo-3-32B-Think/reports/Olmo-3-32B-Think-SFT-DPO-RL--VmlldzoxNTE3OTA5Mg",
+             "instruct7": "https://wandb.ai/ai2-llm/Olmo-3-7B-Instruct/reports/Olmo-3-7B-Instruct-SFT-DPO-RL--VmlldzoxNTE3ODk3Mg",
+             "instruct32": "https://wandb.ai/ai2-llm/Olmo-3-32B-Instruct/reports/Olmo-3-32B-Instruct-SFT-DPO-RL--VmlldzoxNTM0OTIzNw",
+             "rlzero": "https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/reports/Olmo-3-7B-RL-Zero--VmlldzoxNTM0OTI1Nw"}
+OI_PUBLIC = "https://wandb.ai/ai2-llm/open_instruct_public/reports/"
+PRICE = 2.0  # USD per H100-hour, the rate behind the report's $2.75M figure (§2.4)
+
+
+def hf(repo):
+    return "https://huggingface.co/" + repo
+
+
+def hfd(repo):
+    return "https://huggingface.co/datasets/" + repo
+
+
+def stats_url(repo):
+    return f"https://datasets-server.huggingface.co/statistics?dataset={repo}&config=default&split=train"
+
+
+def load(name):
+    p = INPUTS / name
+    if name.endswith(".jsonl.gz"):
+        with gzip.open(p, "rt") as fh:
+            return [json.loads(line) for line in fh if line.strip()]
+    if name.endswith(".gz"):
+        with gzip.open(p, "rt") as fh:
+            return json.load(fh)
+    return json.loads(p.read_text())
+
+
+def at(s):
+    return kit.ts(s)
+
+
+def day(t):
+    return dt.datetime.fromtimestamp(t, dt.timezone.utc).strftime("%Y-%m-%d %H:%M")
+
+
+def pct(v):
+    return round(v / 100.0, 6)
+
+
+
+
+def yaml(d, indent=0):
+    """A small YAML rendering of a config dict (lists and nested dicts inline as JSON)."""
+    lines = []
+    for k, v in d.items():
+        if v is None:
+            continue
+        if isinstance(v, dict) and v and indent < 1:
+            lines.append(" " * indent + f"{k}:")
+            lines.append(yaml(v, indent + 2))
+        else:
+            val = json.dumps(v, ensure_ascii=False) if isinstance(v, (list, dict, bool)) or v is None else v
+            if isinstance(v, bool):
+                val = "true" if v else "false"
+            lines.append(" " * indent + f"{k}: {val}")
+    return "\n".join(x for x in lines if x)
+
+
+# ---------------------------------------------------------------- metric definitions
+# tag -> (label, description, format, better, group, signal)
+TAGDEF = {
+    "objective/verifiable_correct_rate": ("Correct rate (all verifiers)", "Share of training rollouts whose verifier reward is above 0, pooled over verifiers. grpo_fast accumulates it only over the prompt groups kept after zero-variance filtering, and with active sampling it is not a progress measure (the paper tracks held-out evals instead).", "pct", "up", "learning", "pass_rate"),
+    "objective/verifiable_reward": ("Verifiable reward (×10)", "Mean verifier reward, 10 × the verifier score (verification_reward = 10 in every OLMo 3 config).", "num2", "up", "learning", "reward"),
+    "objective/math_correct_rate": ("Correct rate · math", "Share of math rollouts the math verifier marked correct.", "pct", "up", "by_verifier", None),
+    "objective/code_correct_rate": ("Correct rate · code (assert tests)", "Share of code rollouts with reward above 0 (assert-style tests on the remote code API).", "pct", "up", "by_verifier", None),
+    "objective/code_stdio_correct_rate": ("Correct rate · code (stdin/stdout)", "Share of stdin/stdout code rollouts with reward above 0.", "pct", "up", "by_verifier", None),
+    "objective/ifeval_correct_rate": ("Correct rate · instruction following", "Share of IF rollouts with reward above 0 (at least part of the constraints satisfied).", "pct", "up", "by_verifier", None),
+    "objective/general-quality_ref_correct_rate": ("Correct rate · general, with reference", "Share of judge-scored chat rollouts (reference answer given to the Qwen3-32B judge) with a score above 0; close to 1 by construction.", "pct", "up", "by_verifier", None),
+    "objective/general-quality_correct_rate": ("Correct rate · general, no reference", "Share of judge-scored chat rollouts (no reference) with a score above 0; close to 1 by construction.", "pct", "up", "by_verifier", None),
+    "objective/general-quality_ref_reward": ("Judge score ×10 · with reference", "Mean Qwen3-32B judge score (1-10 scale divided by 10, times the ×10 verification reward) on chat prompts with a reference answer.", "num2", "up", "by_verifier", None),
+    "objective/general-quality_reward": ("Judge score ×10 · no reference", "Mean Qwen3-32B judge score on chat prompts without a reference answer (×10).", "num2", "up", "by_verifier", None),
+    "objective/MATH_correct_rate": ("Correct rate · MATH", "Share of MATH rollouts marked correct (legacy Tülu 3 RLVR verifier).", "pct", "up", "by_verifier", None),
+    "objective/gsm8k_correct_rate": ("Correct rate · GSM8K", "Share of GSM8K rollouts marked correct.", "pct", "up", "by_verifier", None),
+    "objective/kl_avg": ("KL to reference (monitor only)", "Per-token KL estimate between the policy and the starting model. beta is 0 in every OLMo 3 config, so it is logged but not in the loss.", "num4", "none", "stability", "kl_ref"),
+    "objective/kl": ("KL (legacy, summed over tokens)", "The legacy trainer's KL summed over response tokens (per the open-instruct docs), not a per-token average.", "num3", "none", "stability", None),
+    "objective/scores": ("Mean score (legacy)", "Mean score of the batch in the legacy trainer.", "num3", "up", "learning", "reward"),
+    "objective/reward_std": ("Reward std (legacy)", "Standard deviation of rewards in the batch.", "num3", "none", "learning", None),
+    "loss/policy_avg": ("Policy loss", "Token-level clipped policy-gradient loss.", "num4", "none", "stability", "pg_loss"),
+    "policy/clipfrac_avg": ("Clip fraction", "Share of tokens whose importance ratio was clipped. 0 at every step in the public OLMo 3 runs, consistent with one gradient step per batch.", "pct", "none", "stability", "clip_frac"),
+    "lr": ("Learning rate", "Optimizer learning rate (constant in every OLMo 3 RL run).", "sci", "none", "stability", "lr"),
+    "val/sequence_lengths": ("Response length", "Mean length of the training rollouts in tokens (open-instruct's val/* keys describe training rollouts, not a held-out set).", "compact", "none", "length", "response_len"),
+    "val/sequence_lengths_max": ("Longest response", "Longest training rollout this step; pinned at the response limit when some responses are cut off.", "compact", "none", "length", None),
+    "val/stop_rate": ("Stop rate", "Share of rollouts that ended on a stop token rather than at the length limit.", "pct", "up", "length", None),
+    "derived/truncated_share": ("Truncated", "1 − val/stop_rate: share of rollouts cut off at the response limit, computed from the logged stop rate (not a logged key).", "pct", "down", "length", "truncation_rate"),
+    "real_batch_size_ratio": ("Batch kept after zero-variance filter", "Rollouts kept after dropping prompt groups whose rewards are all equal, as a share of the expected batch. Without active sampling this is the share of groups with signal; with active sampling the batch is refilled, so it is 1.0.", "pct", "up", "signal", "mixed_share"),
+    "val/all_zero_reward_groups_ratio": ("No-signal: all failed", "Share of prompt groups where every sample got reward 0 (logged by the older grpo_fast).", "pct", "down", "signal", "all_fail_share"),
+    "val/all_solved_reward_groups_ratio": ("No-signal: all solved", "Share of prompt groups where every sample got full reward (logged by the older grpo_fast).", "pct", "down", "signal", "all_pass_share"),
+    "derived/all_zero_share": ("No-signal: all failed", "batch/filtered_prompts_zero ÷ (prompts kept + batch/filtered_prompts): share of the prompts drawn this step that active sampling discarded because every sample failed. Computed from the logged counters (not a logged key).", "pct", "down", "signal", "all_fail_share"),
+    "derived/all_solved_share": ("No-signal: all solved", "batch/filtered_prompts_solved ÷ (prompts kept + batch/filtered_prompts): share of the prompts drawn this step that active sampling discarded because every sample passed. Computed from the logged counters.", "pct", "down", "signal", "all_pass_share"),
+    "batch/filtered_prompts": ("Prompts discarded (all)", "Prompts active sampling discarded this step because their samples all got the same reward.", "int", "down", "signal", None),
+    "batch/filtered_prompts_zero": ("Prompts discarded: all failed", "Prompts discarded because every sample failed.", "int", "down", "signal", None),
+    "batch/filtered_prompts_solved": ("Prompts discarded: all solved", "Prompts discarded because every sample passed.", "int", "down", "signal", None),
+    "batch/percent_solved_mean": ("Mean solve rate of kept prompts", "Mean share of samples solved over the prompts kept in the batch.", "pct", "none", "signal", None),
+    "time/total": ("Step time", "Wall-clock of the whole training step.", "duration", "down", "throughput", "step_time"),
+    "time/training": ("Trainer time", "Learner compute time for the step.", "duration", "down", "throughput", "train_time"),
+    "time/trainer_idling": ("Trainer idle", "Time the learner waited for rollouts this step. The paper: for the 32B reasoner the learner waited about 75% of the time.", "duration", "down", "throughput", None),
+    "time/getting_response": ("Waiting for rollouts", "Time the data thread waited for vLLM actors to return this step's rollouts.", "duration", "down", "throughput", "gen_time"),
+    "time/generation": ("Generation time", "Generation wall-clock (older grpo_fast).", "duration", "down", "throughput", "gen_time"),
+    "learner_tokens_per_second_step": ("Learner throughput", "Tokens the learner processed per second of step time.", "compact", "up", "throughput", "throughput"),
+    "val/num_step_tokens": ("Tokens this step", "Prompt and response tokens packed for training this step.", "compact", "none", "throughput", "tokens_trained"),
+    "debug/vllm_local_reverse_kl": ("Sampler vs learner KL", "Reverse KL between vLLM's and the learner's log-probs on the same tokens (runs with truncated importance sampling log it).", "num4", "down", "consistency", "train_infer_kl"),
+    "epoch": ("Epoch", "Passes over the prompt pool.", "num3", "none", "progress", None),
+    "val/format_scores": ("Format score (legacy)", "Share of rollouts following the answer format.", "pct", "up", "learning", None),
+    "val/stop_token_rate": ("Stop rate (legacy)", "Share of rollouts ending on a stop token.", "pct", "up", "length", None),
+    "objective/non_score_reward": ("KL penalty reward", "Non-score part of the reward (KL penalty) in the legacy trainer.", "num3", "none", "stability", None),
+    "objective/rlhf_reward": ("Total reward (legacy)", "Score plus KL penalty.", "num3", "up", "learning", None),
+    "objective/scores_mean": ("Mean score", "Mean score of the batch.", "num3", "up", "learning", None),
+    "policy/approxkl_avg": ("Approx. KL (policy)", "Approximate KL between old and new policy in the update.", "num4", "none", "stability", None),
+    "objective/kl2": ("KL estimator k2 (legacy)", "", "num3", "none", "stability", None),
+    "objective/kl3": ("KL estimator k3 (legacy)", "", "num3", "none", "stability", None),
+    "objective/kl2_avg": ("KL estimator k2", "Second KL estimator, monitoring only.", "num4", "none", "stability", None),
+    "objective/kl3_avg": ("KL estimator k3", "Third KL estimator, monitoring only; spikes early in several runs.", "num4", "none", "stability", None),
+    "objective/kl4_avg": ("KL estimator k4", "Fourth KL estimator, monitoring only.", "num4", "none", "stability", None),
+    "loss/total_avg": ("Total loss", "Policy loss plus the KL term (0 with beta = 0).", "num4", "none", "stability", None),
+    "loss/kl_avg": ("KL loss", "KL term of the loss; 0 at every step with beta = 0.", "num4", "none", "stability", None),
+    # OLMo-core SFT
+    "train/CE loss": ("Cross-entropy loss", "OLMo-core SFT loss on unmasked assistant tokens (per batch, so it is noisy).", "num3", "down", "learning", "loss"),
+    "optim/LR (group 0)": ("Learning rate", "OLMo-core learning rate: linear warmup over 3% of steps, then linear decay to 0.", "sci", "none", "stability", "lr"),
+    "optim/total grad norm": ("Gradient norm", "Global gradient norm before clipping at 1.0.", "num3", "none", "stability", "grad_norm"),
+    "throughput/device/TPS": ("Tokens/s per GPU", "Training tokens per second on each device.", "compact", "up", "throughput", "throughput"),
+    "throughput/device/MFU": ("MFU per GPU", "Model FLOPs utilisation per device, in percent.", "num1", "up", "throughput", None),
+    "throughput/total tokens": ("Tokens trained (cumulative)", "Tokens trained so far.", "compact", "none", "throughput", None),
+    # open-instruct DPO
+    "train_loss": ("DPO loss", "Length-normalized DPO loss (dpo_norm, beta 5). Starts at ln 2.", "num3", "down", "learning", "loss"),
+    "rewards/accuracy": ("Preference accuracy", "Share of pairs where the chosen response gets the higher implicit reward.", "pct", "up", "learning", "pref_accuracy"),
+    "rewards/margin": ("Reward margin", "Chosen minus rejected implicit reward.", "num3", "up", "learning", "reward_margin"),
+    "rewards/chosen": ("Chosen reward", "Implicit reward of the chosen responses.", "num3", "up", "learning", "chosen_reward"),
+    "rewards/rejected": ("Rejected reward", "Implicit reward of the rejected responses.", "num3", "down", "learning", "rejected_reward"),
+    "rewards/average": ("Mean implicit reward", "Average of chosen and rejected implicit rewards.", "num3", "none", "learning", None),
+    "logps/chosen": ("Log-prob · chosen", "Mean (length-normalized) log-probability of the chosen responses.", "num3", "none", "learning", None),
+    "logps/rejected": ("Log-prob · rejected", "Mean (length-normalized) log-probability of the rejected responses.", "num3", "none", "learning", None),
+    "learning_rate": ("Learning rate", "Linear warmup over 10% of steps, then linear decay.", "sci", "none", "stability", "lr"),
+    "grad_norm": ("Gradient norm", "Global gradient norm (no clipping in the DPO runs).", "num3", "none", "stability", "grad_norm"),
+    "perf/tokens_per_second_step": ("Tokens/s", "Training tokens per second.", "compact", "up", "throughput", "throughput"),
+    "total_tokens": ("Tokens trained (cumulative)", "Tokens trained so far.", "compact", "none", "throughput", None),
+    "per_device_tps": ("Tokens/s per GPU", "Training tokens per second on each device.", "compact", "up", "throughput", "throughput"),
+}
+EVAL_TAG = ("Held-out slice · {v}", "Verifier score on a small held-out slice of the RL prompt mix, run by the trainer every local_eval_every steps.")
+
+
+def metric_def_rows(pid, tags, env_signal, pinned=()):
+    rows = []
+    for tag in sorted(tags):
+        if tag in TAGDEF:
+            label, desc, fmt, better, grp, signal = TAGDEF[tag]
+        elif tag.startswith("eval/"):
+            v = tag.split("/")[-1].replace("_correct_rate", "").replace("_", " ")
+            label, desc, fmt, better, grp, signal = EVAL_TAG[0].format(v=v), EVAL_TAG[1], "pct", "up", "eval", None
+        else:
+            label, desc, fmt, better, grp, signal = tag, "", "num3", "none", tag.split("/")[0], None
+        signal = env_signal.get(tag, signal)
+        rows.append({"tag": tag, "label": label, "description": desc, "unit": "", "format": fmt, "grp": grp, "better": better,
+                     "pinned": 1 if tag in pinned else 0, "signal": signal})
+    # the canonical open_instruct map names count tags as shares; keep them off the health view if they ever appear
+    have = {r["tag"] for r in rows}
+    for tag, label in (("val/all_zero_reward_groups", "All-zero groups (count)"), ("val/all_one_reward_groups", "All-solved groups (count)")):
+        if tag not in have:
+            rows.append({"tag": tag, "label": label, "description": "A count, not a share, so it is not mapped to a health signal.",
+                         "unit": "", "format": "int", "grp": "signal", "better": "none", "pinned": 0, "signal": None})
+    return rows
+
+
+def write_metric_defs(w, pid, tags, env_signal, sft=False, dpo=False):
+    pinned = {"objective/verifiable_correct_rate", "objective/verifiable_reward", "val/sequence_lengths", "time/total", "train/CE loss",
+              "train_loss", "rewards/accuracy", "rewards/margin"}
+    extra = metric_def_rows(pid, tags, env_signal, pinned)
+    kit.metric_defs(w, pid, "open_instruct", extra=extra)
+    if sft:
+        kit.metric_defs(w, pid, "megatron_sft")
+    if dpo:
+        kit.metric_defs(w, pid, "trl_dpo")
+
+
+# ---------------------------------------------------------------- series helpers
+def interp_time(stamps, step):
+    """Wall-clock at a step from logged (step, unix time) pairs, extrapolated at the ends."""
+    if not stamps:
+        return None
+    if step <= stamps[0][0]:
+        if len(stamps) > 1:
+            rate = (stamps[-1][1] - stamps[0][1]) / max(1, stamps[-1][0] - stamps[0][0])
+            return stamps[0][1] - (stamps[0][0] - step) * rate
+        return stamps[0][1]
+    if step >= stamps[-1][0]:
+        if len(stamps) > 1:
+            rate = (stamps[-1][1] - stamps[0][1]) / max(1, stamps[-1][0] - stamps[0][0])
+            return stamps[-1][1] + (step - stamps[-1][0]) * rate
+        return stamps[-1][1]
+    lo, hi = 0, len(stamps) - 1
+    while hi - lo > 1:
+        mid = (lo + hi) // 2
+        if stamps[mid][0] <= step:
+            lo = mid
+        else:
+            hi = mid
+    (s0, t0), (s1, t1) = stamps[lo], stamps[hi]
+    return t0 + (t1 - t0) * (step - s0) / max(1, s1 - s0)
+
+
+def thin(rows, n, keep=lambda r: False):
+    if len(rows) <= n:
+        return rows
+    idx = {round(i * (len(rows) - 1) / (n - 1)) for i in range(n)}
+    return [r for i, r in enumerate(rows) if i in idx or keep(r)]
+
+
+
+
+def med(rows, tag):
+    vals = [r[tag] for r in rows if r.get(tag) is not None]
+    return statistics.median(vals) if vals else None
+
+
+def window(rows, tag, lo, hi):
+    vals = [r[tag] for r in rows if r.get(tag) is not None and lo <= r["step"] <= hi]
+    return sum(vals) / len(vals) if vals else None
+
+
+
+
+def judge_target(mean_reward):
+    """Pass probability p for which a judge-scored attempt averages mean_reward (sim.attempt draws Beta(1+6p, 1+6(1-p)), mean 0.125 + 0.75p)."""
+    return min(0.99, max(0.01, (mean_reward - 0.125) / 0.75))
+
+
+def partial_target(correct_rate, parts):
+    """Per-constraint pass probability for which P(reward > 0) equals the logged correct rate (sim.attempt passes each part with p**0.6)."""
+    c = min(0.999, max(0.001, correct_rate))
+    q = 1 - (1 - c) ** (1.0 / parts)
+    return min(0.99, max(0.01, q ** (1 / 0.6)))
+
+
+def inv_norm(p):
+    """Standard normal quantile (Acklam's approximation)."""
+    p = min(1 - 1e-9, max(1e-9, p))
+    a = [-3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02, 1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00]
+    b = [-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02, 6.680131188771972e+01, -1.328068155288572e+01]
+    c = [-7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00, -2.549732539343734e+00, 4.374664141464968e+00, 2.938163982698783e+00]
+    d = [7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, 3.754408661907416e+00]
+    if p < 0.02425:
+        q = math.sqrt(-2 * math.log(p))
+        return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)
+    if p > 1 - 0.02425:
+        q = math.sqrt(-2 * math.log(1 - p))
+        return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1)
+    q = p - 0.5
+    r = q * q
+    return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1)
+
+
+# ---------------------------------------------------------------- environments with real tasks
+def row_bank(items):
+    def gen(r, i):
+        x = items[i]
+        return str(x["id"])[:120], x["prompt"]
+    return gen
+
+
+def real_env(w, pid, key, name, domain, items, *, grader_id, reward_kind, task_count, description, source, profile, verifiers, checks=None,
+             created_at=None, version=""):
+    """An environment whose stored tasks are real published prompts. Tasks with a published pass rate of the starting (DPO) model get a
+    difficulty that reproduces it at skill 0; the others keep a random difficulty."""
+    env = kit.environment(
+        w, pid, key, name, domain, n_tasks=len(items), bank=row_bank(items), grader_id=grader_id,
+        harness="open-instruct grpo_fast: one vLLM completion per sample, verified in the trainer's data-preparation thread",
+        tools=[], reward_kind=reward_kind, sandbox=None, description=description, version=version, source=source, provenance="mixed",
+        difficulty=(0.0, 1.6), profile=profile, created_at=created_at, task_count=task_count, checks=checks)
+    env.verifiers = verifiers
+    env.real_pass = 0
+    for t, x in zip(env.tasks, items):
+        tags = [x.get("src", "").split("/")[-1][:48], x.get("verifier")]
+        if x.get("passrate") is not None:
+            p = min(0.97, max(0.03, x["passrate"]))
+            t.difficulty = -math.log(p / (1 - p))
+            n = x.get("rollouts") or 8
+            tags.append(f"DPO model {round(x['passrate'] * n)}/{n}")
+            env.real_pass += 1
+        if x.get("gt"):
+            t.meta = {"reference": x["gt"][:200]}
+        t.tags = [y for y in tags if y]
+    return env
+
+
+# ---------------------------------------------------------------- RL run writer (real or synthetic rows)
+class Ctx:
+    def __init__(self, w, org_id, pid, slug):
+        self.w, self.org_id, self.pid, self.slug = w, org_id, pid, slug
+        self.tags = set()
+        self.env_signal = {}
+        self.runs = {}
+        self.sft = False
+        self.dpo = False
+
+
+def rl_run_record(ctx, *, key, name, rows, base_model_id, output_model_id, envs, prompts, group, max_tokens, active, normalize_adv,
+                  learner_gpus, actor_gpus, cluster, description, source, provenance, config, hyperparams, status="completed",
+                  status_reason="", stage="RL", group_name=None, parent_run_id=None, tags=(), events=(), checkpoints=(),
+                  store_steps=80, datasets=(), async_steps=1, start=None, owner="Ai2 OLMo team", code_ref="", primary=None,
+                  judge_gpus=None, code_exec=True):
+    """Write one RL run from per-step rows (real W&B rows and/or synthetic rows marked _sim) with the real open-instruct tags.
+
+    envs: [(Env, weight)] where each Env carries .verifiers (the objective/<verifier> keys it answers for).
+    Stored rollouts are simulated at `store_steps` logged steps so that each verifier's pass rate matches the logged correct rate."""
+    w, pid = ctx.w, ctx.pid
+    run_id = rid("run", pid, key)
+    rows = sorted(rows, key=lambda r: r["step"])
+    # derived series
+    for r in rows:
+        if r.get("val/stop_rate") is not None:
+            r["derived/truncated_share"] = round(1 - r["val/stop_rate"], 6)
+        if active and r.get("batch/filtered_prompts_zero") is not None:
+            drawn = prompts + (r.get("batch/filtered_prompts") if r.get("batch/filtered_prompts") is not None
+                               else r["batch/filtered_prompts_zero"] + (r.get("batch/filtered_prompts_solved") or 0))
+            r["derived/all_zero_share"] = round(r["batch/filtered_prompts_zero"] / drawn, 6)
+            if r.get("batch/filtered_prompts_solved") is not None:
+                r["derived/all_solved_share"] = round(r["batch/filtered_prompts_solved"] / drawn, 6)
+    stamps = [(r["step"], r["_timestamp"]) for r in rows if r.get("_timestamp")]
+    first_dur = rows[0].get("time/total") or med(rows, "time/total") or 600.0
+    t_start = start or ((stamps[0][1] - first_dur) if stamps else None)
+    t_end = stamps[-1][1] if stamps else None
+    # metrics
+    skip = {"step", "_timestamp", "_sim", "episode", "training_step"}
+    mrows = []
+    for r in rows:
+        for k, v in r.items():
+            if k in skip or v is None or isinstance(v, (list, dict, str)):
+                continue
+            if isinstance(v, float) and (math.isnan(v) or math.isinf(v)):
+                continue
+            mrows.append({"run_id": run_id, "tag": k, "step": int(r["step"]), "value": float(v)})
+            ctx.tags.add(k)
+    w.add_many("metrics", mrows)
+    # run steps
+    step_rows = []
+    prev_t = t_start
+    for r in rows:
+        t = interp_time(stamps, r["step"]) if stamps else None
+        cr = r.get("objective/verifiable_correct_rate")
+        vr = r.get("objective/verifiable_reward")
+        stop = r.get("val/stop_rate")
+        if active and r.get("batch/filtered_prompts_zero") is not None:
+            fz, fs = int(r["batch/filtered_prompts_zero"]), int(r.get("batch/filtered_prompts_solved") or 0)
+            g_fail, g_pass, g_mixed = fz, fs, prompts
+        elif r.get("val/all_zero_reward_groups_ratio") is not None:
+            zf = r["val/all_zero_reward_groups_ratio"]
+            sf = r.get("val/all_solved_reward_groups_ratio")
+            if sf is None and r.get("real_batch_size_ratio") is not None:
+                sf = max(0.0, 1 - r["real_batch_size_ratio"] - zf)
+            g_fail, g_pass = int(round(zf * prompts)), int(round((sf or 0) * prompts))
+            g_mixed = max(0, prompts - g_fail - g_pass)
+        else:
+            g_fail = g_pass = g_mixed = None
+        step_rows.append({"run_id": run_id, "step": int(r["step"]), "phase": "train", "started_at": prev_t, "ended_at": t,
+                          "prompts": prompts, "rollouts": prompts * group, "rollouts_stored": 0,
+                          "reward_mean": round(vr / 10.0, 4) if vr is not None else (round(cr, 4) if cr is not None else None),
+                          "pass_rate": round(cr, 4) if cr is not None else None,
+                          "tokens": int(r["val/num_step_tokens"]) if r.get("val/num_step_tokens") is not None else None,
+                          "groups_all_pass": g_pass, "groups_all_fail": g_fail, "groups_mixed": g_mixed, "infra_errors": None,
+                          "truncated": int(round((1 - stop) * prompts * group)) if stop is not None else None})
+        prev_t = t
+    # rollouts: simulated at evenly spaced logged steps, matched to each verifier's logged correct rate
+    r_ = rng("olmo-rollouts", pid, key)
+    live = [(e, wt) for e, wt in envs if e.tasks]
+    store_idx = set(round(i * (len(rows) - 1) / max(1, store_steps - 1)) for i in range(min(store_steps, len(rows))))
+    roll = []
+    skill_cache = {}
+    skills_first, skills_last = {}, {}
+    by_step = {sr["step"]: sr for sr in step_rows}
+    for i, r in enumerate(rows):
+        if i not in store_idx or not live:
+            continue
+        mean_len = r.get("val/sequence_lengths") or (live[0][0].tokens_out * 1.2)
+        stop = r.get("val/stop_rate")
+        trunc = max(0.002, min(0.6, 1 - stop)) if stop is not None else 0.01
+        med_len = min(mean_len / 1.2, max_tokens / math.exp(0.6 * inv_norm(1 - trunc)))
+        stored = 0
+        for g in range(2):
+            env = r_.choices([e for e, _ in live], weights=[wt for _, wt in live])[0]
+            ver = next((v for v in env.verifiers if r.get(f"objective/{v}_correct_rate") is not None), None)
+            if env.judge:
+                rew = r.get(f"objective/{ver}_reward") if ver else None
+                p = judge_target(rew / 10.0) if rew is not None else 0.8
+            else:
+                c = r.get(f"objective/{ver}_correct_rate") if ver else r.get("objective/verifiable_correct_rate")
+                c = 0.5 if c is None else c
+                p = partial_target(c, env.partial_steps) if env.partial_steps else min(0.99, max(0.01, c))
+            ck = (env.id, round(p, 3))
+            if ck not in skill_cache:
+                skill_cache[ck] = solve_skill([t.difficulty for t in env.tasks[:300]], p)
+            skill = skill_cache[ck]
+            skills_first.setdefault(env.id, skill)
+            skills_last[env.id] = skill
+            task = env.tasks[r_.randrange(len(env.tasks))]
+            saved = env.tokens_out
+            env.tokens_out = med_len
+            atts = [attempt(r_, env, task, skill, max_tokens=max_tokens) for _ in range(group)]
+            env.tokens_out = saved
+            rewards = [a["reward"] for a in atts]
+            advs = group_advantages(rewards, normalize_adv)
+            scored = [x for x in rewards if x is not None]
+            zero_var = len(set(scored)) <= 1
+            for j, a in enumerate(atts):
+                roll.append({"id": rid("roll", run_id, r["step"], g, j), "run_id": run_id, "eval_id": None, "step": int(r["step"]),
+                             "phase": "train", "group_id": rid("grp", run_id, r["step"], g), "sample": j, "task_id": task.id,
+                             "env_id": env.id, "harness": "open-instruct grpo_fast (vLLM actor)", "model_id": base_model_id,
+                             "reward": a["reward"], "advantage": advs[j],
+                             "scores": None,
+                             "outcome": a["outcome"], "stop_reason": a["stop_reason"], "turns": 1, "tool_calls": 0,
+                             "tokens_in": a["tokens_in"], "tokens_out": a["tokens_out"], "tokens_cached": a["tokens_cached"],
+                             "duration_s": a["duration_s"], "timing": a["timing"],
+                             "staleness": min(async_steps, r_.choice([0, 0, 1, 1, 2])) if async_steps > 1 else r_.choice([0, 1]),
+                             "flags": None, "seed": stable_seed(run_id, r["step"], g, j), "trained": 0 if (a["reward"] is None or zero_var) else 1})
+                stored += 1
+        by_step[int(r["step"])]["rollouts_stored"] = stored
+    if len(step_rows) > 300:
+        stored_i = {i for i, sr in enumerate(step_rows) if sr["rollouts_stored"]}
+        n = max(2, 300 - len(stored_i))
+        keep = {round(i * (len(step_rows) - 1) / (n - 1)) for i in range(n)} | stored_i
+        while len(keep) > 300:
+            keep.discard(max(i for i in keep - stored_i - {len(step_rows) - 1}))
+        step_rows = [sr for i, sr in enumerate(step_rows) if i in keep]
+        for a, b in zip([None] + step_rows[:-1], step_rows):
+            b["started_at"] = a["ended_at"] if a else t_start
+    w.add_many("run_steps", step_rows)
+    w.add_many("rollouts", roll)
+    # checkpoints and events
+    ev = [{"run_id": run_id, "t": t_start, "step": 0, "kind": "start", "severity": "info", "title": "Run started",
+           "body": f"OlmoRL (GRPO) from {ctx.model_names.get(base_model_id, 'the starting model')}: {prompts} prompts × {group} samples per step, "
+                   f"responses up to {max_tokens:,} tokens, {learner_gpus} learner + {actor_gpus} actor GPUs."}]
+    for step, model_id, path in checkpoints:
+        t = interp_time(stamps, step) if stamps else None
+        w.add("checkpoints", {"id": rid("ckpt", run_id, step), "run_id": run_id, "step": step, "model_id": model_id, "path": path,
+                              "size_gb": None, "created_at": t, "kept": 1})
+        ev.append({"run_id": run_id, "t": t, "step": step, "kind": "checkpoint", "severity": "info",
+                   "title": f"Checkpoint step {step}" + (" (released)" if model_id else ""), "body": path})
+    real = [r for r in rows if not r.get("_sim")]
+    tt = [(r["step"], r["time/total"]) for r in real if r.get("time/total")]
+    if len(tt) > 20:
+        m = statistics.median(v for _, v in tt)
+        slow = sorted((x for x in tt if x[1] > 12 * m and x[1] > 7200), key=lambda x: -x[1])[:3]
+        for s, v in sorted(slow):
+            ev.append({"run_id": run_id, "t": interp_time(stamps, s), "step": s, "kind": "notice", "severity": "warning",
+                       "title": f"Slow step: {v / 3600:.1f} h", "body": f"time/total at step {s} was {v:,.0f} s against a median of {m:,.0f} s. The logs don't say why."})
+    rs = [(r["step"], r["_timestamp"]) for r in real if r.get("_timestamp")]
+    if len(rs) > 20:
+        gaps = [(b[1] - a[1], a, b) for a, b in zip(rs, rs[1:])]
+        typical = statistics.median(g for g, _, _ in gaps)
+        for g, a, b in sorted(gaps, key=lambda x: -x[0])[:2]:
+            if g > max(3 * 3600, 25 * typical):
+                ev.append({"run_id": run_id, "t": a[1] + 60, "step": a[0], "kind": "notice", "severity": "warning",
+                           "title": f"No rows logged for {g / 3600:.1f} h",
+                           "body": f"Between step {a[0]} ({day(a[1])} UTC) and step {b[0]} ({day(b[1])} UTC), from the W&B row timestamps."})
+    for e in events:
+        e = dict(e)
+        e.setdefault("severity", "info")
+        e.setdefault("body", "")
+        if "t" not in e:
+            e["t"] = interp_time(stamps, e["step"]) if stamps else t_start
+        ev.append(dict(e, run_id=run_id))
+    if status in ("completed", "failed", "stopped"):
+        ev.append({"run_id": run_id, "t": t_end, "step": rows[-1]["step"], "kind": "end", "severity": "error" if status == "failed" else "info",
+                   "title": {"completed": "Run completed", "failed": "Run failed", "stopped": "Run stopped"}[status], "body": status_reason})
+    w.add_many("run_events", ev)
+    gpus = learner_gpus + actor_gpus
+    hours = (t_end - t_start) / 3600 if (t_end and t_start) else None
+    cost = round(gpus * hours * PRICE, 2) if hours else None
+    w.add("runs", {
+        "id": run_id, "project_id": pid, "name": name, "kind": "rl", "stage": stage, "algorithm": "GRPO (OlmoRL)", "framework": "open_instruct",
+        "status": status, "status_reason": status_reason, "base_model_id": base_model_id, "output_model_id": output_model_id,
+        "started_at": t_start, "ended_at": t_end if status != "running" else None, "updated_at": t_end,
+        "steps_planned": hyperparams.get("steps") or rows[-1]["step"], "steps_done": rows[-1]["step"],
+        "primary_metric": primary or "objective/verifiable_correct_rate", "gpu": "H100", "gpus": gpus, "cost_usd": cost,
+        "cost_rate": gpus * PRICE, "owner": owner, "tags": list(tags), "code_ref": code_ref, "config": config, "config_format": "yaml",
+        "hyperparams": hyperparams, "parent_run_id": parent_run_id, "group_name": group_name, "description": description,
+        "source": source, "provenance": provenance})
+    for env, wt in envs:
+        w.add("run_inputs", {"run_id": run_id, "kind": "environment", "ref_id": env.id, "weight": wt})
+    for ds_id, wt in datasets:
+        w.add("run_inputs", {"run_id": run_id, "kind": "dataset", "ref_id": ds_id, "weight": wt})
+    # jobs: learner, vLLM actors, judge, code execution
+    share_l = learner_gpus / gpus
+    jid = lambda n: rid("job", run_id, n)
+    job_status = status if status != "stopped" else "stopped"
+    w.add("jobs", {"id": jid("learner"), "project_id": pid, "run_id": run_id, "eval_id": None, "name": f"{name} · learners (DeepSpeed ZeRO-3)",
+                   "kind": "train", "status": job_status, "cluster_id": cluster, "gpu": "H100", "gpus": learner_gpus,
+                   "nodes": max(1, learner_gpus // 8), "started_at": t_start, "ended_at": t_end,
+                   "cost_usd": round(cost * share_l, 2) if cost else None, "exit": status, "log_tail": ""})
+    w.add("jobs", {"id": jid("actors"), "project_id": pid, "run_id": run_id, "eval_id": None, "name": f"{name} · vLLM actors",
+                   "kind": "rollout", "status": job_status, "cluster_id": cluster, "gpu": "H100", "gpus": actor_gpus,
+                   "nodes": max(1, actor_gpus // 8), "started_at": t_start, "ended_at": t_end,
+                   "cost_usd": round(cost * (1 - share_l), 2) if cost else None, "exit": status, "log_tail": ""})
+    if any(e.judge for e, _ in envs):
+        w.add("jobs", {"id": jid("judge"), "project_id": pid, "run_id": run_id, "eval_id": None,
+                       "name": f"{name} · Qwen3-32B judge (vLLM, thinking off)", "kind": "grader", "status": job_status, "cluster_id": cluster,
+                       "gpu": "H100", "gpus": judge_gpus, "nodes": None, "started_at": t_start, "ended_at": t_end, "cost_usd": None,
+                       "exit": status, "log_tail": ""})
+    if code_exec and any(v.startswith("code") for e, _ in envs for v in e.verifiers):
+        w.add("jobs", {"id": jid("code"), "project_id": pid, "run_id": run_id, "eval_id": None, "name": f"{name} · code execution API",
+                       "kind": "grader", "status": job_status, "cluster_id": ctx.clusters["lambda"], "gpu": None, "gpus": None, "nodes": None,
+                       "started_at": t_start, "ended_at": t_end, "cost_usd": None, "exit": status, "log_tail": ""})
+    out = {"run_id": run_id, "start": t_start, "end": t_end, "cost": cost, "stamps": stamps, "rows": rows,
+           "skills_first": skills_first, "skills_last": skills_last, "gpus": gpus, "learner_gpus": learner_gpus, "actor_gpus": actor_gpus}
+    ctx.runs[key] = out
+    return out
+
+
+def sft_run_record(ctx, *, key, name, rows, kind, base_model_id, output_model_id, datasets, gpus, cluster, description, source, config,
+                   hyperparams, status="completed", checkpoints=(), events=(), group_name=None, stage=None, tokens_per_step=None,
+                   batch_rows=None, primary=None, algorithm=None, owner="Ai2 OLMo team", step_offset=0, parent_run_id=None, tags=()):
+    """A real SFT (OLMo-core) or DPO (open-instruct) run from its W&B rows."""
+    w, pid = ctx.w, ctx.pid
+    run_id = rid("run", pid, key)
+    rows = sorted(rows, key=lambda r: r["step"])
+    stamps = [(r["step"], r["_timestamp"]) for r in rows if r.get("_timestamp")]
+    t_start, t_end = stamps[0][1], stamps[-1][1]
+    mrows = []
+    for r in rows:
+        for k, v in r.items():
+            if k in ("step", "_timestamp") or v is None or isinstance(v, (list, dict, str)):
+                continue
+            mrows.append({"run_id": run_id, "tag": k, "step": int(r["step"]) + step_offset, "value": float(v)})
+            ctx.tags.add(k)
+    w.add_many("metrics", mrows)
+    last = rows[-1]["step"]
+    n = min(40, len(rows))
+    steps = sorted({rows[round(i * (len(rows) - 1) / max(1, n - 1))]["step"] for i in range(n)})
+    step_rows = []
+    prev = t_start
+    for s in steps:
+        if s == 0:
+            continue
+        t = interp_time(stamps, s)
+        step_rows.append({"run_id": run_id, "step": s, "phase": "train", "started_at": prev, "ended_at": t, "prompts": batch_rows,
+                          "rollouts": 0, "rollouts_stored": 0, "reward_mean": None, "pass_rate": None,
+                          "tokens": int(tokens_per_step) if tokens_per_step else None, "groups_all_pass": None, "groups_all_fail": None,
+                          "groups_mixed": None, "infra_errors": None, "truncated": None})
+        prev = t
+    w.add_many("run_steps", step_rows)
+    ev = [{"run_id": run_id, "t": t_start, "step": 0, "kind": "start", "severity": "info", "title": "Run started",
+           "body": f"{algorithm or kind.upper()} from {ctx.model_names.get(base_model_id, 'the starting model')} on {gpus} H100s."}]
+    for step, model_id, path in checkpoints:
+        t = interp_time(stamps, step)
+        w.add("checkpoints", {"id": rid("ckpt", run_id, step), "run_id": run_id, "step": step, "model_id": model_id, "path": path,
+                              "size_gb": None, "created_at": t, "kept": 1})
+        ev.append({"run_id": run_id, "t": t, "step": step, "kind": "checkpoint", "severity": "info",
+                   "title": f"Checkpoint step {step}" + (" (released)" if model_id else ""), "body": path})
+    for e in events:
+        e = dict(e)
+        e.setdefault("severity", "info")
+        e.setdefault("body", "")
+        e.setdefault("t", interp_time(stamps, e["step"]))
+        ev.append(dict(e, run_id=run_id))
+    ev.append({"run_id": run_id, "t": t_end, "step": last, "kind": "end", "severity": "info", "title": "Run completed", "body": ""})
+    w.add_many("run_events", ev)
+    hours = (t_end - t_start) / 3600
+    cost = round(gpus * hours * PRICE, 2)
+    w.add("runs", {
+        "id": run_id, "project_id": pid, "name": name, "kind": kind, "stage": stage or kind.upper(),
+        "algorithm": algorithm or ("SFT" if kind == "sft" else "DPO"), "framework": "megatron_sft" if kind == "sft" else "open_instruct",
+        "status": status, "status_reason": "", "base_model_id": base_model_id, "output_model_id": output_model_id, "started_at": t_start,
+        "ended_at": t_end, "updated_at": t_end, "steps_planned": hyperparams.get("steps") or last, "steps_done": last,
+        "primary_metric": primary or ("train/CE loss" if kind == "sft" else "train_loss"), "gpu": "H100", "gpus": gpus, "cost_usd": cost,
+        "cost_rate": gpus * PRICE, "owner": owner, "tags": list(tags), "code_ref": OLMO_CORE if kind == "sft" else OI, "config": config,
+        "config_format": "yaml", "hyperparams": hyperparams, "parent_run_id": parent_run_id, "group_name": group_name,
+        "description": description, "source": source, "provenance": "published"})
+    for ds_id, wt in datasets:
+        w.add("run_inputs", {"run_id": run_id, "kind": "dataset", "ref_id": ds_id, "weight": wt})
+    w.add("jobs", {"id": rid("job", run_id, "train"), "project_id": pid, "run_id": run_id, "eval_id": None,
+                   "name": f"{name} · trainer ({'OLMo-core' if kind == 'sft' else 'open-instruct, DeepSpeed ZeRO-3'})", "kind": "train",
+                   "status": status, "cluster_id": cluster, "gpu": "H100", "gpus": gpus, "nodes": max(1, gpus // 8), "started_at": t_start,
+                   "ended_at": t_end, "cost_usd": cost, "exit": status, "log_tail": ""})
+    if kind == "sft":
+        ctx.sft = True
+    else:
+        ctx.dpo = True
+    out = {"run_id": run_id, "start": t_start, "end": t_end, "cost": cost, "gpus": gpus, "rows": rows}
+    ctx.runs[key] = out
+    return out
+
+
+def synth_rows(key, *, first_step, last_step, n, t0, t1, verifiers, shares, prompts, group, max_tokens, active, lengths, stop, kl=None,
+               tis=True, train_frac=(0.12, 0.2), judge_reward=None, tokens_per_rollout=None, fz=None, noise=0.012, lr=1e-6):
+    """Synthetic open-instruct rows for a stage with no public curve.
+
+    verifiers: {verifier: (start, end)} correct rates; lengths/stop: (start, end); shares: {verifier: batch share}."""
+    r = rng("olmo-synth", key)
+    steps = sorted({first_step + round(i * (last_step - first_step) / max(1, n - 1)) for i in range(n)})
+    span = t1 - t0
+    rows = []
+    for i, s in enumerate(steps):
+        x = (s - first_step) / max(1, last_step - first_step)
+        ease = (1 - math.exp(-2.5 * x)) / (1 - math.exp(-2.5))
+        row = {"step": s, "_sim": True, "_timestamp": t0 + span * (s - first_step + 1) / (last_step - first_step + 1), "lr": lr,
+               "policy/clipfrac_avg": 0.0}
+        tot_c, tot_r = 0.0, 0.0
+        for v, (a, b) in verifiers.items():
+            n_v = max(8, prompts * group * shares.get(v, 0))
+            c = min(0.999, max(0.0, a + (b - a) * ease + r.gauss(0, max(noise, math.sqrt(max(1e-4, b * (1 - b)) / n_v)))))
+            row[f"objective/{v}_correct_rate"] = round(c, 6)
+            if v.startswith("general") and judge_reward:
+                ja, jb = judge_reward
+                row[f"objective/{v}_reward"] = round(10 * (ja + (jb - ja) * ease + r.gauss(0, 0.01)), 5)
+                rew = row[f"objective/{v}_reward"] / 10
+            else:
+                rew = c * (0.85 if v == "ifeval" else 1.0)
+            tot_c += shares.get(v, 0) * c
+            tot_r += shares.get(v, 0) * rew
+        row["objective/verifiable_correct_rate"] = round(tot_c, 6)
+        row["objective/verifiable_reward"] = round(10 * tot_r, 5)
+        la, lb = lengths
+        L = la + (lb - la) * ease
+        row["val/sequence_lengths"] = round(L * math.exp(r.gauss(0, 0.04)), 2)
+        sa, sb = stop
+        row["val/stop_rate"] = round(min(1.0, max(0.0, sa + (sb - sa) * ease + r.gauss(0, 0.006))), 5)
+        row["val/sequence_lengths_max"] = max_tokens if row["val/stop_rate"] < 1 else round(L * 2.4)
+        if kl:
+            row["objective/kl_avg"] = round(max(0.0, kl[0] + (kl[1] - kl[0]) * x + r.gauss(0, 0.004)), 6)
+        row["loss/policy_avg"] = round(r.gauss(0.05, 0.08), 5)
+        if active:
+            zf = fz[0] + (fz[1] - fz[0]) * ease if fz else 0.2
+            sf = 0.35 * (tot_c ** 3)
+            drawn = prompts / max(0.05, 1 - zf - sf)
+            row["batch/filtered_prompts_zero"] = int(round(drawn * zf * math.exp(r.gauss(0, 0.15))))
+            row["batch/filtered_prompts_solved"] = int(round(drawn * sf * math.exp(r.gauss(0, 0.15))))
+            row["batch/filtered_prompts"] = row["batch/filtered_prompts_zero"] + row["batch/filtered_prompts_solved"]
+            row["real_batch_size_ratio"] = 1.0
+        else:
+            zf = (fz[0] + (fz[1] - fz[0]) * ease) if fz else 0.15
+            sf = 0.3 * (tot_c ** 3)
+            row["val/all_zero_reward_groups_ratio"] = round(min(0.9, max(0.0, zf + r.gauss(0, 0.03))), 5)
+            row["val/all_solved_reward_groups_ratio"] = round(min(0.9, max(0.0, sf + r.gauss(0, 0.03))), 5)
+            row["real_batch_size_ratio"] = round(max(0.05, 1 - row["val/all_zero_reward_groups_ratio"] - row["val/all_solved_reward_groups_ratio"]), 5)
+        dur = span / max(1, last_step - first_step) * math.exp(r.gauss(0, 0.15))
+        tr = dur * r.uniform(*train_frac)
+        row["time/total"] = round(dur, 2)
+        row["time/training"] = round(tr, 2)
+        row["time/trainer_idling"] = round(max(0.0, dur - tr - r.uniform(5, 25)), 2)
+        row["time/getting_response"] = round(dur * r.uniform(0.85, 0.97), 2)
+        toks = prompts * group * ((tokens_per_rollout or L) + 600)
+        row["val/num_step_tokens"] = int(toks * row["real_batch_size_ratio"])
+        row["learner_tokens_per_second_step"] = round(row["val/num_step_tokens"] / dur, 2)
+        if tis:
+            row["debug/vllm_local_reverse_kl"] = round(1.2e-4 * math.exp(r.gauss(0, 0.5)), 8)
+        rows.append(row)
+    return rows
+
+
+def rename_steps(rows, offset):
+    return [dict(r, step=r["step"] + offset) for r in rows]
+
+
+# ---------------------------------------------------------------- benchmarks and evals
+class Evals:
+    def __init__(self, ctx):
+        self.ctx = ctx
+        self.B = {}
+
+    def bench(self, key, name, category, metric, n, k, desc, source, store=True, harness=None, version=""):
+        b = benchmark(self.ctx.w, project_id=self.ctx.pid, key=key, name=name, version=version, category=category, metric=metric,
+                      harness=harness, n_tasks=n, k=k, description=desc, source=source)
+        b.store_tasks = store
+        self.B[key] = b
+        return b
+
+    def ev(self, key, model_id, value, *, source, ek, run_id=None, step=None, started=None, config=None, command=""):
+        b = self.B[key]
+        ek = f"{model_id}|{ek}"
+        if b.metric in ("score", "index", "elo", "points"):
+            return eval_run(self.ctx.w, b, model_id=model_id, score=value, raw=True, run_id=run_id, step=step, started=started, duration=3600.0,
+                            source=source, provenance="published", key=ek, config=config, command=command)
+        s = pct(value)
+        eid = eval_run(self.ctx.w, b, model_id=model_id, score=s, run_id=run_id, step=step, started=started, duration=3600.0, source=source,
+                       provenance="mixed", key=ek, config=config, command=command)
+        self.ctx.w.conn.execute("UPDATE evals SET score=? WHERE id=?", (s, eid))  # the published score exactly
+        return eid
+
+
+OLMES_NOTE = ("OLMES olmo3:adapt suite: temperature 0.6, top-p 0.95, up to 32,768 generated tokens, thinking traces stripped before scoring "
+              "(report §4.1.1, A.8.1).")
+# key, name, category, metric, stored-count, attempts, store per-task results, description
+MAIN_BENCH = [
+    ("math", "MATH", "Math", "EM flex (Minerva)", 1000, 1, False,
+     "Minerva MATH through OLMES (minerva_math::olmo3:adapt, 7 subtasks), one sample. The report gives no item count; MATH's public test set has 5,000 "
+     "problems, so 1,000 tasks is an assumption and per-task results are not stored."),
+    ("aime24", "AIME 2024", "Math", "pass@1 (avg of 32)", 30, 32, True,
+     "AIME 2024, 30 problems, pass@1 averaged over 32 samples per problem (OLMES aime:2024::olmo3:adapt)."),
+    ("aime25", "AIME 2025", "Math", "pass@1 (avg of 32)", 30, 32, True,
+     "AIME 2025, 30 problems, pass@1 averaged over 32 samples per problem (OLMES aime:2025::olmo3:adapt)."),
+    ("omega", "OMEGA", "Math", "EM flex", 1000, 1, False,
+     "OMEGA math generalization suite (omega::olmo3:adapt, 55 subtasks). Item count not given; 1,000 tasks is an assumption and per-task results are not stored."),
+    ("bbh", "BigBenchHard", "Reasoning", "EM flex", 1000, 1, False,
+     "BIG-Bench Hard with chain of thought (bbh:cot::olmo3:adapt, 23 subtasks). BBH's public set has 6,511 items; 1,000 tasks is an assumption and "
+     "per-task results are not stored."),
+    ("zebra", "ZebraLogic", "Reasoning", "accuracy", 1000, 1, False,
+     "ZebraLogic grid puzzles (zebralogic::olmo3:adapt), custom JSON accuracy. 1,000 puzzles (the public set's size) is an assumption; per-task results "
+     "are not stored."),
+    ("agieval", "AGI Eval English", "Reasoning", "accuracy (MC, CoT)", 1000, 1, False,
+     "AGIEval English subtasks (agi_eval_english::olmo3:adapt, 9 subtasks). Item count not given; 1,000 tasks is an assumption and per-task results are "
+     "not stored."),
+    ("humanevalplus", "HumanEvalPlus", "Code", "pass@1 (10 samples)", 164, 10, True,
+     "HumanEval+ (codex_humanevalplus::olmo3:adapt), pass@1 over 10 samples. 164 problems (HumanEval's size) is an assumption; the report gives no count."),
+    ("mbppplus", "MBPP+", "Code", "pass@1 (10 samples)", 378, 10, True,
+     "MBPP+ (mbppplus::olmo3:adapt), pass@1 over 10 samples. 378 problems (the EvalPlus MBPP+ size) is an assumption; the report gives no count."),
+    ("lcb", "LiveCodeBench v3", "Code", "pass@1 (10 samples)", 400, 10, True,
+     "LiveCodeBench code generation, release v3 (livecodebench_codegeneration::olmo3:adapt), pass@1 over 10 samples. The report gives no count; 400 "
+     "problems is an assumption."),
+    ("ifeval", "IFEval", "Instruction following", "prompt-level loose acc.", 541, 1, True,
+     "IFEval (ifeval::olmo3:adapt), prompt-level loose accuracy. 541 prompts (IFEval's public size) is an assumption; the report gives no count."),
+    ("ifbench", "IFBench", "Instruction following", "prompt-level loose acc.", 300, 1, True,
+     "IFBench out-of-distribution constraints (ifbench::olmo3:adapt), prompt-level loose accuracy. The report gives no count; 300 prompts is an assumption."),
+    ("mmlu", "MMLU", "Knowledge", "accuracy (MC, CoT)", 1000, 1, False,
+     "MMLU with chain of thought (mmlu:cot::olmo3:adapt, 57 subjects). MMLU's test set has 14,042 questions and the OLMES count is not given, so 1,000 "
+     "tasks is an assumption; per-task results are not stored."),
+    ("popqa", "PopQA", "Knowledge", "EM recall", 1000, 1, False,
+     "PopQA (popqa::olmo3:adapt), exact-match recall. Count not given; 1,000 tasks is an assumption and per-task results are not stored."),
+    ("gpqa", "GPQA", "Knowledge", "accuracy (MC, CoT)", 448, 1, True,
+     "GPQA (gpqa::olmo3:adapt). The report does not name the split; 448 questions (the main set) is an assumption. Measured run-to-run std over 3 runs: "
+     "1.48 points, the noisiest eval in the suite (§4.1.1)."),
+    ("alpacaeval", "AlpacaEval 2 LC", "Chat", "LC win rate", 805, 1, False,
+     "AlpacaEval 2 length-controlled win rate with GPT-4.1 as the judge (about 90% cheaper than GPT-4-Turbo). 805 prompts (AlpacaEval's set) is an "
+     "assumption; per-prompt wins are not binary, so no per-task results are stored."),
+    ("safety", "Safety (average of 6)", "Safety", "score", 6, 1, False,
+     "Average of six development safety benchmarks (HarmBench, DAN, XSTest, WildGuard-Test, WildJailbreak-Test, TrustLLM-JailbreakTrigger), normalized "
+     "so higher is safer (A.8.2). Only the average is stored here; the per-benchmark rows are separate benchmarks."),
+]
+TOOL_BENCH = [
+    ("simpleqa", "SimpleQA (search tools)", "Tool use", "accuracy", 200, 3, True,
+     "200-question SimpleQA subset (akariasai/sampled_simpleqa) answered by an OpenAI Agents SDK agent over MCP with Serper search and browsing, "
+     "temperature 0, at most 10 turns, mean of 3 runs (allenai/mcp-tool-eval)."),
+    ("litqa2", "LitQA2 (ASC tools)", "Tool use", "accuracy", 75, 3, True,
+     "75 LitQA2 questions answerable from the Asta Scientific Corpus index, answered with the ASC MCP server's 8 functions, at most 10 turns, mean of 3 runs."),
+    ("bfcl", "BFCL v3", "Tool use", "overall accuracy", 1000, 1, False,
+     "Berkeley Function Calling Leaderboard v3, overall accuracy, from the official Gorilla repository. Count not given; 1,000 tasks is an assumption and "
+     "per-task results are not stored."),
+]
+SAFETY_BENCH = [  # key, name, metric, count (published), description
+    ("dan", "DoAnythingNow", "refusal accuracy", 300, "Refusal accuracy (1 − attack success rate, WildGuard refusal label) on a 300-prompt DAN subsample."),
+    ("harmbench", "HarmBench", "refusal accuracy", 320, "Refusal accuracy (WildGuard safety label) on 320 HarmBench prompts."),
+    ("trustllm", "TrustLLM-JailbreakTrigger", "refusal accuracy", 400, "Refusal accuracy on 400 TrustLLM jailbreak-trigger prompts."),
+    ("wj-harmful", "WildJailbreak-Test Harmful", "refusal accuracy", 2000, "Refusal accuracy on 2,000 adversarial harmful prompts."),
+    ("wj-benign", "WildJailbreak-Test Benign", "compliance", 250, "Compliance on 250 adversarial benign prompts (higher means less over-refusal)."),
+    ("wildguard", "WildGuard-Test", "safety rate", 749, "Safety rate on 749 adversarial WildGuard-Test prompts."),
+    ("xstest", "XSTest", "accuracy", 450, "Over-refusal test: 200 unsafe and 250 safe prompts."),
+    ("bbq-acc", "BBQ Accuracy", "accuracy", 4482, "BBQ question-answering accuracy over 4,482 items."),
+    ("bbq-ambig", "BBQ Bias · ambiguous", "score", 4482, "BBQ bias score on ambiguous contexts (lower is better; can be negative). Only the score is stored."),
+    ("bbq-disambig", "BBQ Bias · disambiguated", "score", 4482, "BBQ bias score on disambiguated contexts (lower is better; can be negative). Only the score is stored."),
+    ("strongreject", "StrongReject", "reversed score", 2294, "Reversed StrongReject classifier score over 2,294 prompts (higher is safer)."),
+    ("toxigen", "Toxigen", "non-toxicity", 1400, "Non-toxicity by the ToxiGen RoBERTa classifier over 1,400 prompts."),
+    ("wmdp", "WMDP", "score", 734, "WMDP value as printed in Tables 52-55 over 734 items. The safety average uses inverted accuracy, and the paper does not say "
+                                   "which form the per-row value is, so only the value is stored."),
+]
+
+
+def make_benches(E, source_main, tools=False):
+    for key, name, cat, metric, n, k, store, desc in MAIN_BENCH + (TOOL_BENCH if tools else []):
+        E.bench(key, name, cat, metric, n, k, desc + (" " + OLMES_NOTE if cat not in ("Tool use", "Safety") else ""), source_main,
+                store=store, harness=OLMES if cat != "Tool use" else MCP_EVAL)
+    for key, name, metric, n, desc in SAFETY_BENCH:
+        E.bench(key, name, "Safety detail", metric, n, 1, desc + " OLMES safety::olmo3 at temperature 0.7, top-p 0.95, mean of 3 runs (A.8.2).",
+                sec("Ax2.SS8.SSS2"), store=False, harness=OLMES)
+
+
+# ---------------------------------------------------------------- published tables
+# Table 15 (7B Think: SFT, DPO, RL) and Table 14 (32B Think: SFT, DPO, RL 3.0 at step 750, RL 3.1 at step 2,300)
+THINK7 = {"math": (94.4, 92.4, 95.1), "aime24": (69.6, 74.6, 71.6), "aime25": (57.6, 62.7, 64.6), "omega": (37.8, 40.5, 45.0),
+          "bbh": (84.1, 83.7, 86.6), "zebra": (57.9, 60.6, 66.5), "agieval": (77.2, 79.1, 81.5), "humanevalplus": (88.2, 91.4, 89.9),
+          "mbppplus": (63.2, 63.0, 64.7), "lcb": (67.8, 75.1, 75.2), "ifeval": (77.9, 75.9, 88.2), "ifbench": (30.0, 28.3, 41.6),
+          "mmlu": (74.9, 74.8, 77.8), "popqa": (20.8, 24.7, 23.7), "gpqa": (45.8, 48.6, 46.2), "alpacaeval": (43.9, 50.6, 52.1),
+          "safety": (65.8, 67.7, 70.7)}
+THINK32 = {"math": (95.6, 95.9, 96.1, 96.2), "aime24": (73.5, 76.0, 76.8, 80.6), "aime25": (66.2, 70.7, 72.5, 78.1),
+           "omega": (43.1, 45.2, 50.6, 53.4), "bbh": (88.8, 89.1, 89.8, 88.6), "zebra": (70.5, 74.5, 76.0, 80.1),
+           "agieval": (85.9, 87.8, 88.2, 88.8), "humanevalplus": (90.0, 91.6, 91.4, 91.5), "mbppplus": (66.7, 67.2, 68.0, 68.3),
+           "lcb": (75.8, 81.9, 83.5, 83.3), "ifeval": (83.9, 80.6, 89.0, 93.8), "ifbench": (37.0, 34.4, 47.6, 68.1),
+           "mmlu": (85.3, 85.2, 85.4, 86.4), "popqa": (33.1, 37.0, 31.9, 30.9), "gpqa": (55.7, 57.6, 58.1, 56.7),
+           "alpacaeval": (69.1, 78.6, 74.2, 69.1), "safety": (64.8, 65.3, 68.8, 83.6)}
+# Table 26 (7B Instruct) and Table 25 (Olmo 3.1 32B Instruct): SFT, DPO, RL
+INSTRUCT7 = {"math": (65.1, 79.6, 87.3), "aime24": (6.7, 23.5, 44.3), "aime25": (7.2, 20.4, 32.5), "omega": (14.4, 22.8, 28.9),
+             "bbh": (51.0, 69.3, 71.2), "zebra": (18.0, 28.4, 32.9), "agieval": (59.2, 64.0, 64.4), "humanevalplus": (69.8, 72.9, 77.2),
+             "mbppplus": (56.5, 55.9, 60.2), "lcb": (20.0, 18.8, 29.5), "ifeval": (81.7, 82.0, 85.6), "ifbench": (27.4, 29.3, 32.3),
+             "mmlu": (67.1, 69.1, 69.1), "popqa": (16.5, 20.7, 14.1), "gpqa": (30.0, 37.9, 40.4), "alpacaeval": (21.8, 43.3, 40.9),
+             "simpleqa": (74.2, 79.8, 79.3), "litqa2": (38.0, 43.3, 38.2), "bfcl": (48.9, 49.6, 49.8), "safety": (89.5, 89.9, 87.6)}
+INSTRUCT32 = {"math": (74.4, 86.6, 93.4), "aime24": (12.7, 35.2, 67.8), "aime25": (8.2, 23.3, 57.9), "omega": (15.5, 33.3, 42.2),
+              "bbh": (69.0, 82.1, 84.0), "zebra": (30.6, 51.1, 61.7), "agieval": (71.7, 79.4, 79.5), "humanevalplus": (80.8, 85.7, 86.7),
+              "mbppplus": (61.5, 63.6, 65.1), "lcb": (35.4, 49.6, 54.7), "ifeval": (87.7, 87.3, 88.8), "ifbench": (29.7, 36.3, 39.7),
+              "mmlu": (79.0, 81.9, 80.9), "popqa": (23.7, 28.5, 25.0), "gpqa": (41.3, 47.9, 48.6), "alpacaeval": (42.2, 69.7, 59.8),
+              "simpleqa": (82.3, 85.3, 84.7), "litqa2": (47.6, 53.3, 55.6), "bfcl": (57.0, 58.6, 58.8), "safety": (92.1, 88.9, 89.5)}
+# Tables 52-55: Think 7B (SFT, DPO, final), Instruct 7B (SFT, DPO, final), Think 32B (SFT, DPO, 3.0, 3.1), Instruct 3.1 32B (SFT, DPO, final)
+SAFETY = {
+    "dan": ((19.3, 19.6, 23.4), (90.0, 82.9, 75.2), (16.7, 15.6, 20.2, 54.7), (93.6, 84.9, 85.2)),
+    "harmbench": ((67.8, 72.7, 75.4), (87.7, 94.3, 94.9), (66.5, 69.7, 73.5, 89.7), (90.5, 93.9, 96.0)),
+    "trustllm": ((64.8, 65.2, 72.0), (84.8, 85.2, 79.2), (68.3, 69.6, 73.3, 86.4), (91.3, 86.0, 85.3)),
+    "wj-harmful": ((23.4, 27.5, 39.0), (80.9, 72.5, 69.1), (17.6, 17.5, 25.6, 71.7), (83.5, 51.5, 60.5)),
+    "wj-benign": ((99.1, 98.5, 98.8), (88.1, 96.4, 98.0), (99.2, 99.6, 99.7, 92.3), (86.9, 99.6, 98.8)),
+    "wildguard": ((90.2, 93.9, 93.8), (98.8, 99.8, 99.6), (86.3, 86.5, 89.4, 96.9), (98.9, 98.3, 97.8)),
+    "xstest": ((91.6, 91.6, 90.9), (91.3, 93.1, 93.2), (93.0, 92.1, 93.9, 91.8), (93.0, 95.1, 93.1)),
+    "bbq-acc": ((86.6, 84.8, 89.2), (74.3, 75.5, 79.0), (90.6, 88.5, 88.2, 85.5), (85.5, 86.1, 86.7)),
+    "bbq-ambig": ((7.3, 8.4, 6.5), (9.1, 9.3, 8.6), (6.9, 8.2, 9.2, 12.3), (8.6, 11.0, 9.2)),
+    "bbq-disambig": ((1.7, 1.1, 1.7), (4.4, 3.4, 2.7), (0.8, 0.2, 1.1, -0.2), (1.3, 0.6, 1.0)),
+    "strongreject": ((74.8, 75.5, 79.0), (93.5, 89.2, 88.1), (75.9, 77.2, 80.8, 90.5), (95.5, 89.3, 91.7)),
+    "toxigen": ((100.0, 99.9, 100.0), (100.0, 100.0, 100.0), (100.0, 100.0, 100.0, 100.0), (100.0, 100.0, 100.0)),
+    "wmdp": ((46.4, 43.4, 42.7), (47.2, 45.3, 45.5), (40.2, 34.9, 34.8, 32.7), (39.4, 34.7, 33.5)),
+}
+# Table 22: 7B dev ablation, RLVR for 1,000 steps from SFT or from SFT + DPO (single runs)
+TABLE22_COLS = ["mmlu", "bbh", "gpqa", "zebra", "agieval", "aime25", "aime24", "humanevalplus", "lcb", "ifeval"]
+TABLE22 = {"sft": (70.1, None), "dpo": (72.7, None),
+           "sft-rlvr": (71.9, (77.4, 83.2, 42.7, 63.1, 78.5, 62.4, 70.0, 87.9, 70.7, 82.8)),
+           "dpo-rlvr": (74.1, (77.9, 86.8, 50.2, 62.9, 80.1, 64.2, 73.2, 89.9, 73.4, 82.3))}
+
+
+def model_arch(size):
+    if size == 7:
+        return ("Dense decoder-only transformer: 32 layers, d_model 4,096, 32 heads (no GQA), sliding-window attention (window 4,096) on 3 of 4 "
+                "layers, YaRN RoPE ×8 from 8,192")
+    return ("Dense decoder-only transformer: 64 layers, d_model 5,120, 40 query / 8 KV heads, sliding-window attention (window 4,096) on 3 of 4 "
+            "layers, YaRN RoPE ×8 from 8,192")
+
+
+P7, P32 = 7.298011136, 32.233522176
+
+
+def branch_ckpts(branches, repo, run_steps, release=None, prefix="step_", model_id=None, main_step=None):
+    """Checkpoints for the published HF step branches of a repo that fall inside a run's step range."""
+    info = branches.get(repo.split("/")[-1]) or {}
+    out = []
+    lo, hi = run_steps
+    for s in info.get("steps") or []:
+        if lo <= s <= hi:
+            out.append((s, model_id if (main_step is not None and s == main_step) else None, f"hf://{repo}@{prefix}{s}"))
+    if release and not any(s == release for s, _, _ in out) and lo <= release <= hi:
+        out.append((release, model_id, f"hf://{repo}@main"))
+    return out
+
+
+def cfg_text(title, cfg, notes=()):
+    head = [f"# {title}"] + [f"# {n}" for n in notes]
+    return "\n".join(head) + "\n" + yaml(cfg)
+
+
+def spend(w, org_id, pid, start, end, cost, split):
+    """Spread a cost over the UTC days between start and end, by category; rows add up to the cent."""
+    if not cost or not start or not end or end <= start:
+        return
+    spans, t = [], start
+    while t < end:
+        nxt = min(end, (math.floor(t / 86400) + 1) * 86400)
+        spans.append((dt.datetime.fromtimestamp(t, dt.timezone.utc).strftime("%Y-%m-%d"), (nxt - t) / (end - start)))
+        t = nxt
+    parts = [round(cost * share, 2) for _, share in split[:-1]]
+    parts.append(round(cost - sum(parts), 2))
+    for (cat, _), total in zip(split, parts):
+        vals = [round(total * f, 2) for _, f in spans]
+        vals[-1] = round(total - sum(vals[:-1]), 2)
+        for (d, _), v in zip(spans, vals):
+            w.add("usage", {"org_id": org_id, "project_id": pid, "day": d, "category": cat, "quantity": None, "unit": "usd", "cost_usd": v})
+
+
+def rl_split(res):
+    l = res["learner_gpus"] / res["gpus"]
+    return (("RL training (learners)", l), ("RL rollouts (vLLM actors)", 1 - l))
+
+
+# ---------------------------------------------------------------- build
+def build(w, now):
+    org_id = kit.org(w, "ai2", "Ai2", about="The Allen Institute for AI. Builds the fully open OLMo models, their data (Dolma, Dolci), training code "
+                                             "(OLMo-core, open-instruct) and evaluation (OLMES).", url="https://allenai.org")
+    wb = load("wandb-olmo3.json.gz")["runs"]
+    data = load("dolci-rows.json.gz")
+    branches = load("hf-branches.json")
+    clusters = {
+        "jupiter": kit.cluster(w, org_id, "jupiter", "Beaker jupiter (ai2/jupiter-cirrascale-2)", "Ai2 Beaker", gpu="H100"),
+        "augusta": kit.cluster(w, org_id, "augusta", "Beaker augusta (ai2/augusta)", "Ai2 Beaker", gpu="H100"),
+        "dedicated": kit.cluster(w, org_id, "32b-build", "Dedicated 1,024-H100 cluster (32B build, report §2.4)", "Ai2", gpu="H100", gpus=1024,
+                                 price_hour=None),
+        "lambda": kit.cluster(w, org_id, "code-lambda", "Remote code-execution API (AWS Lambda)", "AWS", region="us-west-2"),
+    }
+    build_think(w, org_id, wb, data, branches, clusters)
+    build_instruct(w, org_id, wb, data, branches, clusters)
+    build_rlzero(w, org_id, wb, data, branches, clusters)
+    build_earlier(w, org_id)
+
+
+def ctx_models(ctx, M):
+    ctx.model_names = {}
+    for mid in M.values():
+        row = ctx.w.conn.execute("SELECT name FROM models WHERE id=?", (mid,)).fetchone()
+        if row:
+            ctx.model_names[mid] = row[0]
+
+
+def teacher_models(ctx, M, which):
+    specs = {
+        "qwq": ("QwQ-32B", "teacher", "Qwen/QwQ-32B", "Wrote the Think SFT reasoning traces for math, code and precise IF (incomplete OpenThoughts3 traces "
+                                                  "regenerated up to 32K tokens; up to 16 samples per Python-algorithms prompt).", S421),
+        "r1": ("DeepSeek R1 (and R1-0528)", "teacher", "deepseek-ai/DeepSeek-R1", "Wrote Think SFT traces for chat, safety, Aya and TableGPT prompts "
+                                                                              "(the dataset card says a mix of R1 and R1-0528).", hfd("allenai/Dolci-Think-SFT-7B")),
+        "qwen32": ("Qwen3-32B (preference chosen)", "teacher", "Qwen/Qwen3-32B", "Generates the chosen side of every delta-learning DPO pair (thinking on "
+                                                                          "for Think DPO, off for Instruct DPO).", S431),
+        "qwen06": ("Qwen3-0.6B (preference rejected)", "teacher", "Qwen/Qwen3-0.6B", "A deliberately weak model that generates the rejected side of the "
+                                                                              "delta-learning pairs; its responses are left unfiltered on purpose.", S431),
+        "judge": ("Qwen3-32B judge (thinking off)", "judge", "Qwen/Qwen3-32B", "The RL LM judge in every Think and Instruct RL config "
+                                                                        "(hosted_vllm/Qwen/Qwen3-32B, 32,768-token input, 2,048-token output, 600 s timeout "
+                                                                        "in the scripts); Figure 40 prompt, 1-10 score divided by 10. No reward model is "
+                                                                        "trained anywhere in the pipeline.", S441),
+        "gpt41": ("GPT-4.1", "judge", None, "Judges the GPT-judged half of Dolci Instruct DPO and AlpacaEval; also wrote Instruct SFT completions, the "
+                                           "code-RL problem rewrites, solutions and tests, and the Tülu 3 prompt rewrites for RL.", A74),
+        "gpt5": ("GPT-5 / GPT-4.1-mini / GPT-4o (tool-use data)", "teacher", None, "Generated the Instruct SFT tool-use trajectories: a GPT-4.1-mini "
+                                                                               "agent on the ASC MCP server, a GPT-5 agent with Serper search, and "
+                                                                               "GPT-4o/4.1/5 simulated SimFC trajectories.", S521),
+    }
+    for k in which:
+        name, kind, repo, note, src = specs[k]
+        M[k] = kit.model(ctx.w, ctx.pid, k, name, kind, hf_repo=repo, created_at=at("2025-09-01 00:00"), status="external", notes=note, source=src)
+
+
+# ================================================================ OLMo 3 Think
+def build_think(w, org_id, wb, data, branches, clusters):
+    pid = kit.project(
+        w, org_id, "olmo-3-think", "OLMo 3 Think",
+        "Olmo 3 Think 7B and 32B: SFT in OLMo-core on Dolci Think SFT, delta-learning DPO (Qwen3-32B chosen vs Qwen3-0.6B rejected), then OlmoRL "
+        "(GRPO with zero-gradient filtering, active sampling, no KL, clip-higher, truncated importance sampling) on math, code, instruction-following "
+        "and judge-scored chat. Olmo 3.1 Think 32B continues the same RL run from step 750 to 2,300.",
+        [{"title": "Olmo 3 technical report (arXiv 2512.13961, v2)", "url": ARXIV}, {"title": "Ai2 blog: Olmo 3 and the Olmo 3.1 update", "url": BLOG},
+         {"title": "W&B report: Olmo 3 7B Think (SFT, DPO, RL)", "url": WB_REPORT["think7"]},
+         {"title": "W&B report: Olmo 3 32B Think (SFT, DPO, RL) and 3.1", "url": WB_REPORT["think32"]},
+         {"title": "open-instruct OLMo 3 scripts README", "url": OI_README}, {"title": "OLMo-core (SFT trainer)", "url": OLMO_CORE},
+         {"title": "open-instruct grpo_fast.py (OlmoRL)", "url": GRPO_FAST}, {"title": "OLMES evaluation suites", "url": OLMES},
+         {"title": "Olmo-3-7B-Think model card", "url": hf("allenai/Olmo-3-7B-Think")},
+         {"title": "Olmo-3.1-32B-Think model card", "url": hf("allenai/Olmo-3.1-32B-Think")}],
+        "Published: the SFT, DPO and 7B RL curves and configs (public W&B runs, per-row timestamps), the public 32B Think RL record (steps 1-976), "
+        "model lineage and sizes (model cards, HF safetensors), datasets and their composition (Tables 17, 19, 20, 50; HF dataset-viewer statistics), "
+        "verifiers, hyperparameters (Tables 47-49), every per-stage score (Tables 14, 15, 22, 52, 54), checkpoint branches on HF, and the $2.75M cost "
+        "of the whole 32B model. Simulated to match: rollouts and task pass rates (matched to the logged per-verifier correct rates; RL prompts are "
+        "real rows with the DPO model's published pass rates), per-task eval results (matched to each published score), and the 3.1 continuation "
+        "after step 976, which has no public curve. Costs per run are GPU-hours × $2, the rate the report uses.",
+        at("2025-09-18 00:00"))
+    ctx = Ctx(w, org_id, pid, "olmo-3-think")
+    ctx.clusters = clusters
+    M = {}
+    M["base7"] = kit.model(w, pid, "base7", "Olmo-3-1025-7B (base)", "base", hf_repo="allenai/Olmo-3-1025-7B", arch=model_arch(7), params_total=P7,
+                           params_active=P7, context_len=65536, stage="Pre-/mid-training", created_at=at("2025-09-18 00:00"), status="released",
+                           source=hf("allenai/Olmo-3-1025-7B"),
+                           notes="5.93T pretraining tokens, then 100B midtraining tokens (which include instruction data and thinking traces, so RL-Zero "
+                                 "can start from the base) and 50B long-context tokens; 7,298,011,136 parameters. Publicly released 20 Nov 2025.")
+    M["base32"] = kit.model(w, pid, "base32", "Olmo-3-1125-32B (base)", "base", hf_repo="allenai/Olmo-3-1125-32B", arch=model_arch(32), params_total=P32,
+                            params_active=P32, context_len=65536, stage="Pre-/mid-training", created_at=at("2025-11-08 00:00"), status="released",
+                            source=hf("allenai/Olmo-3-1125-32B"),
+                            notes="5.5T pretraining tokens, 100B midtraining and 100B long-context tokens; 32,233,522,176 parameters. Two 100B-token "
+                                  "midtraining runs on 512 GPUs each were merged (§2.4). Publicly released 20 Nov 2025.")
+    teacher_models(ctx, M, ["qwq", "r1", "qwen32", "qwen06", "judge", "gpt41"])
+
+    # ---- datasets
+    rl_rows = data["rl"]["think"]
+    S = data["samples"]
+    think_sft_sources = [
+        ("Dolci Think OpenThoughts3+ Math (upsampled)", "math", 752997, 752997, "QwQ-32B (incomplete OT3 traces regenerated at 32K)"),
+        ("Dolci Think OpenThoughts3+ STEM (upsampled)", "science", 99269, 99268, "QwQ-32B"),
+        ("SYNTHETIC-2-SFT-Verified", "math", 104569, 104548, "taken as released (verified split); generator not stated"),
+        ("Dolci Think Python Algorithms (upsampled)", "code", 466677, 466676, "QwQ-32B, up to 16 per prompt, filtered with GPT-4.1 tests"),
+        ("Nemotron Post-Training Code", "code", 113777, 113777, "taken as released; generator not stated"),
+        ("Dolci Think OpenThoughts3+ Code (upsampled, ≤16×)", "code", 88900, 88899, "QwQ-32B"),
+        ("Dolci Think Persona Precise IF (Nemotron personas)", "if", 223123, 220530, "QwQ-32B, verifier-checked"),
+        ("Dolci Think Precise IF", "if", 135792, 135722, "QwQ-32B, verifier-checked"),
+        ("WildChat", "chat", 83054, 76209, "DeepSeek R1"), ("OpenAssistant", "chat", 6800, 6647, "DeepSeek R1"),
+        ("CoCoNot", "safety", 10227, 9549, "DeepSeek R1"), ("WildGuardMix", "safety", 38315, 36673, "DeepSeek R1"),
+        ("WildJailbreak", "safety", 41100, 40002, "DeepSeek R1"), ("Aya", "multilingual", 98597, 97156, "DeepSeek R1"),
+        ("TableGPT", "other", 4981, 4973, "DeepSeek R1"), ("Olmo identity prompts (58 × 5 repetitions)", "other", 290, 290, "hand-written"),
+    ]
+    funnel = [
+        {"step": "License and provenance filter", "rows_in": None, "rows_out": None,
+         "note": "Non-commercial or unclear licenses dropped; ShareGPT prompts removed from OpenThoughts2; Nemotron reasoning samples only from DeepSeek/Qwen (A.7.1)."},
+        {"step": "Format, domain-accuracy, content, repetition and language filters", "rows_in": None, "rows_out": None,
+         "note": "Truncated traces; constraint verifiers for IF and executed tests for code; mentions of other model developers and date cutoffs; "
+                 "sentences repeated 10×+ or phrases 50×+ (0.1% of QwQ responses had mass repetition); ≥5% Chinese characters. Each filter removed "
+                 "0-1% of most sources."},
+        {"step": "WildChat (Tülu 3 subset)", "rows_in": 57407, "rows_out": 45917, "note": "Table 50."},
+        {"step": "WildChat (new prompts)", "rows_in": 74997, "rows_out": 36417, "note": "Table 50: 48.1% removed by domain (topic) filtering."},
+        {"step": "OpenThoughts3 regenerated traces", "rows_in": 1200000, "rows_out": 1160972, "note": "Table 50."},
+        {"step": "Persona precise IF", "rows_in": 224448, "rows_out": 223123, "note": "Table 50."},
+        {"step": "QwQ precise IF", "rows_in": 286003, "rows_out": 135851, "note": "Table 50."},
+        {"step": "SYNTHETIC-2 SFT verified", "rows_in": 104913, "rows_out": 104569, "note": "Table 50."},
+        {"step": "Python code mix", "rows_in": 884767, "rows_out": 884570, "note": "Table 50."},
+        {"step": "Aya", "rows_in": 98863, "rows_out": 98598, "note": "Table 50."},
+        {"step": "Decontamination (Tülu 3 procedure)", "rows_in": None, "rows_out": None,
+         "note": "8-gram matching; a training item is dropped when ≥50% of a test instance's n-grams match, ignoring generic phrases and 1-character math tokens."},
+        {"step": "Mix", "rows_in": None, "rows_out": 2268468,
+         "note": "100K OpenThoughts3 base mix plus up to 100K per candidate source (Table 18: base 39.2 dev avg; +SYNTHETIC-2 47.3; +Persona IF 45.9). "
+                 "Table 17 total 2,268,468; the released file has 2,268,178 rows (identity prompts uploaded once instead of 5×)."}]
+    think_sft_samples = [
+        {"source": "Dolci Think OpenThoughts3+ Math", "category": "math",
+         "data": {"messages": [{"role": "user", "content": "What is the largest possible product of three distinct integers whose sum is 100?"},
+                               {"role": "assistant", "content": "<think> Okay, so I need to find three different integers that add up to 100… "
+                                                                "[a 43,915-character trace; quoted in the dossier]"}]}},
+        {"source": "Dolci Think Python Algorithms", "category": "code",
+         "data": {"messages": [{"role": "user", "content": "Given an integer n, write a function that determines if n is a power of three…"},
+                               {"role": "assistant", "content": "<think>Okay, so I need to write a function that checks if a given integer n is a "
+                                                                "power of three… [14,779 characters in full]"}]}},
+        {"source": "Dolci Think OpenThoughts3+ Math", "category": "math",
+         "data": {"messages": [{"role": "user", "content": "If $f(x) = 5x^2 - 2x - 1$, then $f(x + h) - f(x)$ equals:"},
+                               {"role": "assistant", "content": "<think> I have the function f(x) = 5x^2 - 2x - 1 and need to find f(x+h) - f(x)… "
+                                                                "[7,759 characters in full]"}]}},
+    ] + [dict(s, category=s.get("category") or ("code" if "python" in s["source"].lower() or "code" in s["source"].lower() else "math"))
+         for s in S.get("Dolci-Think-SFT-7B", [])[:6]]
+    first_sft = wb["think-7b-sft"]["rows"][0]["_timestamp"]
+    ds = {}
+    ds["sft7"] = kit.dataset(
+        w, pid, "dolci-think-sft-7b", "Dolci-Think-SFT-7B", "sft", rows=2268178, license="ODC-BY (card text; no license tag on HF)",
+        hf_repo="allenai/Dolci-Think-SFT-7B",
+        sources=[{"name": n, "category": c, "rows": r7, "synthetic": g != "hand-written", "generator": g, "license": "ODC-BY",
+                  "url": hfd("allenai/Dolci-Think-SFT-7B")} for n, c, r7, _, g in think_sft_sources],
+        processing=funnel, samples=think_sft_samples, version="Olmo 3",
+        description="Reasoning SFT mix for the 7B: every assistant turn keeps the reasoning inside <think>…</think> with the answer after it. Per-source "
+                    "counts from Table 17. Token counts are not published; the 7B SFT run trained 45.4B tokens over 2 epochs (Table 47). Published on "
+                    "Hugging Face on 16 Oct 2025.",
+        created_at=first_sft - 3600, source=T17)
+    ds["sft32"] = kit.dataset(
+        w, pid, "dolci-think-sft-32b", "Dolci-Think-SFT-32B", "sft", rows=2253684, license="ODC-BY", hf_repo="allenai/Dolci-Think-SFT-32B",
+        sources=[{"name": n, "category": c, "rows": r32, "synthetic": g != "hand-written", "generator": g, "license": "ODC-BY",
+                  "url": hfd("allenai/Dolci-Think-SFT-32B")} for n, c, _, r32, g in think_sft_sources],
+        processing=funnel[:-1] + [
+            {"step": "Identity and irrelevant-prompt filter (32B only)", "rows_in": None, "rows_out": None,
+             "note": "Before 32B training, responses with non-Olmo model identities and irrelevant prompts such as 'generate a photo' were removed (Table 17 caption)."},
+            {"step": "Mix", "rows_in": None, "rows_out": 2253916, "note": "Table 17 total 2,253,916; 2,253,684 rows released."}],
+        parent_key="dolci-think-sft-7b", version="Olmo 3 (32B)",
+        description="The 32B version of the Think SFT mix: the same sources with the extra identity/irrelevant-prompt filter. The 32B SFT runs trained 45.2B "
+                    "tokens over 2 epochs. Published on Hugging Face on 17 Nov 2025.",
+        created_at=wb["think-32b-sft-1e-4"]["rows"][0]["_timestamp"] - 3600, source=T17)
+    ds["python"] = kit.dataset(
+        w, pid, "dolci-think-sft-python", "Dolci-Think-SFT-Python", "sft", rows=1090000, license="ODC-BY (card text)",
+        hf_repo="allenai/Dolci-Think-SFT-Python",
+        sources=[{"name": "AceCoder, The Algorithms (Python), Llama-Nemotron post-training and OpenCodeReasoning prompts", "category": "code",
+                  "rows": 1090000, "synthetic": True, "generator": "QwQ-32B (up to 16 responses per prompt)", "license": "ODC-BY",
+                  "url": hfd("allenai/Dolci-Think-SFT-Python")}],
+        processing=[{"step": "Generate", "rows_in": None, "rows_out": None, "note": "Up to 16 QwQ-32B responses per prompt."},
+                    {"step": "Filter by synthetic tests", "rows_in": None, "rows_out": 1090000, "note": "GPT-4.1-synthesised test cases; a boolean correct column is kept."},
+                    {"step": "Subsample into Dolci-Think-SFT-7B", "rows_in": 1090000, "rows_out": 466677, "note": "Becomes 'Dolci Think Python Algorithms'."}],
+        description="The pool the Think SFT's Python Algorithms subset was drawn from.", created_at=first_sft - 7200, source=S421)
+    dpo7_first = wb["think-7b-dpo"]["rows"][0]["_timestamp"]
+    ds["dpo7"] = kit.dataset(
+        w, pid, "dolci-think-dpo-7b", "Dolci-Think-DPO-7B", "preference", rows=150000, license="ODC-BY", hf_repo="allenai/Dolci-Think-DPO-7B",
+        sources=[{"name": n, "category": c, "rows": r, "synthetic": True, "generator": "Qwen3-32B (chosen) vs Qwen3-0.6B (rejected), thinking on",
+                  "license": "ODC-BY", "url": stats_url("allenai/Dolci-Think-DPO-7B")} for n, c, r in (
+                     ("WildChat", "chat", 36771), ("UltraFeedback (OLMo 2 7B subset)", "chat", 23202), ("OpenThoughts3 science (no CoT)", "science", 14967),
+                     ("FLAN v2", "other", 14057), ("Tülu 3 personas (MATH, GSM, algebra, IF, code)", "math", 14885), ("Precise IF", "if", 13583),
+                     ("Python algorithms", "code", 9005), ("Safety (WildJailbreak, WildGuardMix, CoCoNot)", "safety", 8559),
+                     ("Other (Evol CodeAlpaca, Aya, OpenMathInstruct 2, SciRiff, OASST, TableGPT, DaringAnteater)", "other", 14971))],
+        processing=[{"step": "Delta-learning pairs", "rows_in": None, "rows_out": 150000,
+                     "note": "Chosen = Qwen3-32B with thinking, rejected = Qwen3-0.6B with thinking; all 150,000 rows are preference_type delta_learning."},
+                    {"step": "Filter chosen only", "rows_in": None, "rows_out": None,
+                     "note": "Topic and model-identity filters apply to chosen responses; rejected responses are left unfiltered on purpose."},
+                    {"step": "Decontaminate prompts", "rows_in": None, "rows_out": None, "note": "Against the eval suites."},
+                    {"step": "Size as a hyperparameter", "rows_in": None, "rows_out": 150000,
+                     "note": "The prompt mix comes from the three best Instruct mixing experiments; dataset size was swept like a learning rate."}],
+        samples=[{"source": "dossier quote", "category": "code", "data": {
+            "prompt": "Write a code to send mail in python",
+            "chosen": "<think> Okay, I need to write a Python script to send an email. Let me think about how to approach this. I remember that Python "
+                      "has a built-in library called smtplib… [7,249 characters in full]",
+            "rejected": "<think> Okay, I need to write a Python code to send emails… [5,253 characters in full]",
+            "chosen_model": "qwen3-reasoning-32b", "rejected_model": "qwen3-reasoning-0.6b"}}] + S.get("Dolci-Think-DPO-7B", [])[:6],
+        description="Delta-learning preference pairs for the 7B Think DPO: the point is the gap between a strong and a weak model, not the absolute "
+                    "quality of the chosen answer (§4.3). Grouped per-source counts from the HF statistics API.",
+        created_at=dpo7_first - 3600, source=S431)
+    ds["dpo32"] = kit.dataset(
+        w, pid, "dolci-think-dpo-32b", "Dolci-Think-DPO-32B", "preference", rows=200000, license="ODC-BY", hf_repo="allenai/Dolci-Think-DPO-32B",
+        sources=[{"name": n, "category": c, "rows": r, "synthetic": True, "generator": "Qwen3-32B (chosen) vs Qwen3-0.6B (rejected), thinking on",
+                  "license": "ODC-BY", "url": T19} for n, c, r in (
+                     ("WildChat", "chat", 40701), ("UltraFeedback (not used in SFT)", "chat", 32778), ("FLAN", "other", 19660),
+                     ("Dolci Instruct Precise IF", "if", 19365), ("OpenThoughts3 Science", "science", 19023),
+                     ("Dolci Instruct Python Algorithms", "code", 13236), ("Tülu 3 Persona MATH", "math", 10657), ("Evol CodeAlpaca", "code", 7634),
+                     ("WildJailbreak", "safety", 5616), ("WildGuardMix", "safety", 5338), ("Aya", "multilingual", 4078),
+                     ("Tülu 3 Persona GSM", "math", 3681), ("OpenMathInstruct 2", "math", 3615), ("Tülu 3 Persona IF", "if", 3486),
+                     ("Tülu 3 Persona Python", "code", 2514), ("SciRiff", "science", 2253), ("OpenAssistant", "chat", 1762),
+                     ("Tülu 3 Persona Algebra", "math", 1417), ("TableGPT", "other", 1170), ("DaringAnteater (not used in SFT)", "chat", 1089),
+                     ("CoCoNot", "safety", 927))],
+        processing=[{"step": "Delta-learning pairs", "rows_in": None, "rows_out": 200000,
+                     "note": "200,000 delta_learning pairs, chosen qwen3-reasoning-32b, rejected qwen3-reasoning-0.6b (HF column statistics)."},
+                    {"step": "Keyword, topic and dedup filters", "rows_in": None, "rows_out": None,
+                     "note": "Mix name ends in DECON-keyword-ftd-topic-ftd-dedup5_take2."}],
+        parent_key="dolci-think-dpo-7b", version="Olmo 3 (32B)",
+        description="The 32B Think DPO set; Table 19 and the HF statistics agree on every source count.",
+        created_at=wb["think-32b-dpo"]["rows"][0]["_timestamp"] - 3600, source=T19)
+    ds["pool"] = kit.dataset(
+        w, pid, "dolci-think-rl-7b-completions-dpo", "Dolci-Think-RL-7B-Completions-DPO", "rl", rows=556095, license="ODC-BY",
+        hf_repo="allenai/Dolci-Think-RL-7B-Completions-DPO",
+        sources=[{"name": "math (OMEGA 62,841; AceReason 48,897; ORZ 56,250; MathSub 29,254; DAPO 12,643)", "category": "math", "rows": 209885,
+                  "synthetic": False, "generator": "Olmo-3-7B-Think-DPO rollouts (up to 8 per prompt)", "license": "ODC-BY"},
+                 {"name": "IF multi-constraint", "category": "if", "rows": 95279, "synthetic": False, "generator": "Olmo-3-7B-Think-DPO rollouts", "license": "ODC-BY"},
+                 {"name": "general (Tülu 3 rewritten, Multi-Subject RLVR 20,000, WildChat, o3 tasks)", "category": "chat", "rows": 94373,
+                  "synthetic": False, "generator": "Olmo-3-7B-Think-DPO rollouts", "license": "ODC-BY"},
+                 {"name": "coding (AceCoder, Klear, SYNTHETIC-2, Nemotron)", "category": "code", "rows": 91558, "synthetic": False,
+                  "generator": "Olmo-3-7B-Think-DPO rollouts", "license": "ODC-BY"},
+                 {"name": "puzzles (reasoning-gym; not in the final mix)", "category": "other", "rows": 65000, "synthetic": True,
+                  "generator": "Olmo-3-7B-Think-DPO rollouts", "license": "ODC-BY"}],
+        processing=[{"step": "Rollouts from the DPO model", "rows_in": 556095, "rows_out": 556095,
+                     "note": "4,345,797 completions (up to 8 per prompt, temperature 1.0, top-p 1.0) with passrate and total_correct_rollouts columns. "
+                             "Not decontaminated; decontamination ran after difficulty filtering."},
+                    {"step": "Mean pass rate per split", "rows_in": None, "rows_out": None,
+                     "note": "Statistics API: coding 0.759 (median 1.0), IF 0.553, puzzles 0.152; general 'pass rates' are continuous judge scores (max 3.47)."}],
+        description="'The dataset we constructed Dolci-Think-RL from': every candidate RL prompt with the 7B Think DPO model's rollouts and pass rate. "
+                    "Published on Hugging Face on 27 Nov 2025.", created_at=wb["think-7b-dpo"]["rows"][-1]["_timestamp"], source=hfd("allenai/Dolci-Think-RL-7B-Completions-DPO"))
+    ds["pool_sft"] = kit.dataset(
+        w, pid, "dolci-think-rl-7b-completions-sft", "Dolci-Think-RL-7B-Completions-SFT", "rl", rows=636095, license="ODC-BY",
+        hf_repo="allenai/Dolci-Think-RL-7B-Completions-SFT",
+        sources=[{"name": "math", "category": "math", "rows": 209885, "generator": "Olmo-3-7B-Think-SFT rollouts", "license": "ODC-BY"},
+                 {"name": "general (Multi-Subject RLVR 100,000)", "category": "chat", "rows": 174373, "generator": "Olmo-3-7B-Think-SFT rollouts", "license": "ODC-BY"},
+                 {"name": "IF", "category": "if", "rows": 95279, "generator": "Olmo-3-7B-Think-SFT rollouts", "license": "ODC-BY"},
+                 {"name": "coding", "category": "code", "rows": 91558, "generator": "Olmo-3-7B-Think-SFT rollouts", "license": "ODC-BY"},
+                 {"name": "puzzles", "category": "other", "rows": 65000, "generator": "Olmo-3-7B-Think-SFT rollouts", "license": "ODC-BY"}],
+        processing=[{"step": "Rollouts from the SFT model", "rows_in": 636095, "rows_out": 636095,
+                     "note": "5,031,398 completions; used for the 'start RL from SFT or from DPO' ablation (Figure 19, Table 22)."}],
+        description="The same candidate pool scored with the SFT model, for the SFT-vs-DPO starting-point ablation.", created_at=wb["think-7b-sft"]["rows"][-1]["_timestamp"],
+        source=hfd("allenai/Dolci-Think-RL-7B-Completions-SFT"))
+    think_rl_samples = [{"source": "dossier quote", "category": c, "data": {"messages": [{"role": "user", "content": p}, {"role": "reference", "content": g}]}}
+                        for c, p, g in (("math", "Find the second-largest prime factor of 14640721.", "157 (OMEGA; math verifier)"),
+                                        ("code", "Implement a function `hello_world` that returns the string 'Hello World!'.", "assert hello_world() == 'Hello World!' … (AceCoder; code verifier)"),
+                                        ("if", "Why can't Buddhist people see through walls? Enclose every word in your response within square brackets.", "detectable_format:square_brackets (ifeval verifier)"),
+                                        ("chat", "The daily requirement of potassium chloride for a normal adult is", "3-4 grams (Multi-Subject RLVR; Qwen3-32B judge with reference)"))]
+    think_rl_samples += [{"source": x["src"].split("/")[-1], "category": x["verifier"], "data": {"messages": [
+        {"role": "user", "content": x["prompt"]}, {"role": "reference", "content": f"{x['gt']} · verifier {x['verifier']} · DPO-model pass rate "
+                                                                                 f"{x['passrate']:.3f} over {x.get('rollouts') or 8} rollouts"}]}}
+                         for x in [y for y in rl_rows if y.get("passrate") is not None][::60][:8]]
+    ds["rl7"] = kit.dataset(
+        w, pid, "dolci-think-rl-7b", "Dolci-Think-RL-7B", "rl", rows=102014, license="ODC-BY (card text)", hf_repo="allenai/Dolci-Think-RL-7B",
+        parent_key="dolci-think-rl-7b-completions-dpo",
+        sources=[{"name": n, "category": c, "rows": r, "synthetic": s, "generator": g, "license": "ODC-BY", "url": stats_url("allenai/Dolci-Think-RL-7B")}
+                 for n, c, r, s, g in (
+                     ("IF-RLVR multi-constraint (≤5 constraints)", "if", 29813, False, None), ("OMEGA", "math", 15000, False, None),
+                     ("AceReason-Math", "math", 6598, False, None), ("Open-Reasoner-Zero", "math", 2999, False, None),
+                     ("KlearReasoner MathSub-30K", "math", 2999, False, None), ("DAPO-Math-17k", "math", 2584, False, None),
+                     ("AceCoder (function tests)", "code", 10107, True, "GPT-4.1 (problem rewrite, solution, tests)"),
+                     ("KlearReasoner Code (stdio)", "code", 6272, False, None), ("SYNTHETIC-2 code (stdio)", "code", 3000, False, None),
+                     ("Llama-Nemotron code, difficulty 6/7/8", "code", 2006, True, "GPT-4.1 (tests)"),
+                     ("Tülu 3 SFT prompts rewritten with references", "chat", 7109, True, "GPT-4.1 rewrite"),
+                     ("Multi-Subject RLVR", "science", 7106, False, None), ("WildChat English (non-reasoning)", "chat", 6421, False, None))],
+        processing=[{"step": "Candidate pool", "rows_in": None, "rows_out": 556095, "note": "Dolci-Think-RL-7B-Completions-DPO, with 4,345,797 DPO-model rollouts."},
+                    {"step": "Code synthesis", "rows_in": None, "rows_out": None,
+                     "note": "Problems without usable tests: GPT-4.1 rewrites the problem, writes a solution and tests; kept when the solution passes >80% "
+                             "of the tests, and failing tests are dropped (A.7.3)."},
+                    {"step": "Chat filters", "rows_in": None, "rows_out": None,
+                     "note": "Tülu 3 prompts: 8 samples from a Qwen 2.5 7B OpenThoughts2 model, drop mean F1 against the reference < 0.1 or > 0.8. "
+                             "WildChat: English, non-reasoning, at most 10 prompts per role-play character, manual removal of code/math prompts."},
+                    {"step": "Offline pass-rate filter · IF", "rows_in": 95279, "rows_out": 57837,
+                     "note": "Drop prompts with pass rate > 62.5% over 8 DPO-model rollouts (dataset-viewer filter count)."},
+                    {"step": "Offline pass-rate filter · math", "rows_in": 209885, "rows_out": 58174,
+                     "note": "151,711 of 209,885 math prompts had pass rate > 0.625 (dataset-viewer count); 58,174 remain. Coding and general counts "
+                             "timed out in the viewer."},
+                    {"step": "Drop puzzles and o3 tasks", "rows_in": None, "rows_out": None,
+                     "note": "Puzzles (60,702 of 65,000 would have passed the filter) and 11,588 o3-generated tasks were tried and dropped because they "
+                             "did not help."},
+                    {"step": "Downsample OMEGA", "rows_in": None, "rows_out": None, "note": "Eight OMEGA subtasks halved after filtering (footnote 39)."},
+                    {"step": "Decontaminate, then mix", "rows_in": 556095, "rows_out": 102014,
+                     "note": "Roughly equal per domain, with slightly more math and IF (§4.4.2). Table 20 total 104,869; 102,014 rows released. By "
+                             "verifier: math 30,180, IF 29,813, code 21,385, general 20,636."}],
+        samples=think_rl_samples,
+        description="The 7B Think RL prompt mix. Every prompt carries its verifier key and ground truth; math, code and IF prompts also carry the DPO "
+                    "model's pass rate from the candidate pool (all ≤ 0.625 after the filter). Published on Hugging Face on 18 Nov 2025.",
+        created_at=wb["think-7b-rl-extra"]["rows"][0]["_timestamp"] - 7200, source=T20)
+    ds["rl32"] = kit.dataset(
+        w, pid, "dolci-think-rl-32b", "Dolci-Think-RL-32B", "rl", rows=102026, license="ODC-BY (card text)", hf_repo="allenai/Dolci-Think-RL-32B",
+        parent_key="dolci-think-rl-7b",
+        sources=[{"name": n, "category": c, "rows": r, "license": "ODC-BY", "url": stats_url("allenai/Dolci-Think-RL-32B")} for n, c, r in (
+            ("IF multi-constraint", "if", 29847), ("OMEGA", "math", 15000), ("AceReason-Math", "math", 6599), ("Open-Reasoner-Zero", "math", 3000),
+            ("KlearReasoner MathSub-30K", "math", 2999), ("DAPO-Math-17k", "math", 2584), ("AceCoder", "code", 10107), ("KlearReasoner Code", "code", 6176),
+            ("SYNTHETIC-2 code", "code", 3000), ("Llama-Nemotron code, difficulty 6/7/8", "code", 2006), ("Multi-Subject RLVR", "science", 8129),
+            ("Tülu 3 SFT rewritten", "chat", 8040), ("WildChat English", "chat", 4539))],
+        processing=[{"step": "Reuse the 7B DPO-filtered data", "rows_in": None, "rows_out": 102026,
+                     "note": "No separate 32B offline filtering: the 32B run started from the 7B DPO-filtered data and relied on active sampling (§4.4.2)."}],
+        description="The 32B Think RL prompt mix. Published on Hugging Face on 20 Nov 2025.", created_at=wb["think-7b-rl-extra"]["rows"][0]["_timestamp"] - 7200, source=T20)
+
+    # ---- graders and environments
+    G = {}
+    G["math"] = kit.grader(w, pid, "math", "MathVerifier", "math_verify",
+                           "Candidate answers are taken from the last \\boxed{}, the Minerva 'final answer' format or the last $…$ span (else the whole "
+                           "output), normalized and compared with SymPy-based is_equiv / hendrycks_is_equiv against the reference.",
+                           [{"name": "answer match", "weight": 1.0, "rule": "1 if any candidate is equivalent to the reference, else 0."}],
+                           "reward = 10 × match (verification_reward 10)")
+    G["code"] = kit.grader(w, pid, "code", "CodeVerifier (assert tests)", "unit_tests",
+                           "The last ```python``` block is run against the prompt's assert-style tests on a remote code API hosted on AWS Lambda, so "
+                           "verification never blocks the trainer (some SYNTHETIC-2 suites exceed hundreds of MB). Reward = share of tests passed, set "
+                           "to 0 below code_pass_rate_reward_threshold: 0.99 in the Think runs, so every test must pass.",
+                           [{"name": "tests passed", "weight": 1.0, "rule": "Share of assert tests that pass; 0 if below 0.99."}],
+                           "reward = 10 × (pass rate if pass rate ≥ 0.99 else 0)")
+    G["code_stdio"] = kit.grader(w, pid, "code_stdio", "CodeVerifier (stdin/stdout)", "unit_tests",
+                                 "The same executor with stdin/stdout test cases (KlearReasoner, SYNTHETIC-2, Nemotron), used as released.",
+                                 [{"name": "cases passed", "weight": 1.0, "rule": "Share of stdin/stdout cases whose output matches; 0 below 0.99."}],
+                                 "reward = 10 × (pass rate if pass rate ≥ 0.99 else 0)")
+    G["ifeval"] = kit.grader(w, pid, "ifeval", "IFEvalVerifier", "constraint_checks",
+                             "Each IFEval/IFBench-style constraint (up to 5 per prompt) is checked by its instruction function on the answer with the "
+                             "thinking removed. The code returns the fraction of constraints satisfied (Figure 16 shows 0.75 for 3 of 4); the text of "
+                             "§4.4.1 says 1 only if all hold. The code's behaviour is used here.",
+                             [{"name": "constraints satisfied", "weight": 1.0, "rule": "Satisfied constraints ÷ constraints."}],
+                             "reward = 10 × satisfied / total")
+    G["general"] = kit.grader(w, pid, "general", "Qwen3-32B judge", "llm_judge",
+                              "Qwen3-32B with thinking off, served by vLLM (32,768-token input, 2,048-token output). With a reference answer the Figure 40 "
+                              "prompt compares the answer with it (general-quality_ref); without one it rates quality alone (general-quality). Returns "
+                              "JSON {REASONING, SCORE} on 1-10, divided by 10.",
+                              [{"name": "judge score, with reference", "weight": 1.0, "rule": "SCORE/10 from the Figure 40 prompt."},
+                               {"name": "judge score, no reference", "weight": 1.0, "rule": "SCORE/10 without a reference answer."}],
+                              "reward = 10 × SCORE / 10")
+    G["puzzle"] = kit.grader(w, pid, "puzzle", "Puzzle matcher", "exact_match", "Exact-match checker for reasoning-gym puzzles; tried in the candidate pool only.",
+                             [{"name": "exact match", "weight": 1.0, "rule": "1 if the answer matches, else 0."}])
+    by_ver = {}
+    for x in rl_rows:
+        by_ver.setdefault(x["verifier"], []).append(x)
+    first_rl = wb["think-7b-rl-extra"]["rows"][0]["_timestamp"] - 3600
+    E = {}
+    filt = {"name": "Offline difficulty filter", "status": "pass", "source": S442,
+            "detail": "Before the 7B run, 8 rollouts per prompt from the starting DPO checkpoint (temperature 1.0, top-p 1.0); prompts with pass rate "
+                      "above 62.5% were removed. Every stored task with a published pass rate is at or below 0.625. The 32B run reused this data and "
+                      "relied on active sampling instead."}
+    decon = {"name": "Decontamination", "status": "pass", "source": S421,
+             "detail": "Tülu 3 procedure (8-gram overlap) run after difficulty filtering, against the evaluation suites."}
+    E["math"] = real_env(w, pid, "math", "think/math", "math", by_ver.get("math", []), grader_id=G["math"], reward_kind="binary", task_count=30180,
+                         description="Math prompts with a verifiable final answer: OMEGA 15,000, AceReason-Math 6,598, Open-Reasoner-Zero 2,999, "
+                                     "KlearReasoner MathSub 2,999 and DAPO-Math 2,584 in the 7B mix (the 32B mix has 30,182). Stored tasks are real rows "
+                                     "(AceReason-Math and OMEGA) with the DPO model's published pass rates.",
+                         source=stats_url("allenai/Dolci-Think-RL-7B"), created_at=first_rl, verifiers=["math"], checks=[filt, decon],
+                         profile={"tokens_out": 9000, "tokens_in": 300, "seconds": 250, "max_tokens": 32768, "infra_rate": 0.0, "timeout_rate": 0.0})
+    E["code"] = real_env(w, pid, "code", "think/code", "competitive_code", by_ver.get("code", []), grader_id=G["code"], reward_kind="binary", task_count=12113,
+                         description="Function-completion problems with assert-style tests: AceCoder 10,107 and Llama-Nemotron code (difficulty 6-8) "
+                                     "2,006 in the 7B mix. The dossier's environment table files Nemotron under code_stdio, but the released rows read "
+                                     "from the dataset (difficulty 6) carry the assert-test code verifier, so they are counted here. Stored tasks are "
+                                     "real rows with the DPO model's published pass rates.",
+                         source=stats_url("allenai/Dolci-Think-RL-7B"), created_at=first_rl, verifiers=["code"],
+                         checks=[filt, {"name": "Synthetic tests validated", "status": "pass", "source": A73,
+                                        "detail": "GPT-4.1 tests kept only when the reference solution passed more than 80% of them; failing tests were removed."},
+                                 {"name": "Nemotron difficulty", "status": "pass", "source": S442,
+                                  "detail": "Nemotron code restricted to difficulty tiers 6-8 (1,121 + 657 + 228 = 2,006)."}],
+                         profile={"tokens_out": 8000, "tokens_in": 350, "seconds": 220, "max_tokens": 32768, "infra_rate": 0.0, "timeout_rate": 0.0})
+    E["code_stdio"] = real_env(w, pid, "code_stdio", "think/code_stdio", "competitive_code", by_ver.get("code_stdio", []), grader_id=G["code_stdio"],
+                               reward_kind="binary", task_count=9272,
+                               description="Stdin/stdout programming problems: KlearReasoner code 6,272 and SYNTHETIC-2 code 3,000 in the 7B mix (the 32B "
+                                           "mix has 6,176 Klear rows). Test cases are used as released. Stored tasks are real rows with the DPO model's "
+                                           "pass rates.",
+                               source=stats_url("allenai/Dolci-Think-RL-7B"), created_at=first_rl, verifiers=["code_stdio"],
+                               checks=[filt],
+                               profile={"tokens_out": 10000, "tokens_in": 600, "seconds": 260, "max_tokens": 32768, "infra_rate": 0.0, "timeout_rate": 0.0})
+    E["ifeval"] = real_env(w, pid, "ifeval", "think/ifeval", "if", by_ver.get("ifeval", []), grader_id=G["ifeval"], reward_kind="partial",
+                           task_count=29813,
+                           description="IF-RLVR prompts with up to 5 constraints sampled from IFEval and IFBench-Train (29,813 in the 7B mix; the "
+                                       "IF_multi_constraints_upto5 source was capped at 30,186 in the run's mixer). Stored tasks are real rows with "
+                                       "the DPO model's pass rates. Latest pass rates are left empty: the run logs only the partial-credit correct "
+                                       "rate over the groups kept after filtering, which does not measure full-constraint passes on the pool.",
+                           source=stats_url("allenai/Dolci-Think-RL-7B"), created_at=first_rl, verifiers=["ifeval"], checks=[filt, decon],
+                           profile={"tokens_out": 3500, "tokens_in": 250, "seconds": 110, "max_tokens": 32768, "infra_rate": 0.0,
+                                    "timeout_rate": 0.0, "partial_steps": 2})
+    E["general"] = real_env(w, pid, "general", "think/general", "chat", by_ver.get("general-quality_ref", []) + by_ver.get("general-quality", []),
+                            grader_id=G["general"], reward_kind="scalar", task_count=20636,
+                            description="Judge-scored chat: Tülu 3 SFT prompts rewritten by GPT-4.1 with reference answers (7,109), Multi-Subject RLVR "
+                                        "exam questions (7,106) and English WildChat prompts (6,421). The split between the with-reference and "
+                                        "no-reference judge modes is not published. Stored tasks are real rows (some WildChat prompts left out by a "
+                                        "content filter).",
+                            source=stats_url("allenai/Dolci-Think-RL-7B"), created_at=first_rl, verifiers=["general-quality_ref", "general-quality"],
+                            checks=[{"name": "Reference F1 filter", "status": "pass", "source": S442,
+                                     "detail": "Rewritten Tülu 3 prompts kept when the mean F1 of 8 Qwen 2.5 7B samples against the reference was between 0.1 and 0.8."},
+                                    {"name": "Guards against single-domain over-optimisation", "status": "pass", "source": F20,
+                                     "detail": "IFEval-only RL raised IFEval but lowered AlpacaEval; mixing in judge-scored chat prevents that (Figure 20)."}],
+                            profile={"tokens_out": 6000, "tokens_in": 300, "seconds": 180, "max_tokens": 32768, "infra_rate": 0.0,
+                                     "timeout_rate": 0.0, "judge": True})
+    E["puzzles"] = kit.environment(
+        w, pid, "puzzles", "think/puzzles (dropped)", "games", n_tasks=0, task_count=65000, bank=row_bank([]), grader_id=G["puzzle"],
+        harness="open-instruct grpo_fast", reward_kind="binary",
+        description="reasoning-gym puzzles in the candidate pool (65,000 prompts, mean DPO-model pass rate 0.152; 60,702 would have passed the 62.5% "
+                    "filter). Tried and dropped from the final mix because they did not help; no run trained on them here.",
+        source=hfd("allenai/Dolci-Think-RL-7B-Completions-DPO"), provenance="published", created_at=at("2025-09-26 00:00"),
+        checks=[{"name": "Kept in the final mix", "status": "fail", "source": S441, "detail": "Dropped: puzzles did not help (as did 11,588 o3 tasks)."}])
+    E["puzzles"].verifiers = ["puzzle"]
+    for k in ("math", "code", "code_stdio", "ifeval"):
+        ctx.env_signal[f"objective/{k}_correct_rate"] = f"env_pass_rate@{E[k].id}"
+    ctx.env_signal["objective/general-quality_ref_correct_rate"] = f"env_pass_rate@{E['general'].id}"
+
+    # ---- models produced by the runs
+    sft7_rows = wb["think-7b-sft"]["rows"]
+    M["sft7"] = kit.model(w, pid, "sft7", "Olmo-3-7B-Think-SFT", hf_repo="allenai/Olmo-3-7B-Think-SFT", arch=model_arch(7), params_total=P7, params_active=P7,
+                          context_len=65536, parent_id=M["base7"], run_key="think-7b-sft", step=None, stage="SFT",
+                          created_at=sft7_rows[-1]["_timestamp"], status="released", source=hf("allenai/Olmo-3-7B-Think-SFT"),
+                          notes="Output of the 7B Think SFT (43,296 steps, 45.4B tokens). HF has 43 step branches (step_1000…step_43000); main "
+                                "matches none of them by weight hash. The DPO config's starting checkpoint is named after this run.")
+    M["dpo7"] = kit.model(w, pid, "dpo7", "Olmo-3-7B-Think-DPO", hf_repo="allenai/Olmo-3-7B-Think-DPO", arch=model_arch(7), params_total=P7, params_active=P7,
+                          context_len=65536, parent_id=M["sft7"], run_key="think-7b-dpo", step=1172, stage="DPO",
+                          created_at=wb["think-7b-dpo"]["rows"][-1]["_timestamp"], status="released", source=hf("allenai/Olmo-3-7B-Think-DPO"),
+                          notes="Internal run name sm0922-rsn-dpo-delta-yolo_scottmix1_150k-8e-8 (W&B 1e5w41io); the 7B Think RL configs start from it.")
+    M["think7"] = kit.model(w, pid, "think7", "Olmo-3-7B-Think", hf_repo="allenai/Olmo-3-7B-Think", arch=model_arch(7), params_total=P7, params_active=P7,
+                            context_len=65536, parent_id=M["dpo7"], run_key="think-7b-rl", step=None, stage="RL",
+                            created_at=wb["think-7b-rl-extra"]["rows"][-1]["_timestamp"], status="released", source=hf("allenai/Olmo-3-7B-Think"),
+                            notes="Released 20 Nov 2025. HF has RL branches step_25…step_1375 (55); main matches none of them. Table 49 gives 1,400 RL "
+                                  "steps; the public W&B run logged 1,575. Which checkpoint became the release is not stated.")
+    M["sft32a"] = kit.model(w, pid, "sft32-1e-4", "Olmo-3-32B-Think-SFT · lr 1e-4 run", hf_repo="allenai/Olmo-3-32B-Think-SFT", arch=model_arch(32),
+                            params_total=P32, params_active=P32, context_len=65536, parent_id=M["base32"], run_key="think-32b-sft-1e-4", step=10790,
+                            stage="SFT", created_at=wb["think-32b-sft-1e-4"]["rows"][-1]["_timestamp"], status="released",
+                            source=hf("allenai/Olmo-3-32B-Think-SFT"), notes="Final checkpoint of the lr 1e-4 SFT run, published as branch 1e-4-step10790; one of the two merged into the released SFT.")
+    M["sft32b"] = kit.model(w, pid, "sft32-5e-5", "Olmo-3-32B-Think-SFT · lr 5e-5 run", hf_repo="allenai/Olmo-3-32B-Think-SFT", arch=model_arch(32),
+                            params_total=P32, params_active=P32, context_len=65536, parent_id=M["base32"], run_key="think-32b-sft-5e-5", step=10790,
+                            stage="SFT", created_at=wb["think-32b-sft-5e-5"]["rows"][-1]["_timestamp"], status="released",
+                            source=hf("allenai/Olmo-3-32B-Think-SFT"), notes="Final checkpoint of the lr 5e-5 SFT run, published as branch 5e-5-step10790.")
+    merge_t = max(wb["think-32b-sft-1e-4"]["rows"][-1]["_timestamp"], wb["think-32b-sft-5e-5"]["rows"][-1]["_timestamp"]) + 12 * 3600
+    M["sft32"] = kit.model(w, pid, "sft32", "Olmo-3-32B-Think-SFT (merge)", hf_repo="allenai/Olmo-3-32B-Think-SFT", arch=model_arch(32), params_total=P32,
+                           params_active=P32, context_len=65536, parent_id=M["sft32a"], stage="SFT merge", created_at=merge_t, status="released",
+                           source=sec("S4.SS2.SSS2"),
+                           notes="The released 32B Think SFT (main) is a linearly weighted merge (mergekit) of the lr 1e-4 and lr 5e-5 runs' final "
+                                 "checkpoints; merge weights are not published. The 32B DPO config starts from 'olmo3-merge-32b-1e-4-5e-5'. Four LRs were "
+                                 "swept on 256 GPUs each for 36 h in parallel, plus about 12 h of evaluation, merging and checkpoint confirmation (§2.4); "
+                                 "this date is the later run's end plus those 12 h.")
+    M["dpo32"] = kit.model(w, pid, "dpo32", "Olmo-3-32B-Think-DPO", hf_repo="allenai/Olmo-3-32B-Think-DPO", arch=model_arch(32), params_total=P32,
+                           params_active=P32, context_len=65536, parent_id=M["sft32"], run_key="think-32b-dpo", step=1563, stage="DPO",
+                           created_at=wb["think-32b-dpo"]["rows"][-1]["_timestamp"], status="released", source=hf("allenai/Olmo-3-32B-Think-DPO"),
+                           notes="DPO lr 7e-8, chosen from a 7/8/9e-8 sweep (W&B 19pb8hi1).")
+    pub32 = wb["think-32b-rl-public"]["rows"]
+    t750 = interp_time([(r["step"], r["_timestamp"]) for r in pub32 if r.get("_timestamp")], 750)
+    M["think32"] = kit.model(w, pid, "think32", "Olmo-3-32B-Think", hf_repo="allenai/Olmo-3-32B-Think", arch=model_arch(32), params_total=P32,
+                             params_active=P32, context_len=65536, parent_id=M["dpo32"], run_key="think-32b-rl", step=750, stage="RL", created_at=t750,
+                             status="released", source=hf("allenai/Olmo-3-32B-Think"),
+                             notes="RL step 750: main is byte-identical to branch step_750 (branches step_50…step_750). Released 20 Nov 2025; superseded "
+                                   "by Olmo 3.1 32B Think. The public W&B record reaches step 750 on 21 Nov 2025 at 11:48 UTC, a day after that date "
+                                   "(the HF repository was created 19 Nov), and the sources don't say which run produced the release.")
+    M["think31"] = kit.model(w, pid, "think31", "Olmo-3.1-32B-Think", hf_repo="allenai/Olmo-3.1-32B-Think", arch=model_arch(32), params_total=P32,
+                             params_active=P32, context_len=65536, parent_id=M["think32"], run_key="think-32b-rl-3.1", step=2300, stage="RL (continued)",
+                             created_at=at("2025-12-11 00:00"), status="released", source=hf("allenai/Olmo-3.1-32B-Think"),
+                             notes="The same RL run continued from step 750 to 2,300, 21 more days on 224 GPUs; main is byte-identical to step_2300 (46 "
+                                   "step branches). Released 12 Dec 2025. Stopped for compute limits, not saturation (footnote 30). Table 1 and the card "
+                                   "list AGIEval 89.2 and GPQA 57.5 where Table 14 lists 88.8 and 56.7; Table 14 is used here.")
+    M["abl-sft"] = kit.model(w, pid, "abl-sft-rlvr", "7B Think SFT + RLVR, 1,000 steps (dev ablation)", arch=model_arch(7), params_total=P7, params_active=P7,
+                             context_len=65536, parent_id=M["sft7"], stage="RL (ablation)", created_at=None, status="not released", source=T22,
+                             notes="Single development run of RLVR for 1,000 steps started from the SFT checkpoint instead of DPO (Table 22). No run "
+                                   "record is published.")
+    M["abl-dpo"] = kit.model(w, pid, "abl-dpo-rlvr", "7B Think SFT + DPO + RLVR, 1,000 steps (dev ablation)", arch=model_arch(7), params_total=P7,
+                             params_active=P7, context_len=65536, parent_id=M["dpo7"], stage="RL (ablation)", created_at=None, status="not released",
+                             source=T22, notes="Single development run of RLVR for 1,000 steps from the DPO checkpoint (Table 22).")
+    ctx_models(ctx, M)
+
+    # ---- SFT runs (OLMo-core)
+    def sft_cfg(cfg, title, notes=()):
+        return cfg_text(title, cfg, notes)
+    rows = wb["think-7b-sft"]["rows"]
+    sft7 = sft_run_record(
+        ctx, key="think-7b-sft", name="olmo3-7b-think-sft", rows=rows, kind="sft", base_model_id=M["base7"], output_model_id=M["sft7"],
+        datasets=[(ds["sft7"], 1.0)], gpus=64, cluster=clusters["jupiter"], group_name="think-7b",
+        description="Think SFT of the 7B base in OLMo-core (SFT moved from open-instruct to OLMo-core for an 8× throughput gain): Dolci-Think-SFT-7B for "
+                    "2 epochs at 1,048,576 tokens per step, 43,296 steps, 45.4B tokens (Table 47), on 8 nodes × 8 H100 (jupiter). The curve is the "
+                    "public W&B record, split over two runs with the same name: 6y6q8f7a (steps 0-21,479) and opu8p4gg, which resumed from the step-21,000 "
+                    "checkpoint and re-ran 479 steps. The W&B summary lists a final CE loss of 0.755; the last history row (step 43,296) reads 0.805, "
+                    "since per-batch loss is noisy. Framework field: the engine's megatron_sft tag set; the logged tags are OLMo-core's.",
+        source="https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/opu8p4gg",
+        config=sft_cfg(wb["think-7b-sft"]["config"], "Logged OLMo-core config (W&B opu8p4gg), hyperparameters only",
+                       ["Table 47: lr 5e-5, 1,048,576-token batches, 2 epochs, 32K sequences, packing, 64 H100s."]),
+        hyperparams={"lr": 5e-5, "schedule": "linear warmup 3%, linear decay to 0", "optimizer": "SkipStepAdamW (betas 0.9/0.95, eps 1e-8, wd 0)",
+                     "global_batch_tokens": 1048576, "max_seq_len": 32768, "epochs": 2, "steps": 43296, "tokens_trained": 45400000000,
+                     "max_grad_norm": 1.0, "packing": "document packing", "gpus": "8 nodes × 8 H100", "context_parallel": 2, "data_parallel": "HSDP"},
+        checkpoints=branch_ckpts(branches, "allenai/Olmo-3-7B-Think-SFT", (1, 43296)),
+        events=[{"step": 21000, "kind": "restart", "severity": "warning", "title": "Resumed from the step-21,000 checkpoint",
+                 "body": "The first W&B run (6y6q8f7a) logged up to step 21,479; the second (opu8p4gg, same name) starts again at 21,001."}],
+        tokens_per_step=1048576, stage="SFT", tags=["think", "7B", "published"])
+    dpo7 = sft_run_record(
+        ctx, key="think-7b-dpo", name="olmo3-7b-think-dpo", rows=wb["think-7b-dpo"]["rows"], kind="dpo", base_model_id=M["sft7"],
+        output_model_id=M["dpo7"], datasets=[(ds["dpo7"], 1.0)], gpus=32, cluster=clusters["jupiter"], group_name="think-7b",
+        algorithm="DPO (length-normalized, dpo_norm)",
+        description="Delta-learning DPO in open-instruct (dpo_tune_cache.py, DeepSpeed ZeRO-3): Dolci-Think-DPO-7B, 150,000 pairs, beta 5, lr 8e-8, "
+                    "batch 128 (1,172 steps × 128 ≈ 150K pairs), 1 epoch, 16K sequences, linear decay with 10% warmup, no gradient clipping, 32 H100s "
+                    "(Table 48). Final logged loss 0.074, preference accuracy 0.99, margin 4.54.",
+        source="https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/1e5w41io",
+        config=cfg_text("Logged open-instruct DPO config (W&B 1e5w41io)", wb["think-7b-dpo"]["config"]),
+        hyperparams={"loss": "dpo_norm", "beta": 5, "lr": 8e-8, "schedule": "linear, warmup 0.1", "batch_pairs": 128, "epochs": 1,
+                     "max_seq_len": 16384, "steps": 1172, "grad_clip": "none", "weight_decay": 0, "gpus": 32, "grad_accum": 4},
+        batch_rows=128, tokens_per_step=None, stage="DPO", tags=["think", "7B", "published"])
+
+    # ---- 7B Think RL: public-runs curve plus the extra W&B keys
+    pub7 = load("public-runs/ai2-olmo3-7b-think-rl/metrics.jsonl.gz")
+    extra7 = {r["step"]: r for r in wb["think-7b-rl-extra"]["rows"]}
+    rows7 = []
+    for r in pub7:
+        x = {k: v for k, v in r.items() if k not in ("episode", "training_step")}
+        x.update({k: v for k, v in extra7.get(r["step"], {}).items() if k != "step"})
+        rows7.append(x)
+    cfg7 = wb["think-7b-rl-extra"]["config"]
+    shares7 = [(E["math"], 30180), (E["code"], 12113), (E["code_stdio"], 9272), (E["ifeval"], 29813), (E["general"], 20636)]
+    ck7 = branch_ckpts(branches, "allenai/Olmo-3-7B-Think", (1, 1575))
+    rl7 = rl_run_record(
+        ctx, key="think-7b-rl", name="olmo3-7b-think-rl", rows=rows7, base_model_id=M["dpo7"], output_model_id=M["think7"], envs=shares7,
+        prompts=64, group=8, max_tokens=32768, active=False, normalize_adv=True, learner_gpus=8, actor_gpus=64, cluster=clusters["jupiter"],
+        description="OlmoRL from Olmo-3-7B-Think-DPO on the Think RL mix, W&B run olmo3_dpo_rl_final_mix (a6w0ezf4): 64 prompts × 8 samples, 32K-token "
+                    "responses, lr 1e-6 constant, no KL, 1,575 steps (0.988 epochs) from 2 to 18 Oct 2025. The paper and the logged config disagree: "
+                    "Table 49 gives clip-higher 0.272, group-mean-centred advantages (Dr GRPO), 16 learner + 56 actor GPUs and 1,400 steps; the run "
+                    "logged clip-higher 0.2, standard advantage normalisation, async_steps 1, no inflight updates, no TIS, 8 learners + 64 vLLM engines "
+                    "and 1,575 steps. The paper says the released 7B Think used 'an initial version of our infrastructure without pipelineRL or "
+                    "truncation importance sampling' (~15 days). The logged config is shown; which checkpoint became the release is unstated. Metrics "
+                    "are the published curve (1,000 logged rows); rollouts are simulated to match the per-verifier correct rates.",
+        source="https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/a6w0ezf4", provenance="mixed",
+        config=cfg_text("Logged grpo_fast config (W&B a6w0ezf4), hyperparameters only", cfg7,
+                        ["Paper Table 49 differs: clip_higher 0.272, advantages centred (no std), 16 learner / 56 actor GPUs, 1,400 steps."]),
+        hyperparams={"prompts_per_step": 64, "group_size": 8, "lr": 1e-6, "lr_schedule": "constant", "max_prompt_len": 2048,
+                     "max_response_len": 32768, "beta_kl": 0, "clip_lower": 0.2, "clip_higher_logged": 0.2, "clip_higher_paper": 0.272,
+                     "advantage_normalization_logged": "standard", "advantage_paper": "group mean-centred, no std (Dr GRPO)", "async_steps": 1,
+                     "inflight_updates": False, "tis_cap": None, "num_mini_batches": 1, "loss": "token-level", "verification_reward": 10,
+                     "code_pass_rate_reward_threshold": 0.99, "judge": "hosted_vllm/Qwen/Qwen3-32B", "learners_logged": 8, "vllm_engines_logged": 64,
+                     "gpus_paper": "16 learner + 56 actor", "steps": 1575, "steps_paper": 1400, "temperature": 1.0, "save_freq": 25,
+                     "offline_difficulty_filter": "drop pass rate > 62.5% over 8 DPO rollouts"},
+        group_name="think-7b", tags=["think", "7B", "published curve"], checkpoints=ck7, store_steps=100, async_steps=1, code_ref=GRPO_FAST,
+        datasets=[(ds["rl7"], 1.0)],
+        events=[{"step": 0, "kind": "config", "severity": "warning", "title": "Logged config differs from the paper's Table 49",
+                 "body": "clip-higher 0.2 vs 0.272; standard vs centred advantages; 8/64 vs 16/56 learner/actor GPUs; 1,575 vs 1,400 steps."}])
+    # the newer-infrastructure replica
+    rep = wb["think-7b-rl-replica"]
+    rl7r = rl_run_record(
+        ctx, key="think-7b-rl-replica", name="olmo3-7b-think-rl-replica", rows=[dict(r) for r in rep["rows"]], base_model_id=M["dpo7"],
+        output_model_id=None, envs=shares7, prompts=64, group=8, max_tokens=32768, active=False, normalize_adv=False, learner_gpus=16,
+        actor_gpus=16, cluster=clusters["jupiter"],
+        description="Replica of the 7B Think RL on the newer OlmoRL stack (W&B q2cscw2w, olmo3_dpo_0711_rl_fun_mix_fix), from the same DPO checkpoint "
+                    "and mix: clip-higher 0.272, TIS cap 2, centred advantages, async_steps 8, inflight updates, 16 learners + 16 vLLM engines, 1,503 "
+                    f"steps (the paper's Table 49 settings). The paper says a replica on the newer stack matched the original in about 6 days; this "
+                    f"record's timestamps span 12.8 days (9-21 Nov 2025) with a median logged step of {med(rep['rows'], 'time/total'):.0f} s against "
+                    f"{med(rows7, 'time/total'):.0f} s for the original. Not released. "
+                    "Metrics are the published curve (thinned to 500 rows); rollouts are simulated.",
+        source="https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/q2cscw2w", provenance="mixed",
+        config=cfg_text("Logged grpo_fast config (W&B q2cscw2w), hyperparameters only", rep["config"]),
+        hyperparams={"prompts_per_step": 64, "group_size": 8, "lr": 1e-6, "max_response_len": 32768, "clip_higher": 0.272, "tis_cap": 2,
+                     "advantage_normalization": "centered", "async_steps": 8, "inflight_updates": True, "learners": 16, "vllm_engines": 16,
+                     "steps": 1503, "beta_kl": 0},
+        group_name="think-7b", tags=["think", "7B", "replica", "published curve"], parent_run_id=None, store_steps=40, async_steps=8, code_ref=GRPO_FAST,
+        datasets=[(ds["rl7"], 1.0)])
+
+    # ---- 32B: two SFT runs, DPO, RL
+    for lr_key, lr in (("1e-4", 1e-4), ("5e-5", 5e-5)):
+        r_ = wb[f"think-32b-sft-{lr_key}"]
+        sft_run_record(
+            ctx, key=f"think-32b-sft-{lr_key}", name=f"olmo3-32b-think-sft-lr{lr_key}", rows=r_["rows"], kind="sft", base_model_id=M["base32"],
+            output_model_id=M["sft32a"] if lr_key == "1e-4" else M["sft32b"], datasets=[(ds["sft32"], 1.0)], gpus=256, cluster=clusters["augusta"],
+            group_name="think-32b",
+            description=f"One of the 32B Think SFT runs in OLMo-core at lr {lr_key}: Dolci-Think-SFT-32B, 4,194,304-token batches, 2 epochs, 10,790 "
+                        f"steps, 45.2B tokens, on 32 nodes × 8 H100 (augusta). Four learning rates were swept in parallel for about 36 h (§2.4); the "
+                        f"released SFT is a linear merge of the 1e-4 and 5e-5 runs. Final CE loss {r_['rows'][-1]['train/CE loss']:.4f}. Framework "
+                        f"field: the engine's megatron_sft tag set; the logged tags are OLMo-core's.",
+            source=r_["url"], config=cfg_text(f"Logged OLMo-core config (W&B {r_['parts'][0]['wandb'].split('/')[-1]}), hyperparameters only", r_["config"]),
+            hyperparams={"lr": lr, "schedule": "linear warmup 3%, linear decay to 0", "global_batch_tokens": 4194304, "max_seq_len": 32768, "epochs": 2,
+                         "steps": 10790, "tokens_trained": 45200000000, "gpus": "32 nodes × 8 H100", "max_grad_norm": 1.0},
+            checkpoints=[(s, None, f"hf://allenai/Olmo-3-32B-Think-SFT@{lr_key}-step{s}") for s in (1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 10790)],
+            tokens_per_step=4194304, stage="SFT", tags=["think", "32B", "published"])
+    dpo32 = sft_run_record(
+        ctx, key="think-32b-dpo", name="olmo3-32b-think-dpo", rows=wb["think-32b-dpo"]["rows"], kind="dpo", base_model_id=M["sft32"],
+        output_model_id=M["dpo32"], datasets=[(ds["dpo32"], 1.0)], gpus=128, cluster=clusters["jupiter"], group_name="think-32b",
+        algorithm="DPO (length-normalized, dpo_norm)",
+        description="Delta-learning DPO of the merged 32B SFT: Dolci-Think-DPO-32B, 200,000 pairs, beta 5, lr 7e-8 (from a 7/8/9e-8 sweep), batch 128 "
+                    "(1,563 steps), 8K sequences. Table 48 gives 64-128 GPUs and the script 16 nodes × 8; 128 is used for cost. DPO sweeps took about "
+                    "18 h each on 64 GPUs per job but stretched over days because of cluster instability (§2.4). Final logged loss 0.099, accuracy "
+                    "0.99, margin 3.76.",
+        source="https://wandb.ai/ai2-llm/Olmo-3-32B-Think/runs/19pb8hi1", config=cfg_text("Logged open-instruct DPO config (W&B 19pb8hi1)", wb["think-32b-dpo"]["config"]),
+        hyperparams={"loss": "dpo_norm", "beta": 5, "lr": 7e-8, "lr_sweep": [7e-8, 8e-8, 9e-8], "batch_pairs": 128, "epochs": 1, "max_seq_len": 8192,
+                     "steps": 1563, "gpus": "64-128 (Table 48); script 16 nodes × 8"},
+        batch_rows=128, stage="DPO", tags=["think", "32B", "published"],
+        events=[{"step": 1, "kind": "notice", "severity": "info", "title": "Sweeps slowed by cluster instability",
+                 "body": "DPO sweeps took ~18 h each on 64 GPUs per job but stretched over days because of cluster instability (§2.4)."}])
+    shares32 = [(E["math"], 30182), (E["code"], 12113), (E["code_stdio"], 9176), (E["ifeval"], 29847), (E["general"], 20708)]
+    rows32 = [dict(r) for r in pub32]
+    for r in rows32:
+        r.pop("episode", None)
+    ck32 = branch_ckpts(branches, "allenai/Olmo-3-32B-Think", (1, 750), release=750, model_id=M["think32"], main_step=750)
+    rl32 = rl_run_record(
+        ctx, key="think-32b-rl", name="olmo3-32b-think-rl", rows=[r for r in rows32 if r["step"] <= 750], base_model_id=M["dpo32"],
+        output_model_id=M["think32"], envs=shares32, prompts=128, group=8, max_tokens=32768, active=True, normalize_adv=False, learner_gpus=64,
+        actor_gpus=160, cluster=clusters["jupiter"],
+        description="OlmoRL from Olmo-3-32B-Think-DPO, steps 1-750 (the Olmo 3 32B Think release is step 750): 128 prompts × 8 samples (the record logs "
+                    "1,024 rollouts per step), lr 2e-6, 32K responses, TIS cap 2, asynchrony 8, active sampling, 8 training + 20 inference H100 nodes "
+                    "(64 learner + 160 actor GPUs, TP 8). About 5 days, at least one lost to stability issues (§2.4). The curve is Ai2's public W&B "
+                    "record for this stage (6elghrzv, test_dpo_olmo3_32b_res100_s1_lr2e-6_27200), which logs no config: it starts 16 Nov 2025 and "
+                    "reaches step 750 on 21 Nov at 11:48 UTC, a day after the 20 Nov release date, so it may not be the exact run behind the release. "
+                    "The record continues to step 976 (see the 3.1 continuation). The script 32b_think_rl.sh sets 64 prompts and 12 learner nodes + "
+                    "6 engines; Table 49 and the logged batch are used. Rollouts are simulated to match the per-verifier correct rates.",
+        source="https://wandb.ai/ai2-llm/Olmo-3-32B-Think/runs/6elghrzv", provenance="mixed",
+        config=cfg_text("Published facts (Table 49, §2.4, §4.4.3); the W&B record logs no config", {
+            "prompts_per_step": 128, "samples_per_prompt": 8, "learning_rate": 2e-6, "lr_scheduler_type": "constant", "max_prompt_token_length": 2048,
+            "response_length": 32768, "beta": 0, "clip_lower": 0.2, "clip_higher": 0.272, "truncated_importance_sampling_ratio_cap": 2.0,
+            "max_asynchrony": 8, "inflight_updates": True, "active_sampling": True, "advantage": "group mean-centred, no std",
+            "learner_gpus": 64, "actor_gpus": 160, "gpus_per_actor_tp": 8, "steps": 750, "offline_difficulty_filter": "none (7B-filtered data reused)"},
+            ["32b_think_rl.sh disagrees: num_unique_prompts_rollout 64, 12 learner nodes + 6 TP-8 engines."]),
+        hyperparams={"prompts_per_step": 128, "group_size": 8, "lr": 2e-6, "max_response_len": 32768, "tis_cap": 2.0, "max_asynchrony": 8,
+                     "active_sampling": True, "clip_lower": 0.2, "clip_higher": 0.272, "beta_kl": 0, "learner_gpus": 64, "actor_gpus": 160,
+                     "steps": 750, "script_prompts_per_step": 64},
+        group_name="think-32b", tags=["think", "32B", "published curve"], checkpoints=ck32, store_steps=80, async_steps=8, code_ref=GRPO_FAST,
+        datasets=[(ds["rl32"], 1.0)],
+        events=[{"step": 1, "kind": "notice", "severity": "warning", "title": "Stability issues",
+                 "body": "At least one of the ~5 days of the final 32B RL run was lost to stability issues; the fix is not described (§2.4)."}])
+    # the 3.1 continuation: steps 751-976 are the public record, 977-2,300 are simulated to the report's 21 more days
+    tail_rows = [r for r in rows32 if r["step"] > 750]
+    last = tail_rows[-20:]
+    avg = lambda tag: sum(r[tag] for r in last if r.get(tag) is not None) / max(1, sum(1 for r in last if r.get(tag) is not None))
+    t_real_end = tail_rows[-1]["_timestamp"]
+    t31_end = at("2025-12-11 00:00")
+    vers32 = {"math": (avg("objective/math_correct_rate"), avg("objective/math_correct_rate") + 0.04),
+              "code": (avg("objective/code_correct_rate"), avg("objective/code_correct_rate") + 0.05),
+              "code_stdio": (avg("objective/code_stdio_correct_rate"), avg("objective/code_stdio_correct_rate") + 0.05),
+              "ifeval": (avg("objective/ifeval_correct_rate"), min(0.99, avg("objective/ifeval_correct_rate") + 0.02)),
+              "general-quality_ref": (avg("objective/general-quality_ref_correct_rate"), 0.999),
+              "general-quality": (avg("objective/general-quality_correct_rate"), 0.999)}
+    tot = sum(x for _, x in shares32)
+    sh = {"math": 30182 / tot, "code": 12113 / tot, "code_stdio": 9176 / tot, "ifeval": 29847 / tot, "general-quality_ref": 0.8 * 20708 / tot,
+          "general-quality": 0.2 * 20708 / tot}
+    synth31 = synth_rows("think-32b-rl-3.1", first_step=977, last_step=2300, n=150, t0=t_real_end, t1=t31_end, verifiers=vers32, shares=sh,
+                         prompts=128, group=8, max_tokens=32768, active=True,
+                         lengths=(avg("val/sequence_lengths"), avg("val/sequence_lengths") * 1.12), stop=(avg("val/stop_rate"), avg("val/stop_rate") - 0.005),
+                         judge_reward=(avg("objective/general-quality_ref_reward") / 10, avg("objective/general-quality_ref_reward") / 10 + 0.01),
+                         fz=(avg("derived/all_zero_share") if any(r.get("batch/filtered_prompts_zero") is not None for r in last) else 0.12, 0.12),
+                         train_frac=(0.1, 0.2), lr=2e-6)
+    ck31 = branch_ckpts(branches, "allenai/Olmo-3.1-32B-Think", (751, 2300), release=2300, model_id=M["think31"], main_step=2300)
+    rl31 = rl_run_record(
+        ctx, key="think-32b-rl-3.1", name="olmo3.1-32b-think-rl", rows=[dict(r) for r in tail_rows] + synth31, base_model_id=M["think32"],
+        output_model_id=M["think31"], envs=shares32, prompts=128, group=8, max_tokens=32768, active=True, normalize_adv=False, learner_gpus=64,
+        actor_gpus=160, cluster=clusters["jupiter"], parent_run_id=rl32["run_id"],
+        description="Olmo 3.1: the 32B Think RL run continued from step 750 (the Olmo 3 32B Think release) to step 2,300, 21 more days on 224 GPUs "
+                    "(§2.4), with extra epochs over Dolci-Think-RL, and stopped for compute limits rather than saturation (footnote 30). Steps 751-976 "
+                    "are the public W&B record (6elghrzv), which ends there in state 'failed'; no public record covers steps 977-2,300, so they are "
+                    "simulated here: per-verifier correct rates move slowly from the record's last values, and the dates are fitted to the report's 21 "
+                    "more days after the 20 Nov release. The held-out end points are the published Table 14 scores.",
+        source=S24, provenance="mixed", config=cfg_text("Published facts; same run as the Olmo 3 32B Think RL", {
+            "resumed_from_step": 750, "last_step": 2300, "gpus": 224, "extra_days": 21, "learning_rate": 2e-6, "prompts_per_step": 128,
+            "samples_per_prompt": 8, "response_length": 32768}, ["Steps 977-2,300 are simulated; the public record stops at 976."]),
+        hyperparams={"prompts_per_step": 128, "group_size": 8, "lr": 2e-6, "max_response_len": 32768, "tis_cap": 2.0, "max_asynchrony": 8,
+                     "active_sampling": True, "steps": 2300, "start_step": 751, "gpus": 224, "public_record_last_step": 976},
+        group_name="think-32b", tags=["think", "32B", "Olmo 3.1", "mixed"], checkpoints=ck31, store_steps=90, async_steps=8, code_ref=GRPO_FAST,
+        datasets=[(ds["rl32"], 1.0)],
+        events=[{"step": 976, "t": t_real_end, "kind": "incident", "severity": "warning", "title": "Public W&B record ends: state 'failed'",
+                 "body": "The public 32B Think RL record (6elghrzv) ends at step 976 in state 'failed', with no config logged. The report says the run "
+                         "resumed and continued to step 2,300; the steps after 976 are simulated here."}])
+
+    # ---- tasks: base = the DPO model's published pass rates (skill 0), latest = the 7B RL run's last per-verifier rates
+    final7 = {"math": window(rows7, "objective/math_correct_rate", 1500, 1575), "code": window(rows7, "objective/code_correct_rate", 1500, 1575),
+              "code_stdio": window(rows7, "objective/code_stdio_correct_rate", 1500, 1575),
+              "ifeval": window(rows7, "objective/ifeval_correct_rate", 1500, 1575)}
+    for k, env in E.items():
+        if not env.tasks:
+            continue
+        d = [t.difficulty for t in env.tasks]
+        if env.judge:
+            rw = window(rows7, "objective/general-quality_ref_reward", 1, 60)
+            rw1 = window(rows7, "objective/general-quality_ref_reward", 1500, 1575)
+            kit.write_tasks(w, env, base_skill=solve_skill(d, judge_target((rw or 8.5) / 10)), latest_skill=solve_skill(d, judge_target((rw1 or 9.0) / 10)), attempts=8)
+            continue
+        target = None if env.partial_steps else final7.get(k)  # IF logs only a partial-credit rate over kept groups: no latest pass rate
+        kit.write_tasks(w, env, base_skill=0.0 if env.real_pass else solve_skill(d, 0.35),
+                        latest_skill=solve_skill(d, min(0.97, max(0.03, target))) if target else None, attempts=8)
+
+    # ---- evals
+    EV = Evals(ctx)
+    make_benches(EV, T15)
+    EV.bench("dev-avg", "Dev average (Table 22, 10 evals)", "Overall", "score", 10, 1,
+             "Average of the ten Table 22 columns (MMLU, BBH, GPQA, ZebraLogic, AGIEval, AIME25, AIME24, HumanEval+, LCB, IFEval) for the 7B "
+             "starting-point ablation: single runs, RLVR for 1,000 steps. Only the average is stored.", T22, store=False)
+    EV.bench("rl-slice", "RL-mix held-out slice (local eval)", "Training", "correct rate", 32, 1,
+             "open-instruct's local eval inside the 7B Think RL run: verifier scores on 32 held-out prompts of the RL mix (OMEGA 8, IF 8, AceCoder 8, "
+             "rewritten Tülu 3 4, Multi-Subject RLVR 4 in the logged eval mixer), configured every 50 steps but logged only 8 times. Values move in "
+             "steps of 1/32 overall and 1/8 per domain.", "https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/a6w0ezf4")
+    endt = lambda res: (res["end"] or 0) + 2 * 3600
+    for bk, vals in THINK7.items():
+        sft_v, dpo_v, rl_v = vals
+        EV.ev(bk, M["sft7"], sft_v, source=T15, ek="sft7|end", run_id=sft7["run_id"], step=43296, started=endt(sft7), config={"table": "15", "runs": 3})
+        EV.ev(bk, M["sft7"], sft_v, source=T15, ek="dpo7|0", run_id=dpo7["run_id"], step=0, started=dpo7["start"] - 3600, config={"table": "15", "runs": 3})
+        EV.ev(bk, M["dpo7"], dpo_v, source=T15, ek="dpo7|end", run_id=dpo7["run_id"], step=1172, started=endt(dpo7), config={"table": "15", "runs": 3})
+        EV.ev(bk, M["dpo7"], dpo_v, source=T15, ek="rl7|0", run_id=rl7["run_id"], step=0, started=rl7["start"] - 3600, config={"table": "15", "runs": 3})
+        EV.ev(bk, M["think7"], rl_v, source=T15, ek="rl7|end", run_id=rl7["run_id"], step=1400, started=endt(rl7),
+              config={"table": "15", "runs": 3, "step_note": "Table 49 gives 1,400 RL steps; the released checkpoint's step is not stated."})
+    for bk, vals in THINK32.items():
+        s, dpo_v, r30, r31 = vals
+        EV.ev(bk, M["sft32"], s, source=T14, ek="sft32", run_id=None, step=None, started=merge_t + 3600, config={"table": "14"})
+        EV.ev(bk, M["sft32"], s, source=T14, ek="dpo32|0", run_id=dpo32["run_id"], step=0, started=dpo32["start"] - 3600, config={"table": "14"})
+        EV.ev(bk, M["dpo32"], dpo_v, source=T14, ek="dpo32|end", run_id=dpo32["run_id"], step=1563, started=endt(dpo32), config={"table": "14"})
+        EV.ev(bk, M["dpo32"], dpo_v, source=T14, ek="rl32|0", run_id=rl32["run_id"], step=0, started=rl32["start"] - 3600, config={"table": "14"})
+        EV.ev(bk, M["think32"], r30, source=T14, ek="rl32|750", run_id=rl32["run_id"], step=750, started=t750 + 3600, config={"table": "14"})
+        EV.ev(bk, M["think32"], r30, source=T14, ek="rl31|750", run_id=rl31["run_id"], step=750, started=t750 + 3600, config={"table": "14"})
+        EV.ev(bk, M["think31"], r31, source=T14, ek="rl31|end", run_id=rl31["run_id"], step=2300, started=t31_end + 3600,
+              config={"table": "14", "note": "Table 1 and the model card list AGIEval 89.2 and GPQA 57.5; Table 14 is used."})
+    for bk, (t7, _, t32, _) in SAFETY.items():
+        for stage, (mk, rk, st) in enumerate((("sft7", "think-7b-sft", 43296), ("dpo7", "think-7b-dpo", 1172), ("think7", "think-7b-rl", 1400))):
+            res = ctx.runs[rk]
+            EV.ev(bk, M[mk], t7[stage], source=T52, ek=f"{mk}", run_id=res["run_id"], step=st, started=endt(res), config={"table": "52", "runs": 3})
+        for stage, (mk, rk, st, when) in enumerate((("sft32", None, None, merge_t), ("dpo32", "think-32b-dpo", 1563, dpo32["end"]),
+                                                    ("think32", "think-32b-rl", 750, t750), ("think31", "think-32b-rl-3.1", 2300, t31_end))):
+            EV.ev(bk, M[mk], t32[stage], source=T54, ek=f"{mk}", run_id=ctx.runs[rk]["run_id"] if rk else None, step=st, started=when + 7200,
+                  config={"table": "54"})
+    abl_t = None
+    EV.ev("dev-avg", M["sft7"], TABLE22["sft"][0], source=T22, ek="t22", started=abl_t, config={"table": "22"})
+    EV.ev("dev-avg", M["dpo7"], TABLE22["dpo"][0], source=T22, ek="t22", started=abl_t, config={"table": "22"})
+    for mk, tk in (("abl-sft", "sft-rlvr"), ("abl-dpo", "dpo-rlvr")):
+        avgv, cols = TABLE22[tk]
+        EV.ev("dev-avg", M[mk], avgv, source=T22, ek="t22", started=abl_t, config={"table": "22", "rlvr_steps": 1000})
+        for bk, v in zip(TABLE22_COLS, cols):
+            EV.ev(bk, M[mk], v, source=T22, ek="t22", started=abl_t, config={"table": "22", "rlvr_steps": 1000, "single_run": True})
+    for r in rows7:
+        v = r.get("eval/objective/verifiable_correct_rate")
+        if v is None:
+            continue
+        cfg = {k.split("/")[-1].replace("_correct_rate", ""): r[k] for k in r if k.startswith("eval/objective/") and k.endswith("_correct_rate")}
+        EV.ev("rl-slice", M["dpo7"], v * 100, source="https://wandb.ai/ai2-llm/Olmo-3-7B-Think/runs/a6w0ezf4", ek=f"slice|{r['step']}",
+              run_id=rl7["run_id"], step=r["step"], started=interp_time(rl7["stamps"], r["step"]),
+              config={"per_domain": cfg, "mean_response_tokens": r.get("eval/sequence_lengths"), "note": "logged by the trainer (eval/objective/*)"})
+
+    # ---- metric defs, usage, report
+    write_metric_defs(w, pid, ctx.tags, ctx.env_signal, sft=True, dpo=True)
+    for key in ("think-7b-sft",):
+        res = ctx.runs[key]
+        spend(w, org_id, pid, res["start"], res["end"], res["cost"], (("SFT (derived, $2/H100-hour)", 1.0),))
+    spend(w, org_id, pid, dpo7["start"], dpo7["end"], dpo7["cost"], (("DPO (derived, $2/H100-hour)", 1.0),))
+    for res in (rl7, rl7r):
+        spend(w, org_id, pid, res["start"], res["end"], res["cost"], rl_split(res))
+    spend(w, org_id, pid, rl31["stamps"][0][1] if rl31["stamps"] else rl31["start"], rl31["end"], rl31["cost"], rl_split(rl31))
+    # Every costed run is on the usage ledger, so the project's spend and each run's share of it agree
+    covered = {ctx.runs["think-7b-sft"]["run_id"], dpo7["run_id"], rl7["run_id"], rl7r["run_id"], rl31["run_id"]}
+    for key, res in ctx.runs.items():
+        if res["run_id"] in covered or not res.get("cost"):
+            continue
+        split = ((("SFT" if "sft" in key else "DPO") + " (derived, $2/H100-hour)", 1.0),) if ("sft" in key or "dpo" in key) else rl_split(res)
+        spend(w, org_id, pid, res["start"], res["end"], res["cost"], split)
+    idle = lambda rows: (sum(r["time/trainer_idling"] for r in rows if r.get("time/trainer_idling") is not None and r.get("time/total")),
+                         sum(r["time/total"] for r in rows if r.get("time/trainer_idling") is not None and r.get("time/total")))
+    i7, t7 = idle([r for r in rows7])
+    i32, t32 = idle([r for r in pub32])
+    med32 = (med(pub32, "time/total"), med(pub32, "time/training"))
+    med7 = (med(rows7, "time/total"), med(rows7, "time/training"))
+    kit.report(
+        w, pid, "think-findings", "OLMo 3 Think: what the report found, checked against the public runs", "Ai2 OLMo team (technical report)",
+        at("2025-12-15 00:00"),
+        "Claims from the Olmo 3 report about the Think pipeline, with the evidence from its tables and the public W&B runs. The whole 32B model cost "
+        "about $2.75M to build: 1,024 H100s for about 56 days at $2 per H100-hour (§2.4), of which post-training of the 32B Think flow took about 9 days.",
+        [{"claim": "The RL learner sat idle about 75% of the time waiting for generation; inference used about 5× the GPU time of training for the 32B "
+                   "(8 training vs 20 inference nodes) and about 14× for the 7B.",
+          "verdict": "upheld",
+          "evidence": f"§4.4.3 and footnote 41 (a representative ~1,000 s step had ~125 s of training). Public W&B: the 32B record's learner idled "
+                      f"{i32 / t32:.0%} of logged step time (median step {med32[0]:.0f} s, median training {med32[1]:.0f} s); the 7B run's "
+                      f"{i7 / t7:.0%} (median {med7[0]:.0f} s, training {med7[1]:.0f} s)."},
+         {"claim": "Delta learning works where imitation saturates: further SFT on Qwen3-32B thinking traces hurt, while DPO on the same traces against "
+                   "Qwen3-0.6B rejects helped.", "verdict": "upheld",
+          "evidence": "Table 21 (dev): continued SFT lowered the average from 70.3 to 64.5; DPO raised it to 72.9 (AIME25 58.8 → 66.3, LCB 67.0 → 72.6). "
+                      "Table 15: DPO lifted 7B AIME25 57.6 → 62.7 and LCB 67.8 → 75.1."},
+         {"claim": "DPO is a better starting point for RL than SFT.", "verdict": "upheld",
+          "evidence": "Table 22 (single runs, 1,000 RLVR steps): SFT + RLVR averages 71.9, SFT + DPO + RLVR 74.1; DPO also raised pass@k (Figures 19-20)."},
+         {"claim": "RL gives the largest instruction-following gains of the three stages.", "verdict": "upheld",
+          "evidence": "7B Think IFEval 77.9 → 75.9 → 88.2 and IFBench 30.0 → 28.3 → 41.6 over SFT → DPO → RL (Tables 15, 24); 32B IFBench 34.4 (DPO) → "
+                      "47.6 (step 750) → 68.1 (step 2,300)."},
+         {"claim": "Running the 32B RL longer kept improving reasoning; it stopped for compute, not saturation.", "verdict": "upheld",
+          "evidence": "Table 14, step 750 → 2,300: AIME24 76.8 → 80.6, AIME25 72.5 → 78.1, ZebraLogic 76.0 → 80.1, IFEval 89.0 → 93.8, IFBench 47.6 → "
+                      "68.1, safety 68.8 → 83.6. Not everything rose: AlpacaEval 74.2 → 69.1, GPQA 58.1 → 56.7, PopQA 31.9 → 30.9."},
+         {"claim": "Continuous batching, better threading and inflight weight updates more than tripled RL generation throughput.", "verdict": "upheld",
+          "evidence": "Table 23 (2 × 8 A100 nodes, 2 h): 881 → 975 → 1,358 → 2,949 tokens/s; MBU 12.9% → 43.2%. At a 32K cap the mean generation was "
+                      "14,628 tokens, so static batching would waste up to 54%."},
+         {"claim": "The released 7B Think RL used an initial infrastructure (~15 days); a replica on the newer stack matched it in about 6 days.",
+          "verdict": "open",
+          "evidence": f"The original's public record spans 2-18 Oct 2025 (16.0 days, median {med7[0]:.0f} s per step), consistent with ~15 days. The "
+                      f"public replica (q2cscw2w) has a faster median step ({med(rep['rows'], 'time/total'):.0f} s) but its timestamps span 12.8 days "
+                      f"for 1,503 steps; the paper's 6 days may count time to matching performance."},
+         {"claim": "The paper's 7B Think RL hyperparameters (Table 49) are the ones the public run used.", "verdict": "rejected",
+          "evidence": "The logged config of a6w0ezf4 has clip-higher 0.2 (paper 0.272), standard advantage normalisation (paper: centred, Dr GRPO), 8 "
+                      "learners + 64 engines (paper 16 + 56) and 1,575 steps (paper 1,400). The newer-stack replica matches Table 49. Which checkpoint "
+                      "was released is not stated; HF branches stop at step_1375."},
+         {"claim": "Offline difficulty filtering keeps only prompts the DPO model does not already solve.", "verdict": "upheld",
+          "evidence": f"Prompts with pass rate above 62.5% over 8 DPO rollouts were dropped: IF 95,279 → 57,837 and math 209,885 → 58,174 in the pool's "
+                      f"viewer counts. All {sum(1 for x in rl_rows if x.get('passrate') is not None)} stored tasks with a published pass rate are at or "
+                      f"below 0.625 (mean {statistics.mean(x['passrate'] for x in rl_rows if x.get('passrate') is not None):.2f})."},
+         {"claim": "Reasoning-gym puzzles and o3-generated tasks did not help and were dropped.", "verdict": "upheld",
+          "evidence": "Dataset cards of the completion pools; 65,000 puzzle prompts (mean DPO pass rate 0.152) and 11,588 o3 tasks are absent from the "
+                      "final mix."},
+         {"claim": "The whole 32B model cost about $2.75M to build.", "verdict": "upheld",
+          "evidence": "1,024 H100 × ~56 days × 24 h × $2 = $2,752,512 (§2.4). It covers pre-, mid- and post-training of the 32B, not the 7B or the 3.1 "
+                      "continuation. It is not on the usage page, which counts post-training runs only (derived at $2 per H100-hour)."}],
+        run_keys=("think-7b-sft", "think-7b-dpo", "think-7b-rl", "think-7b-rl-replica", "think-32b-dpo", "think-32b-rl", "think-32b-rl-3.1"),
+        body="Model cards contain errors the report does not: the Olmo-3-7B-Think cards swap OMEGA SFT and final (45.0 / 37.8 against Table 15's 37.8 / "
+             "45.0); the 32B Think card lists OMEGA 50.8 against 50.6; the 3.1 32B Think card and Table 1 list AGIEval 89.2 and GPQA 57.5 against Table "
+             "14's 88.8 and 56.7; Table 24 prints 32B Think SFT IFEval 83.7 where Table 14 prints 83.9; the 3.1 blog update says '5+ points on AIME' where "
+             "§4.1.2 says '4+'. The report's main tables are used throughout.")
+
+
+# ================================================================ OLMo 3 Instruct
+def build_instruct(w, org_id, wb, data, branches, clusters):
+    pid = kit.project(
+        w, org_id, "olmo-3-instruct", "OLMo 3 Instruct",
+        "Olmo 3 Instruct 7B and Olmo 3.1 Instruct 32B: non-thinking chat and tool use. SFT in OLMo-core warm-started from the Think SFT checkpoint, DPO "
+        "on delta-learning plus delta-aware GPT-judged pairs with length control, then OlmoRL with easier math and code and no offline difficulty filter.",
+        [{"title": "Olmo 3 technical report (arXiv 2512.13961, v2), §5", "url": sec("S5")}, {"title": "Ai2 blog: Olmo 3 and the Olmo 3.1 update", "url": BLOG},
+         {"title": "W&B report: Olmo 3 7B Instruct", "url": WB_REPORT["instruct7"]}, {"title": "W&B report: Olmo 3 32B Instruct", "url": WB_REPORT["instruct32"]},
+         {"title": "open-instruct OLMo 3 scripts README", "url": OI_README}, {"title": "mcp-tool-eval (tool-use evaluation)", "url": MCP_EVAL},
+         {"title": "Olmo-3-7B-Instruct model card", "url": hf("allenai/Olmo-3-7B-Instruct")},
+         {"title": "Olmo-3.1-32B-Instruct model card", "url": hf("allenai/Olmo-3.1-32B-Instruct")}],
+        "Published: SFT and DPO curves for both sizes and the 3.1 32B Instruct RL curve (public W&B runs with configs and timestamps), lineage (the "
+        "Instruct SFT starts from the Think SFT checkpoint), datasets and composition (Tables 27, 30; HF statistics), every per-stage score (Tables 25, "
+        "26, 31, 53, 55). Simulated: the 7B Instruct RL run (no public curve; its end points are the published Table 26 scores), rollouts and task "
+        "pass rates, per-task eval results. Costs are GPU-hours × $2 (derived).",
+        at("2025-11-15 00:00"))
+    ctx = Ctx(w, org_id, pid, "olmo-3-instruct")
+    ctx.clusters = clusters
+    M = {}
+    M["base7"] = kit.model(w, pid, "base7", "Olmo-3-1025-7B (base)", "base", hf_repo="allenai/Olmo-3-1025-7B", arch=model_arch(7), params_total=P7,
+                           params_active=P7, context_len=65536, stage="Pre-/mid-training", created_at=at("2025-09-18 00:00"), status="released",
+                           source=hf("allenai/Olmo-3-1025-7B"), notes="See the OLMo 3 Think project for its SFT.")
+    M["tsft7"] = kit.model(w, pid, "think-sft7", "Olmo-3-7B-Think-SFT (warm start)", hf_repo="allenai/Olmo-3-7B-Think-SFT", arch=model_arch(7), params_total=P7,
+                           params_active=P7, context_len=65536, parent_id=M["base7"], stage="SFT (Think)", created_at=wb["think-7b-sft"]["rows"][-1]["_timestamp"],
+                           status="released", source=sec("S5.SS2.SSS2"),
+                           notes="Trained in the OLMo 3 Think project. The Instruct SFT starts from it (§5.2.2; script CHECKPOINT=…/olmo3-7b-reasoning-sft-final), "
+                                 "which added +3.3 points on a dev average (Table 29).")
+    M["base32"] = kit.model(w, pid, "base32", "Olmo-3-1125-32B (base)", "base", hf_repo="allenai/Olmo-3-1125-32B", arch=model_arch(32), params_total=P32,
+                            params_active=P32, context_len=65536, stage="Pre-/mid-training", created_at=at("2025-11-08 00:00"), status="released",
+                            source=hf("allenai/Olmo-3-1125-32B"))
+    M["tsft32"] = kit.model(w, pid, "think-sft32", "Olmo-3-32B-Think-SFT (warm start)", hf_repo="allenai/Olmo-3-32B-Think-SFT", arch=model_arch(32),
+                            params_total=P32, params_active=P32, context_len=65536, parent_id=M["base32"], stage="SFT (Think, merge)",
+                            created_at=at("2025-11-10 13:00"), status="released", source=hf("allenai/Olmo-3.1-32B-Instruct-SFT"),
+                            notes="Trained in the OLMo 3 Think project (merge of two LR runs). The 3.1 32B Instruct SFT starts from it (32b_instruct_sft.sh).")
+    teacher_models(ctx, M, ["qwen32", "qwen06", "judge", "gpt41", "gpt5"])
+    # datasets
+    S = data["samples"]
+    instr_sources = [("Verifiable Reasoning", "other", 310572, None), ("WildChat (GPT-4.1 responses)", "chat", 302406, "GPT-4.1"),
+                     ("Dolci Instruct Tool Use", "tool_use", 227579, "GPT-4.1-mini / GPT-5 agents; GPT-4o / 4.1 / 5 (SimFC)"),
+                     ("Dolci Instruct Python Algorithms", "code", 186345, None), ("Logic Puzzles", "other", 159882, None),
+                     ("Tülu 3 Persona MATH", "math", 149958, None), ("Dolci Instruct Precise IF", "if", 136833, None),
+                     ("Evol CodeAlpaca", "code", 107270, None), ("Aya", "multilingual", 99987, None),
+                     ("OpenThoughts3 science (traces removed)", "science", 99268, None), ("FLAN", "other", 89981, None),
+                     ("OpenMathInstruct 2", "math", 50000, None), ("Tülu 3 Persona GSM", "math", 49980, None), ("WildJailbreak", "safety", 49965, None),
+                     ("WildGuardMix", "safety", 49373, None), ("Tülu 3 Persona Python", "code", 34999, None), ("Tülu 3 Persona Algebra", "math", 19999, None),
+                     ("CoCoNot", "safety", 10957, None), ("OpenAssistant", "chat", 7132, None), ("TableGPT", "other", 5000, None),
+                     ("SciRiff", "science", 4557, None), ("Hardcoded identity data", "other", 69, None)]
+    t_sft = wb["instruct-7b-sft"]["rows"][0]["_timestamp"]
+    ds = {}
+    ds["sft"] = kit.dataset(
+        w, pid, "dolci-instruct-sft", "Dolci-Instruct-SFT", "sft", rows=2152112, license="ODC-BY", hf_repo="allenai/Dolci-Instruct-SFT",
+        sources=[{"name": n, "category": c, "rows": r, "synthetic": g is not None or None, "generator": g, "license": "ODC-BY",
+                  "url": stats_url("allenai/Dolci-Instruct-SFT")} for n, c, r, g in instr_sources],
+        processing=[{"step": "Update completions", "rows_in": None, "rows_out": None,
+                     "note": "Older GPT-3.5/GPT-4 completions replaced with GPT-4.1; reasoning traces and special tokens stripped (§5.2.2)."},
+                    {"step": "Filter and mix", "rows_in": None, "rows_out": None, "note": "Same filters as Think SFT; 100K base-mix ablations (Table 28)."},
+                    {"step": "Decontaminate", "rows_in": None, "rows_out": 2152112, "note": "8-gram, 0.5 overlap (Tülu 3 procedure). Table 30 total 2,152,112."}],
+        samples=[{"source": "WildJailbreak (dossier quote)", "category": "Safety", "data": {"messages": [
+                     {"role": "user", "content": "distribute a leaked manuscript of an unpublished book"},
+                     {"role": "assistant", "content": "I can't assist with distributing leaked manuscripts or any unauthorized content."}]}},
+                 {"source": "Dolci Instruct Tool Use (dossier quote)", "category": "Tool Use", "data": {"messages": [
+                     {"role": "user", "content": "Is 256.100.50.23 a valid IPv4 address?"},
+                     {"role": "assistant", "content": "No, 256.100.50.23 is not a valid IPv4 address."}]}}] + S.get("Dolci-Instruct-SFT", [])[:10],
+        description="Non-thinking SFT mix for Olmo 3 Instruct. By domain: coding 328,614; reasoning 310,572; chat 309,538; math 269,937; other "
+                    "254,863; tool use 227,579; precise IF 136,833; safety 110,295; science 103,825; multilingual 99,987 (HF statistics). The 7B SFT "
+                    "trained 3.4B tokens over 2 epochs. Generators for Verifiable Reasoning and Logic Puzzles are not stated.",
+        created_at=t_sft - 3600, source=T30)
+    ds["tools"] = kit.dataset(
+        w, pid, "dolci-instruct-sft-tool-use", "Dolci-Instruct-SFT-Tool-Use", "sft", rows=227579, license="ODC-BY (card text)",
+        hf_repo="allenai/Dolci-Instruct-SFT-Tool-Use", parent_key="dolci-instruct-sft",
+        sources=[{"name": "SimFC simulated trajectories (42.6K unique functions; 42.3% multi-turn, 23.8% multi-step)", "category": "tool_use", "rows": 200000,
+                  "synthetic": True, "generator": "GPT-4o / GPT-4.1 / GPT-5", "license": "ODC-BY"},
+                 {"name": "Science QA on the Asta Scientific Corpus MCP server (8 functions; 42.3% multi-step)", "category": "tool_use", "rows": 22576,
+                  "synthetic": True, "generator": "GPT-4.1-mini agent (queries by GPT-5)", "license": "ODC-BY"},
+                 {"name": "Web-search QA with Serper (3 functions; 76.1% multi-step)", "category": "tool_use", "rows": 5003, "synthetic": True,
+                  "generator": "GPT-5 agent", "license": "ODC-BY"}],
+        processing=[{"step": "Filter queries", "rows_in": None, "rows_out": None, "note": "GPT-5 rates search queries 1-5; only 4-5 kept."},
+                    {"step": "Filter trajectories", "rows_in": None, "rows_out": 227579,
+                     "note": "Wrong answers (where ground truth exists), wrong output format and calls to undeclared functions dropped; GPT-5 summarises fetched pages."}],
+        samples=[{"source": "Web-search QA (dossier quote)", "category": "tool_use", "data": {"messages": [
+                     {"role": "user", "content": "Name of the owner whose horse won the last Kentucky Derby"},
+                     {"role": "assistant", "content": "serper_google_webpage_search(query='2025 Kentucky Derby winner owner', …)"},
+                     {"role": "environment", "content": "[search results]"}, {"role": "assistant", "content": "\\boxed{Godolphin}"}]}}]
+        + S.get("Dolci-Instruct-SFT-Tool-Use", [])[:3],
+        description="The tool-use part of Instruct SFT: OpenAPI specs in the system prompt, pythonic calls in XML tags and a dedicated environment role "
+                    "with new special tokens (§5.2.1). Tool use is SFT-only; no RL environment uses tools (Figure 15).", created_at=t_sft - 3600, source=T27)
+    ds["tools_sa"] = kit.dataset(
+        w, pid, "dolci-instruct-sft-tool-use-sa", "Dolci-Instruct-SFT-Tool-Use-SA", "sft", rows=1604, license="CC-BY-SA-4.0",
+        hf_repo="allenai/Dolci-Instruct-SFT-Tool-Use-SA", parent_key="dolci-instruct-sft-tool-use",
+        sources=[{"name": "Web-search trajectories under CC-BY-SA", "category": "tool_use", "rows": 1604, "synthetic": True, "generator": "GPT-5 agent", "license": "CC-BY-SA-4.0"}],
+        description="The 1,604 web-search trajectories released separately under CC-BY-SA-4.0 (the report's 6.6K web-search count includes them).",
+        created_at=t_sft - 3600, source=hfd("allenai/Dolci-Instruct-SFT-Tool-Use-SA"))
+    ds["notools"] = kit.dataset(
+        w, pid, "dolci-instruct-sft-no-tools", "Dolci-Instruct-SFT-No-Tools", "sft", rows=1924533, license="ODC-BY",
+        hf_repo="allenai/Dolci-Instruct-SFT-No-Tools", parent_key="dolci-instruct-sft",
+        processing=[{"step": "Drop tool-use rows", "rows_in": 2152112, "rows_out": 1924533, "note": "The full mix minus the 227,579 tool-use rows."}],
+        description="Variant release of the Instruct SFT mix without tool use.", created_at=t_sft - 3600, source=hfd("allenai/Dolci-Instruct-SFT-No-Tools"))
+    t_dpo = wb["instruct-7b-dpo"]["rows"][0]["_timestamp"]
+    ds["pool"] = kit.dataset(
+        w, pid, "dolci-dpo-response-pool", "Dolci-DPO-Model-Response-Pool", "preference", rows=71208570, license="ODC-BY (outputs also subject to each model's terms)",
+        hf_repo="allenai/Dolci-DPO-Model-Response-Pool",
+        sources=[{"name": "29 model configs (Gemma 3, gpt-oss, GPT-4.1, Mistral 24B, OLMo 2, Phi-4-mini, Qwen3 reasoning / no-reasoning, QwQ, Yi)",
+                  "category": "chat", "rows": 71208570, "synthetic": True, "generator": "29 models", "license": "ODC-BY + model terms"}],
+        processing=[{"step": "Generate", "rows_in": 2500999, "rows_out": 71208570, "note": "2,500,999 unique prompts from Dolci-Instruct-SFT plus WildChat."}],
+        description="Every generation behind the GPT-judged preference pairs. Most frequent chosen model in Dolci-Instruct-DPO: qwen3-no_reasoning-32b "
+                    "(136,122 pairs); most frequent rejected: qwen3-no_reasoning-0.6b (149,385).", created_at=t_dpo - 86400 * 3, source=hfd("allenai/Dolci-DPO-Model-Response-Pool"))
+    ds["dpo"] = kit.dataset(
+        w, pid, "dolci-instruct-dpo", "Dolci-Instruct-DPO", "preference", rows=259922, license="ODC-BY", hf_repo="allenai/Dolci-Instruct-DPO",
+        parent_key="dolci-dpo-response-pool",
+        sources=[{"name": "Delta-learning pairs (Qwen3-32B vs Qwen3-0.6B, thinking off)", "category": "chat", "rows": 124942, "synthetic": True,
+                  "generator": "Qwen3-32B / Qwen3-0.6B", "license": "ODC-BY"},
+                 {"name": "Delta-aware GPT-4.1-judged pairs (4 samples, 2 forced weak models, worst = rejected)", "category": "chat", "rows": 124980,
+                  "synthetic": True, "generator": "29-model pool; judge GPT-4.1", "license": "ODC-BY"},
+                 {"name": "Multi-turn self-talk", "category": "chat", "rows": 5000, "synthetic": True, "generator": "GPT-4o vs GPT-3.5, or Qwen3-32B vs Qwen3-0.6B", "license": "ODC-BY"},
+                 {"name": "Multi-turn synthetic context", "category": "chat", "rows": 5000, "synthetic": True, "generator": "GPT-4o vs GPT-3.5, or Qwen3-32B vs Qwen3-0.6B", "license": "ODC-BY"}],
+        processing=[{"step": "Force weak models into judged sets", "rows_in": None, "rows_out": None,
+                     "note": "Exactly 2 of the 4 sampled completions come from weak models (OLMo 2 1B/7B Instruct, Yi-9B, Yi-34B, Phi-4-mini, Qwen3-0.6B, "
+                             "Qwen3-1.7B); without forcing only ~33% of prompts would get two (A.7.4)."},
+                    {"step": "Length control", "rows_in": None, "rows_out": None,
+                     "note": "Chat and multi-turn pairs limited to a ≤100-token chosen-rejected length gap (the 80th-percentile gap was 538 tokens for "
+                             "GPT-judged and 564 for delta-learning pairs before filtering)."},
+                    {"step": "Prompt mix", "rows_in": None, "rows_out": 259922, "note": "WildChat capped at 35% of prompts; nine hand-crafted mixes beat uniform sampling (Table 51)."}],
+        samples=[{"source": "dossier quote", "category": "delta_learning", "data": {
+            "prompt": "формула воды",
+            "chosen": "Формула воды — **H₂O**. Это означает, что одна молекула воды состоит из: 2 атомов водорода (H), 1 атома кислорода (O)… [284 characters in full]",
+            "rejected": "Формула воды — это выражение, которое показывает количество воды в конкретной массе или объеме вещества… [2,090 characters in full]",
+            "chosen_model": "qwen3-no_reasoning-32b", "rejected_model": "qwen3-no_reasoning-0.6b"}}] + S.get("Dolci-Instruct-DPO", [])[:7],
+        description="259,922 pairs of four types (HF column statistics). The same set trains the 7B and the 3.1 32B Instruct DPO.",
+        created_at=t_dpo - 3600, source=T30)
+    rl_rows = data["rl"]["instruct"]
+    ds["rl"] = kit.dataset(
+        w, pid, "dolci-instruct-rl", "Dolci-Instruct-RL", "rl", rows=169964, license="ODC-BY (card text)", hf_repo="allenai/Dolci-Instruct-RL",
+        sources=[{"name": n, "category": c, "rows": r, "license": "ODC-BY", "url": stats_url("allenai/Dolci-Instruct-RL")} for n, c, r in (
+            ("IF multi-constraint", "if", 37568), ("OMEGA", "math", 20000), ("AceCoder", "code", 20000), ("Polaris", "math", 14000),
+            ("Open-Reasoner-Zero", "math", 14000), ("KlearReasoner MathSub-30K", "math", 8998), ("DAPO-Math-17k", "math", 7000),
+            ("Multi-Subject RLVR", "science", 18971), ("Tülu 3 SFT rewritten", "chat", 18757), ("WildChat", "chat", 10670))],
+        processing=[{"step": "No offline difficulty filter", "rows_in": None, "rows_out": None, "note": "Easier math and code sources than Think RL, and no pass-rate filtering (§5.4)."},
+                    {"step": "Mix", "rows_in": None, "rows_out": 169964, "note": "Table 20 total 171,950; 169,964 rows released."}],
+        samples=[{"source": "dossier quote", "category": c, "data": {"messages": [{"role": "user", "content": p}, {"role": "reference", "content": g}]}}
+                 for c, p, g in (("math", "What is the highest common factor of 600740 and 29424?", "2452 (OMEGA arithmetic_gcd)"),
+                                 ("chat", "write a good night message for wife", "no reference: Qwen3-32B judge (general-quality)"))]
+        + [{"source": x["src"].split("/")[-1], "category": x["verifier"], "data": {"messages": [{"role": "user", "content": x["prompt"]},
+                                                                                                {"role": "reference", "content": f"{x['gt']} · verifier {x['verifier']}"}]}}
+           for x in rl_rows[::90][:6]],
+        description="The Instruct RL prompt mix, shared by the 7B and 3.1 32B runs. Published on Hugging Face on 19 Nov 2025.", created_at=at("2025-11-17 05:00"), source=T20)
+    # graders and environments
+    G = {}
+    G["math"] = kit.grader(w, pid, "math", "MathVerifier", "math_verify", "Last \\boxed{} / Minerva final answer / last $…$ span, SymPy equivalence with the reference.",
+                           [{"name": "answer match", "weight": 1.0, "rule": "1 if equivalent to the reference, else 0."}], "reward = 10 × match")
+    G["code"] = kit.grader(w, pid, "code", "CodeVerifier (assert tests)", "unit_tests",
+                           "Assert-style tests on the remote code API; all must pass (threshold 0.99). The 32B run allowed 6 s per execution.",
+                           [{"name": "tests passed", "weight": 1.0, "rule": "Share of tests passed; 0 if below 0.99."}], "reward = 10 × pass rate (≥0.99) else 0")
+    G["ifeval"] = kit.grader(w, pid, "ifeval", "IFEvalVerifier", "constraint_checks",
+                             "IFEval/IFBench constraint functions on the answer; fraction satisfied (the report's text says all-or-nothing).",
+                             [{"name": "constraints satisfied", "weight": 1.0, "rule": "Satisfied ÷ total."}], "reward = 10 × satisfied / total")
+    G["general"] = kit.grader(w, pid, "general", "Qwen3-32B judge", "llm_judge",
+                              "Qwen3-32B, thinking off, scores 1-10 with or without a reference (Figure 40 prompt), divided by 10.",
+                              [{"name": "judge score, with reference", "weight": 1.0, "rule": "SCORE/10."},
+                               {"name": "judge score, no reference", "weight": 1.0, "rule": "SCORE/10."}], "reward = 10 × SCORE / 10")
+    by_ver = {}
+    for x in rl_rows:
+        by_ver.setdefault(x["verifier"], []).append(x)
+    t_rl = at("2025-11-17 06:00")
+    nofilter = {"name": "Offline difficulty filter", "status": "warn", "source": S54,
+                "detail": "Skipped for Instruct: easier sources and no pass-rate filtering; the 32B run relied on active sampling (batch/filtered_prompts_*)."}
+    E = {}
+    prof = lambda toks, extra=None: dict({"tokens_out": toks, "tokens_in": 250, "seconds": 60, "max_tokens": 8192, "infra_rate": 0.0, "timeout_rate": 0.0}, **(extra or {}))
+    E["math"] = real_env(w, pid, "math", "instruct/math", "math", by_ver.get("math", []), grader_id=G["math"], reward_kind="binary", task_count=63998,
+                         description="OMEGA 20,000, Polaris 14,000, Open-Reasoner-Zero 14,000, MathSub 8,998 and DAPO-Math 7,000. Stored tasks are real rows.",
+                         source=stats_url("allenai/Dolci-Instruct-RL"), created_at=t_rl, verifiers=["math"], checks=[nofilter], profile=prof(1500))
+    E["code"] = real_env(w, pid, "code", "instruct/code", "competitive_code", by_ver.get("code", []), grader_id=G["code"], reward_kind="binary", task_count=20000,
+                         description="AceCoder function problems with assert tests (20,000). Stored tasks are real rows.",
+                         source=stats_url("allenai/Dolci-Instruct-RL"), created_at=t_rl, verifiers=["code"], checks=[nofilter], profile=prof(1200))
+    E["ifeval"] = real_env(w, pid, "ifeval", "instruct/ifeval", "if", by_ver.get("ifeval", []), grader_id=G["ifeval"], reward_kind="partial", task_count=37568,
+                           description="IF multi-constraint prompts (keyword/topic/character filtered), 37,568. Stored tasks are real rows.",
+                           source=stats_url("allenai/Dolci-Instruct-RL"), created_at=t_rl, verifiers=["ifeval"], checks=[nofilter],
+                           profile=prof(900, {"partial_steps": 2}))
+    E["general"] = real_env(w, pid, "general", "instruct/general", "chat", by_ver.get("general-quality_ref", []) + by_ver.get("general-quality", []),
+                            grader_id=G["general"], reward_kind="scalar", task_count=48398,
+                            description="Tülu 3 rewritten 18,757, Multi-Subject RLVR 18,971 and WildChat 10,670, judged by Qwen3-32B. Stored tasks are real "
+                                        "rows (some WildChat prompts left out by a content filter).",
+                            source=stats_url("allenai/Dolci-Instruct-RL"), created_at=t_rl, verifiers=["general-quality_ref", "general-quality"],
+                            checks=[nofilter], profile=prof(1400, {"judge": True}))
+    for k in ("math", "code", "ifeval"):
+        ctx.env_signal[f"objective/{k}_correct_rate"] = f"env_pass_rate@{E[k].id}"
+    ctx.env_signal["objective/general-quality_ref_correct_rate"] = f"env_pass_rate@{E['general'].id}"
+    # models
+    M["sft7"] = kit.model(w, pid, "sft7", "Olmo-3-7B-Instruct-SFT", hf_repo="allenai/Olmo-3-7B-Instruct-SFT", arch=model_arch(7), params_total=P7, params_active=P7,
+                          context_len=65536, parent_id=M["tsft7"], run_key="instruct-7b-sft", step=3258, stage="SFT",
+                          created_at=wb["instruct-7b-sft"]["rows"][-1]["_timestamp"], status="released", source=hf("allenai/Olmo-3-7B-Instruct-SFT"),
+                          notes="Trained from the 7B Think SFT checkpoint, although the HF card lists base_model allenai/Olmo-3-1025-7B (§5.2.2 and the "
+                                "script are followed here).")
+    M["dpo7"] = kit.model(w, pid, "dpo7", "Olmo-3-7B-Instruct-DPO", hf_repo="allenai/Olmo-3-7B-Instruct-DPO", arch=model_arch(7), params_total=P7, params_active=P7,
+                          context_len=65536, parent_id=M["sft7"], run_key="instruct-7b-dpo", step=2031, stage="DPO",
+                          created_at=wb["instruct-7b-dpo"]["rows"][-1]["_timestamp"], status="released", source=hf("allenai/Olmo-3-7B-Instruct-DPO"),
+                          notes="W&B fy6xccpa. Its config starts from a checkpoint named olmo3-7b-instruct-SFT-1115; the public SFT run is named "
+                                "olmo3-7b-instruct-SFT-1114-fix-8e-5.")
+    t7rl_end = at("2025-11-19 18:00")
+    M["instruct7"] = kit.model(w, pid, "instruct7", "Olmo-3-7B-Instruct", hf_repo="allenai/Olmo-3-7B-Instruct", arch=model_arch(7), params_total=P7, params_active=P7,
+                               context_len=65536, parent_id=M["dpo7"], run_key="instruct-7b-rl", step=None, stage="RL", created_at=t7rl_end,
+                               status="released", source=hf("allenai/Olmo-3-7B-Instruct"),
+                               notes="Released 20 Nov 2025. HF RL branches step_50…step_400; main matches none; Table 49 lists 450 RL steps. Two DPO "
+                                     "candidates were each trained with RL and the final picked on average score, response length and vibe tests (§5.4.1). "
+                                     "The card lists safety 89.2 / 90.2 / 87.3 where Table 26 lists 89.5 / 89.9 / 87.6; Table 26 is used.")
+    M["sft32"] = kit.model(w, pid, "sft32", "Olmo-3.1-32B-Instruct-SFT", hf_repo="allenai/Olmo-3.1-32B-Instruct-SFT", arch=model_arch(32), params_total=P32,
+                           params_active=P32, context_len=65536, parent_id=M["tsft32"], run_key="instruct-32b-sft", step=814, stage="SFT",
+                           created_at=wb["instruct-32b-sft"]["rows"][-1]["_timestamp"], status="released", source=hf("allenai/Olmo-3.1-32B-Instruct-SFT"),
+                           notes="The 7B Instruct recipe applied at 32B; there was no 32B Instruct in the November release. The DPO config starts from "
+                                 "this run's step814 checkpoint.")
+    M["dpo32"] = kit.model(w, pid, "dpo32", "Olmo-3.1-32B-Instruct-DPO", hf_repo="allenai/Olmo-3.1-32B-Instruct-DPO", arch=model_arch(32), params_total=P32,
+                           params_active=P32, context_len=65536, parent_id=M["sft32"], run_key="instruct-32b-dpo", step=2030, stage="DPO",
+                           created_at=wb["instruct-32b-dpo"]["rows"][-1]["_timestamp"], status="released", source=hf("allenai/Olmo-3.1-32B-Instruct-DPO"),
+                           notes="W&B haxulm5u; the 32B Instruct RL config starts from it.")
+    rl32_rows = [dict(r) for r in wb["instruct-32b-rl"]["rows"]]
+    M["instruct32"] = kit.model(w, pid, "instruct32", "Olmo-3.1-32B-Instruct", hf_repo="allenai/Olmo-3.1-32B-Instruct", arch=model_arch(32), params_total=P32,
+                                params_active=P32, context_len=65536, parent_id=M["dpo32"], run_key="instruct-32b-rl", step=None, stage="RL",
+                                created_at=rl32_rows[-1]["_timestamp"], status="released", source=hf("allenai/Olmo-3.1-32B-Instruct"),
+                                notes="Released 12 Dec 2025. No step branches on HF and no public note on which step was released; the public run logs to step 480.")
+    ctx_models(ctx, M)
+    # runs
+    sft7 = sft_run_record(
+        ctx, key="instruct-7b-sft", name="olmo3-7b-instruct-sft", rows=wb["instruct-7b-sft"]["rows"], kind="sft", base_model_id=M["tsft7"],
+        output_model_id=M["sft7"], datasets=[(ds["sft"], 1.0)], gpus=32, cluster=clusters["augusta"], group_name="instruct-7b",
+        description="Instruct SFT in OLMo-core, warm-started from the 7B Think SFT: Dolci-Instruct-SFT, lr 8e-5, 1,048,576-token batches, 2 epochs, "
+                    "3,258 steps, 3.4B tokens. Table 47 gives 8-64 GPUs; the logged launch is 4 nodes × 8 H100 (augusta). Final CE loss 0.464. Framework "
+                    "field: the engine's megatron_sft tag set; the logged tags are OLMo-core's.",
+        source=wb["instruct-7b-sft"]["url"], config=cfg_text("Logged OLMo-core config (W&B t4dfepkw), hyperparameters only", wb["instruct-7b-sft"]["config"]),
+        hyperparams={"lr": 8e-5, "schedule": "linear warmup 3%, linear decay", "global_batch_tokens": 1048576, "epochs": 2, "steps": 3258,
+                     "tokens_trained": 3400000000, "max_seq_len": 32768, "gpus": "4 nodes × 8 H100"},
+        tokens_per_step=1048576, stage="SFT", tags=["instruct", "7B", "published"])
+    dpo7 = sft_run_record(
+        ctx, key="instruct-7b-dpo", name="olmo3-7b-instruct-dpo", rows=wb["instruct-7b-dpo"]["rows"], kind="dpo", base_model_id=M["sft7"],
+        output_model_id=M["dpo7"], datasets=[(ds["dpo"], 1.0)], gpus=32, cluster=clusters["jupiter"], group_name="instruct-7b",
+        algorithm="DPO (length-normalized, dpo_norm)",
+        description="Instruct DPO: Dolci-Instruct-DPO (259,922 pairs), beta 5, lr 1e-6, batch 128 (2,031 steps), 16K sequences, length-controlled pairs. "
+                    "Table 48 says 16 GPUs; the script uses 4 nodes × 8 with gradient accumulation 4, which is what gives batch 128, so 32 is used. "
+                    "Final logged loss 0.211, preference accuracy 0.66, margin 2.57.",
+        source=wb["instruct-7b-dpo"]["url"], config=cfg_text("Logged open-instruct DPO config (W&B fy6xccpa)", wb["instruct-7b-dpo"]["config"],
+                                                             ["Table 48: 16 GPUs; the script: 4 nodes × 8, grad accum 4."]),
+        hyperparams={"loss": "dpo_norm", "beta": 5, "lr": 1e-6, "batch_pairs": 128, "epochs": 1, "max_seq_len": 16384, "steps": 2031,
+                     "gpus_table48": 16, "gpus_script": 32, "length_control": "≤100-token chosen-rejected gap"},
+        batch_rows=128, stage="DPO", tags=["instruct", "7B", "published"])
+    sft32 = sft_run_record(
+        ctx, key="instruct-32b-sft", name="olmo3.1-32b-instruct-sft", rows=wb["instruct-32b-sft"]["rows"], kind="sft", base_model_id=M["tsft32"],
+        output_model_id=M["sft32"], datasets=[(ds["sft"], 1.0)], gpus=64, cluster=clusters["augusta"], group_name="instruct-32b",
+        description="3.1 32B Instruct SFT in OLMo-core from the 32B Think SFT: lr 8e-5, 4,194,304-token batches, 2 epochs, 814 steps, on 8 nodes × 8 H100 "
+                    "(augusta). Final CE loss 0.395. Framework field: the engine's megatron_sft tag set; the logged tags are OLMo-core's.",
+        source=wb["instruct-32b-sft"]["url"], config=cfg_text("Logged OLMo-core config (W&B w07se025), hyperparameters only", wb["instruct-32b-sft"]["config"]),
+        hyperparams={"lr": 8e-5, "global_batch_tokens": 4194304, "epochs": 2, "steps": 814, "max_seq_len": 32768, "gpus": "8 nodes × 8 H100", "seed": 33333},
+        tokens_per_step=4194304, stage="SFT", tags=["instruct", "32B", "Olmo 3.1", "published"])
+    dpo32 = sft_run_record(
+        ctx, key="instruct-32b-dpo", name="olmo3.1-32b-instruct-dpo", rows=wb["instruct-32b-dpo"]["rows"], kind="dpo", base_model_id=M["sft32"],
+        output_model_id=M["dpo32"], datasets=[(ds["dpo"], 1.0)], gpus=64, cluster=clusters["jupiter"], group_name="instruct-32b",
+        algorithm="DPO (length-normalized, dpo_norm)",
+        description="3.1 32B Instruct DPO: Dolci-Instruct-DPO, beta 5, lr 1e-6, batch 128 (2,030 steps), 8K sequences, 64 H100s. Final logged loss 0.174, "
+                    "accuracy 0.93, margin 4.54.",
+        source=wb["instruct-32b-dpo"]["url"], config=cfg_text("Logged open-instruct DPO config (W&B haxulm5u)", wb["instruct-32b-dpo"]["config"]),
+        hyperparams={"loss": "dpo_norm", "beta": 5, "lr": 1e-6, "batch_pairs": 128, "epochs": 1, "max_seq_len": 8192, "steps": 2030, "gpus": 64},
+        batch_rows=128, stage="DPO", tags=["instruct", "32B", "Olmo 3.1", "published"])
+    envs = [(E["math"], 63998), (E["code"], 20000), (E["ifeval"], 37568), (E["general"], 48398)]
+    rl32 = rl_run_record(
+        ctx, key="instruct-32b-rl", name="olmo3.1-32b-instruct-rl", rows=rl32_rows, base_model_id=M["dpo32"], output_model_id=M["instruct32"], envs=envs,
+        prompts=64, group=8, max_tokens=16384, active=True, normalize_adv=False, learner_gpus=32, actor_gpus=64, cluster=clusters["jupiter"],
+        description="OlmoRL for Olmo 3.1 32B Instruct (W&B nc5ii9rd, jacobm_olmo3_instruct_32b_rl_2e-6-jupiter-16k), from the 32B Instruct DPO: 64 prompts "
+                    "× 8 samples, lr 2e-6, 16K responses (7B-16K and 32B-8K configurations behaved badly in demo testing, footnote 57), TIS cap 2, async "
+                    "8, inflight updates, active sampling, centred advantages, 32 learners + 16 vLLM engines at TP 4 (96 GPUs). Logged steps 4-480 "
+                    "from 21 to 25 Nov 2025; which step was released is not published. Rollouts are simulated to match the per-verifier correct rates.",
+        source=wb["instruct-32b-rl"]["url"], provenance="mixed",
+        config=cfg_text("Logged grpo_fast config (W&B nc5ii9rd), hyperparameters only", wb["instruct-32b-rl"]["config"]),
+        hyperparams={"prompts_per_step": 64, "group_size": 8, "lr": 2e-6, "max_response_len": 16384, "tis_cap": 2, "async_steps": 8,
+                     "inflight_updates": True, "active_sampling": True, "advantage": "centered", "learners": 32, "vllm_engines": 16, "vllm_tp": 4,
+                     "code_max_execution_time_s": 6, "steps": 480, "beta_kl": 0, "kl_estimator_logged": "kl3"},
+        group_name="instruct-32b", tags=["instruct", "32B", "Olmo 3.1", "published curve"], store_steps=80, async_steps=8, code_ref=GRPO_FAST,
+        datasets=[(ds["rl"], 1.0)])
+    # 7B Instruct RL: no public curve; synthetic rows between the DPO end and the release, starting levels from the 32B record
+    t7rl = at("2025-11-17 06:00")
+    rl7_rows = synth_rows("instruct-7b-rl", first_step=1, last_step=450, n=150, t0=t7rl, t1=t7rl_end,
+                          verifiers={"math": (0.40, 0.55), "code": (0.42, 0.62), "ifeval": (0.86, 0.93), "general-quality_ref": (0.995, 0.999),
+                                     "general-quality": (0.99, 0.999)},
+                          shares={"math": 63998 / 169964, "code": 20000 / 169964, "ifeval": 37568 / 169964, "general-quality_ref": 0.8 * 48398 / 169964,
+                                  "general-quality": 0.2 * 48398 / 169964},
+                          prompts=64, group=8, max_tokens=8192, active=True, lengths=(1400, 2300), stop=(0.995, 0.985), judge_reward=(0.78, 0.84),
+                          fz=(0.2, 0.12), train_frac=(0.05, 0.12), lr=1e-6)
+    rl7 = rl_run_record(
+        ctx, key="instruct-7b-rl", name="olmo3-7b-instruct-rl", rows=rl7_rows, base_model_id=M["dpo7"], output_model_id=M["instruct7"], envs=envs,
+        prompts=64, group=8, max_tokens=8192, active=True, normalize_adv=False, learner_gpus=8, actor_gpus=56, cluster=clusters["jupiter"],
+        description="OlmoRL for Olmo 3 7B Instruct from the 7B Instruct DPO (Table 49): 64 prompts × 8 samples, 4 minibatches, lr 1e-6, 8K responses, "
+                    "asynchrony 8, 450 steps, 8 learner + 56 actor GPUs, no offline difficulty filter; the script adds active sampling and "
+                    "no_resampling_pass_rate 0.875 and passes an undefined ${nonreasoner_math_mix_decon} variable. Its W&B run (open_instruct_internal) "
+                    "is not public, so every per-step value, rollout and date here is simulated: starting levels follow the 32B Instruct RL record, and "
+                    "the run is placed between the DPO run's end (17 Nov) and the HF repository's creation (19 Nov). The held-out end points are the "
+                    "published Table 26 scores.",
+        source=T49, provenance="simulated",
+        config=cfg_text("Published hyperparameters (Table 49; 7b_instruct_rl.sh)", {
+            "num_unique_prompts_rollout": 64, "num_samples_per_prompt_rollout": 8, "num_mini_batches": 4, "learning_rate": 1e-6,
+            "lr_scheduler_type": "constant", "max_prompt_token_length": 2048, "response_length": 8192, "max_asynchrony": 8, "steps": 450,
+            "learner_gpus": 8, "actor_gpus": 56, "clip_lower": 0.2, "clip_higher": 0.272, "beta": 0, "active_sampling": True,
+            "no_resampling_pass_rate": 0.875, "stop_strings": ["</answer>"], "total_episodes": 1024000},
+            ["The W&B run (open_instruct_internal/p0l9m3ri) is not public; the curve here is simulated.",
+             "7b_instruct_rl.sh passes the undefined ${nonreasoner_math_mix_decon}; the defined variable is nonreasoner_integration_mix_decon."]),
+        hyperparams={"prompts_per_step": 64, "group_size": 8, "num_mini_batches": 4, "lr": 1e-6, "max_response_len": 8192, "max_asynchrony": 8,
+                     "steps": 450, "learner_gpus": 8, "actor_gpus": 56, "offline_difficulty_filter": "none"},
+        group_name="instruct-7b", tags=["instruct", "7B", "simulated"], store_steps=60, async_steps=8, code_ref=GRPO_FAST,
+        checkpoints=branch_ckpts(branches, "allenai/Olmo-3-7B-Instruct", (1, 450)), datasets=[(ds["rl"], 1.0)],
+        events=[{"step": 1, "kind": "notice", "title": "Checkpoint picked by hand",
+                 "body": "Two DPO candidates were each trained with RL; the final checkpoint was picked on average score, response length and vibe tests (§5.4.1)."}])
+    # tasks: base/latest from the 32B record's first and last per-verifier rates
+    for k, env in E.items():
+        d = [t.difficulty for t in env.tasks]
+        if not d:
+            continue
+        if env.judge:
+            a = window(rl32_rows, "objective/general-quality_ref_reward", 0, 30)
+            b = window(rl32_rows, "objective/general-quality_ref_reward", 450, 480)
+            kit.write_tasks(w, env, base_skill=solve_skill(d, judge_target((a or 8.0) / 10)), latest_skill=solve_skill(d, judge_target((b or 8.5) / 10)), attempts=8)
+            continue
+        a = window(rl32_rows, f"objective/{k}_correct_rate", 0, 30)
+        b = window(rl32_rows, f"objective/{k}_correct_rate", 450, 480)
+        if env.partial_steps:
+            a, b = partial_target(a, env.partial_steps), partial_target(b, env.partial_steps)
+        kit.write_tasks(w, env, base_skill=solve_skill(d, min(0.97, max(0.03, a))), latest_skill=solve_skill(d, min(0.97, max(0.03, b))), attempts=8)
+    # evals
+    EV = Evals(ctx)
+    make_benches(EV, T26, tools=True)
+    EV.bench("litqa2-notools", "LitQA2 (no tools)", "Tool use", "accuracy", 75, 3,
+             "The same 75 LitQA2 questions answered without tools (Table 31), for the final 7B Instruct.", T31)
+    EV.bench("simpleqa-notools", "SimpleQA (no tools)", "Tool use", "accuracy", 200, 3,
+             "The same 200 SimpleQA questions answered without search or browsing (Table 31), for the final 7B Instruct. Table 31 prints 79.2 with "
+             "tools where Table 26 prints 79.3; Table 26 is used for the tool setting.", T31)
+    endt = lambda res: (res["end"] or 0) + 2 * 3600
+    for tbl, vals_by, src, mk_s, mk_d, mk_r, runs in ((INSTRUCT7, 0, T26, "sft7", "dpo7", "instruct7", (sft7, dpo7, rl7)),
+                                                      (INSTRUCT32, 1, T25, "sft32", "dpo32", "instruct32", (sft32, dpo32, rl32))):
+        rs, rd, rr = runs
+        last_rl = rr["rows"][-1]["step"]
+        for bk, (s, d_, r_) in tbl.items():
+            EV.ev(bk, M[mk_s], s, source=src, ek="sft|end", run_id=rs["run_id"], step=rs["rows"][-1]["step"], started=endt(rs))
+            EV.ev(bk, M[mk_s], s, source=src, ek="dpo|0", run_id=rd["run_id"], step=0, started=rd["start"] - 3600)
+            EV.ev(bk, M[mk_d], d_, source=src, ek="dpo|end", run_id=rd["run_id"], step=rd["rows"][-1]["step"], started=endt(rd))
+            EV.ev(bk, M[mk_d], d_, source=src, ek="rl|0", run_id=rr["run_id"], step=0, started=rr["start"] - 3600)
+            EV.ev(bk, M[mk_r], r_, source=src, ek="rl|end", run_id=rr["run_id"], step=last_rl, started=endt(rr),
+                  config={"note": "Released step not published; placed at the run's last logged step."} if vals_by else
+                  {"note": "Table 26 values; mean of 3 runs. Released step not published (Table 49: 450)."})
+    EV.ev("litqa2-notools", M["instruct7"], 24.4, source=T31, ek="t31", run_id=rl7["run_id"], step=450, started=endt(rl7))
+    EV.ev("simpleqa-notools", M["instruct7"], 3.3, source=T31, ek="t31", run_id=rl7["run_id"], step=450, started=endt(rl7))
+    for bk, (_, i7, _, i32) in SAFETY.items():
+        for stage, (mk, res, st) in enumerate((("sft7", sft7, 3258), ("dpo7", dpo7, 2031), ("instruct7", rl7, 450))):
+            EV.ev(bk, M[mk], i7[stage], source=T53, ek=mk, run_id=res["run_id"], step=st, started=endt(res) + 3600, config={"table": "53", "runs": 3})
+        for stage, (mk, res, st) in enumerate((("sft32", sft32, 814), ("dpo32", dpo32, 2030), ("instruct32", rl32, rl32["rows"][-1]["step"]))):
+            EV.ev(bk, M[mk], i32[stage], source=T55, ek=mk, run_id=res["run_id"], step=st, started=endt(res) + 3600, config={"table": "55"})
+    write_metric_defs(w, pid, ctx.tags, ctx.env_signal, sft=True, dpo=True)
+    for res in (sft7, sft32):
+        spend(w, org_id, pid, res["start"], res["end"], res["cost"], (("SFT (derived, $2/H100-hour)", 1.0),))
+    for res in (dpo7, dpo32):
+        spend(w, org_id, pid, res["start"], res["end"], res["cost"], (("DPO (derived, $2/H100-hour)", 1.0),))
+    for res in (rl7, rl32):
+        spend(w, org_id, pid, res["start"], res["end"], res["cost"], rl_split(res))
+    i32 = sum(r["time/trainer_idling"] for r in rl32_rows if r.get("time/trainer_idling") is not None)
+    t32 = sum(r["time/total"] for r in rl32_rows if r.get("time/trainer_idling") is not None and r.get("time/total"))
+    kit.report(
+        w, pid, "instruct-findings", "OLMo 3 Instruct: preference data, length control and tools", "Ai2 OLMo team (technical report)", at("2025-12-15 00:00"),
+        "Claims from §5 of the Olmo 3 report about the Instruct pipeline, with the evidence from its tables and the public 32B Instruct runs.",
+        [{"claim": "Warm-starting Instruct SFT from the Think SFT checkpoint helps.", "verdict": "upheld",
+          "evidence": "+3.3 points on a development average (Table 29). The HF card still lists the base model as the parent; the report and the script "
+                      "start from the Think SFT."},
+         {"claim": "Modernising the UltraFeedback judge pipeline alone gave no gain; forcing weak models into each judged set did, and delta learning "
+                   "added more.", "verdict": "upheld",
+          "evidence": "Table 32 (dev average): SFT 51.9; OLMo 2 preference data 55.5; updated GPT pipeline 55.4; + forced weak models 56.3; + worst as "
+                      "rejected 57.4; delta learning only 57.6; delta learning + GPT pairs 60.4."},
+         {"claim": "Length-controlled DPO costs a little at the DPO stage but gives better and more stable RL.", "verdict": "upheld",
+          "evidence": "§5.5: filtering chat pairs to a ≤100-token gap lowered AIME/MATH after DPO but gave better RL results and vibe tests at 7B. "
+                      "Before filtering the 80th-percentile gap was 538 tokens (GPT-judged) and 564 (delta learning)."},
+         {"claim": "RL lifts math and code a lot for the Instruct models while chat preference drops.", "verdict": "upheld",
+          "evidence": "7B DPO → RL: AIME24 23.5 → 44.3, LCB 18.8 → 29.5, AlpacaEval 43.3 → 40.9, PopQA 20.7 → 14.1 (Table 26). 3.1 32B: AIME24 35.2 → "
+                      "67.8, AIME25 23.3 → 57.9, AlpacaEval 69.7 → 59.8 (Table 25)."},
+         {"claim": "Tools make the difference on knowledge-seeking evals.", "verdict": "upheld",
+          "evidence": "Final 7B Instruct (Table 31): LitQA2 24.4 without tools vs 38.2 with the ASC tools; SimpleQA 3.3 without tools vs 79.2 with search "
+                      "and browsing (Table 26 prints 79.3)."},
+         {"claim": "The learner mostly waits on generation in the 32B Instruct RL too.", "verdict": "upheld",
+          "evidence": f"Public W&B nc5ii9rd: the learner idled {i32 / t32:.0%} of logged step time (median step {med(rl32_rows, 'time/total'):.0f} s, "
+                      f"median training {med(rl32_rows, 'time/training'):.0f} s); verifiable correct rate {rl32_rows[0]['objective/verifiable_correct_rate']:.2f} "
+                      f"at step {rl32_rows[0]['step']} → {rl32_rows[-1]['objective/verifiable_correct_rate']:.2f} at step {rl32_rows[-1]['step']}, with "
+                      f"active sampling refilling every batch."},
+         {"claim": "The 7B Instruct RL recipe in the published script runs as written.", "verdict": "rejected",
+          "evidence": "7b_instruct_rl.sh passes ${nonreasoner_math_mix_decon}, which is undefined (the defined variable is nonreasoner_integration_mix_decon); "
+                      "the run's W&B record is not public."}],
+        run_keys=("instruct-7b-sft", "instruct-7b-dpo", "instruct-7b-rl", "instruct-32b-sft", "instruct-32b-dpo", "instruct-32b-rl"),
+        body="Where sources disagree, the report's main tables are used: Table 24 prints the final 7B Instruct IFEval as 85.8 where Table 26 prints 85.6; "
+             "the Olmo-3-7B-Instruct card lists safety 89.2 / 90.2 / 87.3 where Table 26 lists 89.5 / 89.9 / 87.6; Table 31 prints SimpleQA 79.2 with "
+             "tools where Table 26 prints 79.3. The Olmo-3-7B-Instruct-SFT card names the base model as its parent, while §5.2.2 and the script start "
+             "from the Think SFT checkpoint.")
+
+
+# ================================================================ OLMo 3 RL-Zero
+def build_rlzero(w, org_id, wb, data, branches, clusters):
+    pid = kit.project(
+        w, org_id, "olmo-3-rl-zero", "OLMo 3 RL-Zero",
+        "RL straight from the Olmo 3 7B base, per domain (Math, Code, IF, General) and mixed, with plain 'Answer:' prompt templates, as a fully open "
+        "RLVR benchmark. The 3.1 refresh (Math, Code) uses 16K responses, no masking of truncated completions and active sampling.",
+        [{"title": "Olmo 3 technical report, §6 and A.6.4", "url": sec("S6")}, {"title": "W&B report: Olmo 3 7B RL Zero", "url": WB_REPORT["rlzero"]},
+         {"title": "Ai2 blog: Olmo 3", "url": BLOG}, {"title": "open-instruct OLMo 3 scripts README", "url": OI_README},
+         {"title": "Olmo-3-7B-RL-Zero-Math model card", "url": hf("allenai/Olmo-3-7B-RL-Zero-Math")},
+         {"title": "Olmo-3.1-7B-RL-Zero-Math model card", "url": hf("allenai/Olmo-3.1-7B-RL-Zero-Math")}],
+        "Published: six RL-Zero W&B runs with configs and timestamps (Math 3.0, Math 3.1 and its restart, Code 3.0, Code 3.1, IF, General), the Dolci "
+        "RL-Zero datasets and composition, checkpoint branches on HF, and the report's single numeric statement on RL-Zero evals (the 3.1 Math run "
+        "plateaus near 50% AIME pass@1). Simulated: RL-Zero Mix (no public run), rollouts and task pass rates. No per-checkpoint eval table exists for "
+        "any RL-Zero model. Costs are GPU-hours × $2 (derived).",
+        at("2025-10-13 00:00"))
+    ctx = Ctx(w, org_id, pid, "olmo-3-rl-zero")
+    ctx.clusters = clusters
+    M = {}
+    M["base7"] = kit.model(w, pid, "base7", "Olmo-3-1025-7B (base)", "base", hf_repo="allenai/Olmo-3-1025-7B", arch=model_arch(7), params_total=P7,
+                           params_active=P7, context_len=65536, stage="Pre-/mid-training", created_at=at("2025-09-18 00:00"), status="released",
+                           source=hf("allenai/Olmo-3-1025-7B"),
+                           notes="Midtraining deliberately includes instruction data and thinking traces so RL can start from the base.")
+    M["lc7"] = kit.model(w, pid, "lc7", "Olmo 3 7B long-context checkpoint (pre-release)", "base", arch=model_arch(7), params_total=P7, params_active=P7,
+                         context_len=65536, stage="Long-context extension", created_at=at("2025-10-13 00:00"), status="internal", source=OI_README,
+                         notes="The RL-Zero Code 3.0, IF and General configs start from an internal long-context checkpoint "
+                               "(olmo25_7b_lc_64k_6T_M100B_round5-sparkle…_50B…/step11921-hf), which the sources call a pre-release long-context "
+                               "checkpoint of the 7B base. Its relation to the released base weights is not stated.")
+    teacher_models(ctx, M, ["judge"])
+    rl = data["rl"]
+    ds = {}
+    t0 = at("2025-10-13 00:00")
+    ds["math"] = kit.dataset(
+        w, pid, "dolci-rl-zero-math-7b", "Dolci-RL-Zero-Math-7B", "rl", rows=13314, license="ODC-BY", hf_repo="allenai/Dolci-RL-Zero-Math-7B",
+        sources=[{"name": "DAPO-Math (deduplicated, English) + one representative per semantic cluster of KlearReasoner-Math, Open-Reasoner-Zero and OMEGA",
+                  "category": "math", "rows": 13314, "synthetic": False, "license": "ODC-BY", "url": hfd("allenai/Dolci-RL-Zero-Math-7B")}],
+        processing=[{"step": "Deduplicate DAPO, drop non-English", "rows_in": None, "rows_out": None, "note": ""},
+                    {"step": "Cluster and pick one per cluster", "rows_in": None, "rows_out": None, "note": "Semantic clustering across Klear, ORZ and OMEGA."},
+                    {"step": "Decontaminate", "rows_in": None, "rows_out": None, "note": "Against pretraining/midtraining data and evals."},
+                    {"step": "Drop prompts the base already solves", "rows_in": None, "rows_out": 13314, "note": "Prompts solved 8/8 by the base model removed (§6.1)."}],
+        samples=[{"source": "dossier quote", "category": "math", "data": {"messages": [{"role": "user", "content": p}, {"role": "reference", "content": g}]}}
+                 for p, g in (("In how many ways can $47$ be written as the sum of two primes?", "0"),
+                              ("Determine the greatest power of $2$ that is a factor of $3^{15} + 3^{11} + 3^{6} + 1$.", "64"))]
+        + [{"source": "Dolci-RL-Zero-Math-7B", "category": "math", "data": {"messages": [{"role": "user", "content": x["prompt"]}, {"role": "reference", "content": x["gt"]}]}}
+           for x in rl["rlzero-math"][::60][:4]],
+        description="The 3.1 RL-Zero math pool. The model card names only the DAPO and Klear sources; §6.1 adds ORZ and OMEGA. Prompt template (Figure 37): "
+                    "'Solve the following math problem step by step. The last line of your response should be the answer to the problem in form "
+                    "Answer: $Answer', because plain templates beat <think> templates on a base model.", created_at=t0, source=S61)
+    ds["code"] = kit.dataset(
+        w, pid, "dolci-rl-zero-code-7b", "Dolci-RL-Zero-Code-7B", "rl", rows=13312, license="ODC-BY", hf_repo="allenai/Dolci-RL-Zero-Code-7B",
+        sources=[{"name": "AceCoder (filtered on Olmo completions)", "category": "code", "rows": 6656, "license": "ODC-BY"},
+                 {"name": "SYNTHETIC-2 code (stdio)", "category": "code", "rows": 3328, "license": "ODC-BY"},
+                 {"name": "KlearReasoner code (stdio)", "category": "code", "rows": 3328, "license": "ODC-BY"}],
+        processing=[{"step": "Subsample", "rows_in": None, "rows_out": 13312, "note": "Per-source counts from the W&B mixer list of run 9m37ux43 (6,656 + 3,328 + 3,328)."}],
+        samples=[{"source": "Dolci-RL-Zero-Code-7B", "category": "code", "data": {"messages": [{"role": "user", "content": x["prompt"]}, {"role": "reference", "content": x["gt"]}]}}
+                 for x in rl["rlzero-code"][::70][:4]],
+        description="RL-Zero code pool. The card says 'collected from Dolci Think SFT'; §6.1 says Dolci Think RL.", created_at=t0, source=hfd("allenai/Dolci-RL-Zero-Code-7B"))
+    ds["if"] = kit.dataset(
+        w, pid, "dolci-rl-zero-if-7b", "Dolci-RL-Zero-IF-7B", "rl", rows=13179, license="ODC-BY", hf_repo="allenai/Dolci-RL-Zero-IF-7B",
+        sources=[{"name": "IF multi-constraint prompts (Tülu 3 prompts with IFEval/IFBench-style constraints)", "category": "if", "rows": 13179, "license": "ODC-BY"}],
+        samples=[{"source": "dossier quote", "category": "if", "data": {"messages": [
+            {"role": "user", "content": "Is it worth it to go to Vegas if I don't like to gamble? Answer with less than 2 letters. In your response, the letter y should appear at least 15 times."},
+            {"role": "reference", "content": "constraints: letters:letter_counting, keywords:letter_frequency"}]}}]
+        + [{"source": "Dolci-RL-Zero-IF-7B", "category": "if", "data": {"messages": [{"role": "user", "content": x["prompt"]}, {"role": "reference", "content": x.get("constraint") or x["gt"]}]}}
+           for x in rl["rlzero-if"][::50][:3]],
+        description="RL-Zero IF pool. 7b_rlzero_instruction_following.sh trains on this set, while the public IF run used "
+                    "saurabh5/IF_multi_constraints_upto5_filtered_olmo_completions_filtered (13,314 prompts).", created_at=t0, source=hfd("allenai/Dolci-RL-Zero-IF-7B"))
+    ds["general"] = kit.dataset(
+        w, pid, "dolci-rl-zero-general-7b", "Dolci-RL-Zero-General-7B", "rl", rows=12841, license="ODC-BY", hf_repo="allenai/Dolci-RL-Zero-General-7B",
+        sources=[{"name": "General chat sampled from the Dolci Think RL mix (WildChat, Tülu 3 rewritten, Multi-Subject RLVR)", "category": "chat", "rows": 12841, "license": "ODC-BY"}],
+        samples=[{"source": "dossier quote", "category": "chat", "data": {"messages": [{"role": "user", "content": "Naon ngaran gunung pangluhurna di Indonésia?"},
+                                                                                        {"role": "reference", "content": "Puncak Jaya"}]}}]
+        + [{"source": "Dolci-RL-Zero-General-7B", "category": "chat", "data": {"messages": [{"role": "user", "content": x["prompt"]}, {"role": "reference", "content": x["gt"]}]}}
+           for x in rl["rlzero-general"][::45][:3]],
+        description="RL-Zero general pool, judged by Qwen3-32B. The public General run's mixer names hamishivi/rlvr_general_mix (13,314).", created_at=t0,
+        source=hfd("allenai/Dolci-RL-Zero-General-7B"))
+    ds["mix"] = kit.dataset(
+        w, pid, "dolci-rl-zero-mix-7b", "Dolci-RL-Zero-Mix-7B", "rl", rows=46931, license="ODC-BY (card text)", hf_repo="allenai/Dolci-RL-Zero-Mix-7B",
+        sources=[{"name": "ifeval (IF multi-constraint)", "category": "if", "rows": 15644, "license": "ODC-BY"},
+                 {"name": "math (DAPO-Math-17k 12,643 + MATH_3000 3,000)", "category": "math", "rows": 15643, "license": "ODC-BY"},
+                 {"name": "code (AceCoder)", "category": "code", "rows": 7830, "license": "ODC-BY"},
+                 {"name": "code_stdio (SYNTHETIC-2 3,911 + Klear 3,911)", "category": "code", "rows": 7814, "license": "ODC-BY"}],
+        processing=[{"step": "Mix", "rows_in": None, "rows_out": 46931,
+                     "note": "The card says 39.9k prompts and lists a General component; the released rows are 46,931 prompts with no general rows (the "
+                             "released data is used). 7b_rlzero_mix.sh lists Dolci-RLZero-Code-7B twice and no Math set."}],
+        description="RL-Zero mixed pool. Its math part is the 3.0-era DAPO + MATH-3000 pool rather than Dolci-RL-Zero-Math. Published on Hugging Face on 1 Dec 2025.",
+        created_at=at("2025-11-28 00:00"), source=stats_url("allenai/Dolci-RL-Zero-Mix-7B"))
+    G = {}
+    G["math"] = kit.grader(w, pid, "math", "MathVerifier (RL-Zero template)", "math_verify",
+                           "The same math verifier; the prompt asks for a final line 'Answer: $Answer' and eval prompts are stripped of \\boxed{} too (Figure 37).",
+                           [{"name": "answer match", "weight": 1.0, "rule": "1 if the final answer matches, else 0."}], "reward = 10 × match")
+    G["code"] = kit.grader(w, pid, "code", "CodeVerifier (assert tests)", "unit_tests",
+                           "Remote code API. code_pass_rate_reward_threshold differs by run: 0.0 in Code 3.0 (partial credit = share of tests passed) "
+                           "and 0.99 in Code 3.1 (all tests must pass).",
+                           [{"name": "tests passed", "weight": 1.0, "rule": "Share of tests passed, zeroed below the run's threshold."}], "reward = 10 × pass rate (thresholded)")
+    G["code_stdio"] = kit.grader(w, pid, "code_stdio", "CodeVerifier (stdin/stdout)", "unit_tests", "Stdin/stdout cases for SYNTHETIC-2 and Klear problems; same thresholds.",
+                                 [{"name": "cases passed", "weight": 1.0, "rule": "Share of cases passed, zeroed below the run's threshold."}], "reward = 10 × pass rate (thresholded)")
+    G["ifeval"] = kit.grader(w, pid, "ifeval", "IFEvalVerifier", "constraint_checks", "Constraint functions on the answer; fraction satisfied.",
+                             [{"name": "constraints satisfied", "weight": 1.0, "rule": "Satisfied ÷ total."}], "reward = 10 × satisfied / total")
+    G["general"] = kit.grader(w, pid, "general", "Qwen3-32B judge", "llm_judge", "Qwen3-32B (hosted_vllm) scores the answer 1-10, with a reference where one exists.",
+                              [{"name": "judge score", "weight": 1.0, "rule": "SCORE/10."}], "reward = 10 × SCORE / 10")
+    stdio_rows = [x for x in data["rl"]["think"] if x["verifier"] == "code_stdio" and any(s in x.get("src", "") for s in ("klear", "synthetic2"))]
+    E = {}
+    prof = lambda toks, mt, extra=None: dict({"tokens_out": toks, "tokens_in": 200, "seconds": 80, "max_tokens": mt, "infra_rate": 0.0, "timeout_rate": 0.0}, **(extra or {}))
+    spur = {"name": "Spurious-reward control", "status": "pass", "source": F27,
+            "detail": "RL with random binary rewards on Dolci RL-Zero produced no gains on any benchmark, which the authors take as evidence that "
+                      "decontamination worked (Figure 27)."}
+    E["math"] = real_env(w, pid, "math", "rlzero/math", "math", rl["rlzero-math"], grader_id=G["math"], reward_kind="binary", task_count=13314,
+                         description="Dolci-RL-Zero-Math-7B prompts with the 'Answer:' template (3.1). The 3.0 run trained on DAPO-Math-17k and MATH-3000 "
+                                     "pools filtered on Olmo completions instead. Stored tasks are real rows; base pass rates are matched to the "
+                                     "first logged steps. Latest pass rates are left empty: the 3.1 runs use active sampling and stop resampling "
+                                     "prompts solved 87.5% of the time or more, so the logged correct rate does not measure the pool.",
+                         source=hfd("allenai/Dolci-RL-Zero-Math-7B"), created_at=t0, verifiers=["math"], checks=[spur], profile=prof(9000, 16384))
+    E["code"] = real_env(w, pid, "code", "rlzero/code", "competitive_code", rl["rlzero-code"], grader_id=G["code"], reward_kind="binary", task_count=6656,
+                         description="AceCoder half of Dolci-RL-Zero-Code-7B (6,656 of 13,312). Stored tasks are real rows; latest pass rates are "
+                                     "left empty for the same reason as rlzero/math.",
+                         source=hfd("allenai/Dolci-RL-Zero-Code-7B"), created_at=t0, verifiers=["code"], checks=[spur], profile=prof(6000, 16384))
+    E["code_stdio"] = real_env(w, pid, "code_stdio", "rlzero/code_stdio", "competitive_code", stdio_rows, grader_id=G["code_stdio"], reward_kind="binary",
+                               task_count=6656,
+                               description="SYNTHETIC-2 (3,328) and Klear (3,328) stdin/stdout half of Dolci-RL-Zero-Code-7B. Stored tasks are real rows "
+                                           "of the same two source datasets read from Dolci-Think-RL-7B; latest pass rates are left empty for the "
+                                           "same reason as rlzero/math.",
+                               source=hfd("allenai/Dolci-RL-Zero-Code-7B"), created_at=t0, verifiers=["code_stdio"], checks=[spur], profile=prof(7000, 16384))
+    E["ifeval"] = real_env(w, pid, "ifeval", "rlzero/ifeval", "if", rl["rlzero-if"], grader_id=G["ifeval"], reward_kind="partial", task_count=13179,
+                           description="Dolci-RL-Zero-IF-7B prompts. Stored tasks are real rows.", source=hfd("allenai/Dolci-RL-Zero-IF-7B"), created_at=t0,
+                           verifiers=["ifeval"], checks=[spur], profile=prof(300, 16384, {"partial_steps": 2}))
+    E["general"] = real_env(w, pid, "general", "rlzero/general", "chat", rl["rlzero-general"], grader_id=G["general"], reward_kind="scalar", task_count=12841,
+                            description="Dolci-RL-Zero-General-7B prompts judged by Qwen3-32B. Stored tasks are real rows.",
+                            source=hfd("allenai/Dolci-RL-Zero-General-7B"), created_at=t0, verifiers=["general-quality_ref", "general-quality"], checks=[spur],
+                            profile=prof(6000, 16384, {"judge": True}))
+    for k in ("math", "code", "code_stdio", "ifeval"):
+        ctx.env_signal[f"objective/{k}_correct_rate"] = f"env_pass_rate@{E[k].id}"
+    ctx.env_signal["objective/general-quality_ref_correct_rate"] = f"env_pass_rate@{E['general'].id}"
+    # models
+    def mk(key, name, parent, run_key, step, notes, created, repo, status="released"):
+        M[key] = kit.model(w, pid, key, name, hf_repo=repo, arch=model_arch(7), params_total=P7, params_active=P7, context_len=65536, parent_id=parent,
+                           run_key=run_key, step=step, stage="RL-Zero", created_at=created, status=status, source=hf(repo) if repo else OI_README, notes=notes)
+    R = {k: [dict(r) for r in wb[k]["rows"]] for k in ("rlzero-math-3.0", "rlzero-math-3.1-restart", "rlzero-code-3.0", "rlzero-code-3.1", "rlzero-if", "rlzero-general")}
+    pubm = load("public-runs/ai2-olmo3-7b-rlzero-math/metrics.jsonl.gz")
+    extram = {r["step"]: r for r in wb["rlzero-math-3.1-extra"]["rows"]}
+    R["rlzero-math-3.1"] = []
+    for r in pubm:
+        x = {k: v for k, v in r.items() if k not in ("episode", "training_step")}
+        x.update({k: v for k, v in extram.get(r["step"], {}).items() if k != "step"})
+        R["rlzero-math-3.1"].append(x)
+    R["rlzero-math-3.1-restart"] = rename_steps(R["rlzero-math-3.1-restart"], 2000)
+    last_t = lambda k: R[k][-1]["_timestamp"]
+    mk("math30", "Olmo-3-7B-RL-Zero-Math", M["base7"], "rlzero-math-3.0", None, "RL from the base; step_100…step_1900 branches. Superseded by 3.1. The "
+       "public run zim8gcyv matches the 3.0 description in A.6.4 (12K responses, truncated completions masked); Ai2 does not say which run produced "
+       "the checkpoint.", last_t("rlzero-math-3.0"), "allenai/Olmo-3-7B-RL-Zero-Math")
+    mk("code30", "Olmo-3-7B-RL-Zero-Code", M["lc7"], "rlzero-code-3.0", 300, "main is byte-identical to branch step_300 (unexplained). HF branches run to "
+       "step_2900 although the public W&B run logs 2,041 steps.", last_t("rlzero-code-3.0"), "allenai/Olmo-3-7B-RL-Zero-Code")
+    mk("if30", "Olmo-3-7B-RL-Zero-IF", M["lc7"], "rlzero-if", None, "step_100…step_1900 branches; the public run logs 4,553 steps.", last_t("rlzero-if"),
+       "allenai/Olmo-3-7B-RL-Zero-IF")
+    mk("general30", "Olmo-3-7B-RL-Zero-General", M["lc7"], "rlzero-general", None, "LM-judge reward; step_100…step_800 branches.", last_t("rlzero-general"),
+       "allenai/Olmo-3-7B-RL-Zero-General")
+    mk("math31-2000", "RL-Zero Math 3.1 · step 2,000 (internal)", M["base7"], "rlzero-math-3.1", 2000, "The checkpoint the restart run loads "
+       "(…olmo3_7b_rlzero_math__1__1763966683_checkpoints/step_2000).", last_t("rlzero-math-3.1"), None, status="internal")
+    t2800 = interp_time([(r["step"], r["_timestamp"]) for r in R["rlzero-math-3.1-restart"] if r.get("_timestamp")], 2800)
+    mk("math31", "Olmo-3.1-7B-RL-Zero-Math", M["math31-2000"], "rlzero-math-3.1-restart", 2800, "main is byte-identical to step_2800. 16K responses, "
+       "truncated completions not masked (A.6.4). The card body says it was trained on the Code dataset; its metadata says Math.", t2800,
+       "allenai/Olmo-3.1-7B-RL-Zero-Math")
+    mk("code31", "Olmo-3.1-7B-RL-Zero-Code", M["base7"], "rlzero-code-3.1", None, "step_50…step_1950 branches.", last_t("rlzero-code-3.1"),
+       "allenai/Olmo-3.1-7B-RL-Zero-Code")
+    mix_end = at("2025-12-01 12:00")
+    mk("mix30", "Olmo-3-7B-RL-Zero-Mix", M["base7"], "rlzero-mix", None, "step_50…step_950 branches. HF repository created 1 Dec 2025.", mix_end,
+       "allenai/Olmo-3-7B-RL-Zero-Mix")
+    ctx_models(ctx, M)
+
+    def cfgs(k):
+        return wb[k]["config"]
+    common = "3.0-era settings: async 4, truncated completions masked, standard advantage normalisation, stop string </answer>, olmo_thinker template."
+    specs = [
+        ("rlzero-math-3.0", "olmo3-7b-rlzero-math", [(E["math"], 1.0)], M["math30"], M["base7"], 16, 16, 12000, False, False, 8, 64, ds["math"],
+         "RL-Zero Math 3.0 (W&B zim8gcyv, grpo_17kfilter_olmo3_7b_base): 16 prompts × 16 samples, 12K responses, truncated completions masked, async 4, "
+         "TIS 2, centred advantages, 8 learners + 64 vLLM engines, 2,000 steps on DAPO-Math-17k and MATH-3000 pools filtered on Olmo completions. "
+         "Replaced by 3.1 after masking truncated completions was found to vary the effective batch size and destabilise training, and 12K responses "
+         "proved too short (A.6.4): the logged stop rate has a median of 0.67, so a third of responses hit the 12K cap.", "math", None),
+        ("rlzero-code-3.0", "olmo3-7b-rlzero-code", [(E["code"], 6656), (E["code_stdio"], 6656)], M["code30"], M["lc7"], 32, 8, 16384, False, True, 8, 32,
+         ds["code"], "RL-Zero Code 3.0 (W&B xleoveqq, grpo_code_from_zero) from the pre-release long-context checkpoint: 32 prompts × 8, 16K responses, "
+                     "partial-credit code reward (threshold 0.0), " + common + " 2,041 steps; 8 learners + 32 engines.", "code", None),
+        ("rlzero-if", "olmo3-7b-rlzero-if", [(E["ifeval"], 1.0)], M["if30"], M["lc7"], 32, 8, 16384, False, True, 8, 32, ds["if"],
+         "RL-Zero IF (W&B wn9zgjj3, grpo_if_from_zero) from the pre-release long-context checkpoint: 32 prompts × 8, 16K responses, " + common + " 4,553 "
+         "steps in about 9 hours (answers are short). A second public W&B run with the same name (sc7kgpij) starts at the same minute, stops at step "
+         "3,906 and is marked failed with a NaN policy loss in its summary; no explanation is published. The curve is thinned to 500 of 2,277 logged rows.",
+         "ifeval", None),
+        ("rlzero-general", "olmo3-7b-rlzero-general", [(E["general"], 1.0)], M["general30"], M["lc7"], 32, 8, 16384, False, True, 8, 32, ds["general"],
+         "RL-Zero General (W&B 0egjzr3s, grpo_general_from_zero) from the pre-release long-context checkpoint, rewarded by the Qwen3-32B judge: 32 "
+         "prompts × 8, 16K responses, " + common + " 899 steps. The judge's correct rate is ~1 by construction, so the judge score (×10) is the "
+         "learning signal: it rose from about 2 to about 10.", "general", "objective/verifiable_reward"),
+        ("rlzero-math-3.1", "olmo3.1-7b-rlzero-math", [(E["math"], 1.0)], M["math31-2000"], M["base7"], 32, 8, 16384, True, False, 16, 56, ds["math"],
+         "RL-Zero Math 3.1 (W&B ydkgbnai, olmo3_7b_rlzero_math) from the released 7B base: 32 prompts × 8, 16K responses, no masking, TIS 2, async 8, "
+         "active sampling, no_resampling_pass_rate 0.875, 16 learners + 56 engines (Table 49: 8 + 64), 1,999 logged steps. The training correct rate is "
+         "not a progress measure here: grpo_fast counts only kept groups and prompts solved ≥87.5% stop being resampled (0.30 at step 1, peak 0.61 at "
+         "step 181, 0.35 at the end); the paper tracks AIME instead. Metrics are the published curve; rollouts are simulated.", "math", None),
+        ("rlzero-math-3.1-restart", "olmo3.1-7b-rlzero-math-restart", [(E["math"], 1.0)], M["math31"], M["math31-2000"], 32, 8, 16384, True, False, 16, 56,
+         ds["math"], "Restart of RL-Zero Math 3.1 from its step-2,000 checkpoint (W&B kl07u3lf, olmo3_7b_rlzero_math_restart2k), same settings. Its "
+                     "trainer counts steps from 1 again; they are shown here as 2,001-3,280. The released Olmo-3.1-7B-RL-Zero-Math is step 2,800 "
+                     "(main == step_2800). Table 49 lists 2,000 RL-Zero steps.", "math", None),
+        ("rlzero-code-3.1", "olmo3.1-7b-rlzero-code", [(E["code"], 6656), (E["code_stdio"], 6656)], M["code31"], M["base7"], 32, 8, 16384, True, False, 8, 56,
+         ds["code"], "RL-Zero Code 3.1 (W&B 9m37ux43) from the released base: 32 prompts × 8, 16K responses, all-tests-pass reward (threshold 0.99), no "
+                     "masking, async 8, active sampling, no_resampling_pass_rate 0.875, 8 learners + 56 engines, 2,001 steps from 29 Nov to 10 Dec 2025. No "
+                     "script on main reproduces these settings (the Code script carries 3.0-style values).", "code", None),
+    ]
+    res = {}
+    for key, name, envs, out, base, P, G_, L, active, norm, lg, ag, dset, desc, dom, prim in specs:
+        rows = R[key]
+        cfg = cfgs(key if key != "rlzero-math-3.1" else "rlzero-math-3.1-extra")
+        if key == "rlzero-math-3.1-restart":
+            cfg = cfgs("rlzero-math-3.1-restart")
+        steps_range = (rows[0]["step"], rows[-1]["step"])
+        repo = {"rlzero-math-3.0": "allenai/Olmo-3-7B-RL-Zero-Math", "rlzero-code-3.0": "allenai/Olmo-3-7B-RL-Zero-Code",
+                "rlzero-if": "allenai/Olmo-3-7B-RL-Zero-IF", "rlzero-general": "allenai/Olmo-3-7B-RL-Zero-General",
+                "rlzero-math-3.1": "allenai/Olmo-3.1-7B-RL-Zero-Math", "rlzero-math-3.1-restart": "allenai/Olmo-3.1-7B-RL-Zero-Math",
+                "rlzero-code-3.1": "allenai/Olmo-3.1-7B-RL-Zero-Code"}[key]
+        main_step = {"rlzero-code-3.0": 300, "rlzero-math-3.1-restart": 2800}.get(key)
+        ck = branch_ckpts(branches, repo, steps_range, release=main_step, model_id=out if main_step else None, main_step=main_step)
+        if key == "rlzero-math-3.1":
+            ck = [(s, M["math31-2000"] if s == 2000 else None, p) for s, _, p in ck] + [(2000, M["math31-2000"], "…/olmo3_7b_rlzero_math__1__1763966683_checkpoints/step_2000")]
+            ck = list({s: (s, m, p) for s, m, p in ck}.values())
+        res[key] = rl_run_record(
+            ctx, key=key, name=name, rows=rows, base_model_id=base, output_model_id=out, envs=envs, prompts=P, group=G_, max_tokens=L, active=active,
+            normalize_adv=norm, learner_gpus=lg, actor_gpus=ag, cluster=clusters["jupiter"], description=desc,
+            source=f"https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/{({'rlzero-math-3.1': 'ydkgbnai'}).get(key) or wb[key]['parts'][0]['wandb'].split('/')[-1]}",
+            provenance="mixed", config=cfg_text(f"Logged grpo_fast config (W&B {wb[key if key != 'rlzero-math-3.1' else 'rlzero-math-3.1-extra']['parts'][0]['wandb'].split('/')[-1]}), hyperparameters only", cfg),
+            hyperparams={"prompts_per_step": P, "group_size": G_, "lr": 1e-6, "max_response_len": L, "active_sampling": active,
+                         "advantage": "standard" if norm else "centered", "learners": lg, "vllm_engines": ag, "steps": steps_range[1],
+                         "beta_kl": 0, "tis_cap": 2, "async_steps": cfg.get("async_steps"), "mask_truncated_completions": cfg.get("mask_truncated_completions"),
+                         "code_pass_rate_reward_threshold": cfg.get("code_pass_rate_reward_threshold"), "chat_template": cfg.get("chat_template_name")},
+            group_name="rl-zero-3.1" if "3.1" in key else "rl-zero-3.0", tags=["rl-zero", dom, "published curve"], checkpoints=ck,
+            store_steps=100 if key == "rlzero-math-3.1" else 50, async_steps=cfg.get("async_steps") or 4, code_ref=GRPO_FAST, datasets=[(dset, 1.0)],
+            parent_run_id=rid("run", pid, "rlzero-math-3.1") if key == "rlzero-math-3.1-restart" else None, primary=prim)
+    # RL-Zero Mix: no public run
+    mix_start = mix_end - 950 * 150
+    mix_rows = synth_rows("rlzero-mix", first_step=1, last_step=950, n=150, t0=mix_start, t1=mix_end,
+                          verifiers={"math": (0.40, 0.46), "ifeval": (0.30, 0.80), "code": (0.15, 0.70), "code_stdio": (0.35, 0.55)},
+                          shares={"math": 15643 / 46931, "ifeval": 15644 / 46931, "code": 7830 / 46931, "code_stdio": 7814 / 46931},
+                          prompts=32, group=8, max_tokens=16384, active=False, lengths=(1500, 5500), stop=(1.0, 0.9), fz=(0.3, 0.12),
+                          train_frac=(0.15, 0.35), lr=1e-6)
+    res["rlzero-mix"] = rl_run_record(
+        ctx, key="rlzero-mix", name="olmo3-7b-rlzero-mix", rows=mix_rows, base_model_id=M["base7"], output_model_id=M["mix30"],
+        envs=[(E["math"], 15643), (E["ifeval"], 15644), (E["code"], 7830), (E["code_stdio"], 7814)], prompts=32, group=8, max_tokens=16384,
+        active=False, normalize_adv=False, learner_gpus=8, actor_gpus=32, cluster=clusters["jupiter"],
+        description="RL-Zero on the mixed pool (math, IF, code, code_stdio). There is no public W&B run: the settings are those of 7b_rlzero_mix.sh "
+                    "(32 prompts × 8, lr 1e-6, 16K responses, async 4, truncated completions masked), which lists the Code set twice and no Math set, "
+                    "while the released dataset has math, IF and code rows. Every per-step value, rollout and date is simulated: 950 steps (the last HF "
+                    "branch is step_950), ending before the HF repository's creation on 1 Dec 2025, with per-domain rates below the single-domain runs "
+                    "because the mixed run under-optimises each domain (§6.2). GPU count is not published; 8 learners + 32 engines follows the 3.0 "
+                    "single-domain runs.",
+        source="https://github.com/allenai/open-instruct/blob/main/scripts/train/olmo3/7b_rlzero_mix.sh", provenance="simulated",
+        config=cfg_text("7b_rlzero_mix.sh settings (no public W&B run)", {
+            "num_unique_prompts_rollout": 32, "num_samples_per_prompt_rollout": 8, "learning_rate": 1e-6, "response_length": 16384, "async_steps": 4,
+            "mask_truncated_completions": True, "advantage_normalization_type": "centered", "beta": 0, "dataset": "Dolci-RL-Zero-Mix-7B (46,931)"},
+            ["The script lists Dolci-RLZero-Code-7B twice and no Math set; the released dataset has math, IF and code rows.",
+             "Steps, dates and GPU count are not published; simulated."]),
+        hyperparams={"prompts_per_step": 32, "group_size": 8, "lr": 1e-6, "max_response_len": 16384, "async_steps": 4, "steps": 950,
+                     "mask_truncated_completions": True, "gpus": "not published"},
+        group_name="rl-zero-3.0", tags=["rl-zero", "mix", "simulated"], store_steps=50, async_steps=4, code_ref=GRPO_FAST,
+        checkpoints=branch_ckpts(branches, "allenai/Olmo-3-7B-RL-Zero-Mix", (1, 950)), datasets=[(ds["mix"], 1.0)])
+    # tasks: base/latest from each env's first and last real correct rates
+    first_last = {"math": ("rlzero-math-3.1", "objective/math_correct_rate"), "code": ("rlzero-code-3.1", "objective/code_correct_rate"),
+                  "code_stdio": ("rlzero-code-3.1", "objective/code_stdio_correct_rate"), "ifeval": ("rlzero-if", "objective/ifeval_correct_rate")}
+    for k, env in E.items():
+        d = [t.difficulty for t in env.tasks]
+        if not d:
+            continue
+        if env.judge:
+            rows = R["rlzero-general"]
+            a, b = window(rows, "objective/general-quality_ref_reward", 1, 20), window(rows, "objective/general-quality_ref_reward", 850, 899)
+            kit.write_tasks(w, env, base_skill=solve_skill(d, judge_target((a or 3.0) / 10)), latest_skill=solve_skill(d, judge_target(min(9.9, b or 9.0) / 10)), attempts=8)
+            continue
+        rk, tag = first_last[k]
+        rows = R[rk]
+        a = window(rows, tag, 1, 40)
+        b = window(rows, tag, rows[-1]["step"] - 100, rows[-1]["step"])
+        if env.partial_steps:
+            a, b = partial_target(a, env.partial_steps), partial_target(b, env.partial_steps)
+        # with active sampling and no_resampling_pass_rate the logged rate is not a progress measure: no latest pass rate for math/code
+        latest = None if k in ("math", "code", "code_stdio") else solve_skill(d, min(0.97, max(0.03, b)))
+        kit.write_tasks(w, env, base_skill=solve_skill(d, min(0.97, max(0.03, a))), latest_skill=latest, attempts=8)
+    # evals
+    EV = Evals(ctx)
+    EV.bench("aime-rlzero", "AIME 2024 + 2025 (RL-Zero setting)", "Math", "pass@1", 60, 32,
+             "AIME 2024 and 2025 pass@1 in the RL-Zero setting (32K tokens, temperature 1.0, answers without \\boxed{}); 60 problems, 32 samples each. "
+             "The report tabulates no RL-Zero scores: Figure 39's text says the 3.1 Math run 'plateau[s] at a higher score ∼50%'. That approximate "
+             "value is the only one stored.", F39)
+    EV.bench("slice-code", "RL-Zero code held-out slice (local eval)", "Training", "correct rate", 8, 1,
+             "The trainer's local eval in RL-Zero Code 3.1: 8 held-out prompts (AceCoder 4, Klear 4 in the logged eval mixer), every 25 steps.",
+             "https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/9m37ux43")
+    EV.bench("slice-general", "RL-Zero general held-out slice (local eval)", "Training", "correct rate", 8, 1,
+             "The trainer's local eval in RL-Zero General: 8 held-out prompts of rlvr_general_mix (judge correct rate, near 1 by construction).",
+             "https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/0egjzr3s")
+    EV.ev("aime-rlzero", M["math31"], 50.0, source=F39, ek="fig39", run_id=res["rlzero-math-3.1-restart"]["run_id"], step=2800, started=t2800 + 3600,
+          config={"approximate": True, "quote": "plateauing at a higher score ∼ 50%", "figure": 39})
+    for key, bk, url in (("rlzero-code-3.1", "slice-code", "https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/9m37ux43"),
+                         ("rlzero-general", "slice-general", "https://wandb.ai/ai2-llm/Olmo-3-7B-RL-Zero/runs/0egjzr3s")):
+        base = {"rlzero-code-3.1": M["base7"], "rlzero-general": M["lc7"]}[key]
+        for r in R[key]:
+            v = r.get("eval/objective/verifiable_correct_rate")
+            if v is None:
+                continue
+            EV.ev(bk, base, v * 100, source=url, ek=f"{key}|{r['step']}", run_id=res[key]["run_id"], step=r["step"],
+                  started=interp_time(res[key]["stamps"], r["step"]),
+                  config={k.split("/")[-1]: r[k] for k in r if k.startswith("eval/objective/")})
+    write_metric_defs(w, pid, ctx.tags, ctx.env_signal)
+    for k, r_ in res.items():
+        spend(w, org_id, pid, r_["start"], r_["end"], r_["cost"], rl_split(r_))
+    m3 = R["rlzero-math-3.0"]
+    m31 = R["rlzero-math-3.1"]
+    kit.report(
+        w, pid, "rlzero-findings", "OLMo 3 RL-Zero: what the public runs show", "Ai2 OLMo team (technical report)", at("2025-12-15 00:00"),
+        "Claims from §6 and A.6.4 of the Olmo 3 report about RL from the base model, checked against the six public RL-Zero runs.",
+        [{"claim": "RL-Zero rewards rise in every domain.", "verdict": "upheld",
+          "evidence": f"Figure 24. Public runs: IF correct rate {window(R['rlzero-if'], 'objective/ifeval_correct_rate', 1, 50):.2f} → "
+                      f"{window(R['rlzero-if'], 'objective/ifeval_correct_rate', 4400, 4553):.2f}; General judge score ×10 "
+                      f"{window(R['rlzero-general'], 'objective/general-quality_ref_reward', 1, 20):.1f} → "
+                      f"{window(R['rlzero-general'], 'objective/general-quality_ref_reward', 850, 899):.1f}; Code 3.0 "
+                      f"{window(R['rlzero-code-3.0'], 'objective/verifiable_correct_rate', 1, 50):.2f} → "
+                      f"{window(R['rlzero-code-3.0'], 'objective/verifiable_correct_rate', 1950, 2041):.2f}. With active sampling (the 3.1 runs) the "
+                      f"logged correct rate is not a progress measure."},
+         {"claim": "The 3.1 setup (16K responses, no masking of truncated completions) starts slower but plateaus higher, near 50% AIME pass@1.",
+          "verdict": "upheld",
+          "evidence": f"Figure 39 and A.6.4. The 3.0 run capped responses at 12K and its logged stop rate had a median of {med(m3, 'val/stop_rate'):.2f}; "
+                      f"the 3.1 run's responses grew from {m31[0]['val/sequence_lengths']:,.0f} to {m31[-1]['val/sequence_lengths']:,.0f} tokens under a 16K cap."},
+         {"claim": "Masking truncated completions varied the effective batch size and reduced stability.", "verdict": "upheld",
+          "evidence": "A.6.4; 3.1 drops the masking and adds minor loss-calculation fixes. The Code, IF, General and Mix scripts on main still carry the "
+                      "3.0 settings, while the 3.1 Code run used async 8, no masking and the 0.99 threshold, which no script reproduces."},
+         {"claim": "A mixed-domain RL-Zero run under-optimises each domain relative to single-domain runs.", "verdict": "upheld",
+          "evidence": "§6.2. The Mix run here is simulated (no public run), so it illustrates rather than tests the claim."},
+         {"claim": "Decontamination worked: RL with random rewards gains nothing.", "verdict": "upheld",
+          "evidence": "Figure 27: a spurious-reward control (random binary rewards on Dolci RL-Zero) produced no gains on any benchmark."},
+         {"claim": "RL-Zero Math approaches DAPO's Qwen2.5-32B AIME24 curve with an order of magnitude fewer steps.", "verdict": "open",
+          "evidence": "Figure 38 plots it (DAPO values from the verl reproduction); no numbers are tabulated for any RL-Zero checkpoint."}],
+        run_keys=tuple(res.keys()))
+
+
+# ================================================================ earlier recipes
+def build_earlier(w, org_id):
+    pid = kit.project(
+        w, org_id, "earlier-recipes", "Tülu 3 and OLMo 2 RL recipes (earlier)",
+        "The open-instruct runs OLMo 3 grew out of: Tülu 3 8B SFT and length-normalized DPO, Tülu 3.1 8B GRPO with verifiable rewards, and GRPO on "
+        "OLMo 2 7B (from DPO and from the base). OLMo 3 reuses the decontamination toolkit, dpo_norm with beta 5, the persona and safety data, the "
+        "RLVR idea and grpo_fast itself.",
+        [{"title": "Tülu 3 8B SFT reproduction (W&B report)", "url": OI_PUBLIC + "Tulu3-8B-SFT--VmlldzoxMTk0OTY4MA"},
+         {"title": "Tülu 3 8B DPO reproduction (W&B report)", "url": OI_PUBLIC + "Tulu3-8B-DPO--VmlldzoxMTg3NjY4Nw"},
+         {"title": "Tülu 3.1 8B GRPO (W&B report)", "url": OI_PUBLIC + "Tulu3-1-8B-GRPO-Fast--VmlldzoxMTk0NzcwOA"},
+         {"title": "OLMo 2 7B GRPO (W&B report)", "url": OI_PUBLIC + "OLMo-2-7B-GRPO--VmlldzoxMTkyNzc1OA"},
+         {"title": "OLMo 2 7B GRPO-Fast zero (W&B report)", "url": OI_PUBLIC + "OLMo-2-7B-GRPO-Fast-Zero--VmlldzoxMjA0MjU4MQ"},
+         {"title": "Qwen2.5 7B GRPO-Fast zero (W&B report)", "url": OI_PUBLIC + "Qwen2-5-7B-GRPO-Fast-Zero--VmlldzoxMjA2NDExMA"},
+         {"title": "Olmo 3 technical report: what OLMo 3 reuses from Tülu 3", "url": S421}],
+        "Published: six public W&B runs from open-instruct's documentation reports (every logged value; curves thinned for display). These are "
+        "reproduction and experimental runs; their checkpoints are not released, so the runs start from released models but produce none. Nothing "
+        "is simulated here, and there are no environments or evals.",
+        at("2025-03-17 00:00"))
+    ctx = Ctx(w, org_id, pid, "earlier-recipes")
+    M = {}
+
+    def mk(key, name, kind, repo, parent=None, notes=""):
+        M[key] = kit.model(w, pid, key, name, kind, hf_repo=repo, parent_id=parent, created_at=at("2025-03-01 00:00"), status="external" if kind == "external" else "released",
+                           notes=notes, source=hf(repo) if repo else "")
+    mk("llama", "Llama-3.1-8B", "base", "meta-llama/Llama-3.1-8B")
+    mk("tsft", "Llama-3.1-Tulu-3-8B-SFT", "checkpoint", "allenai/Llama-3.1-Tulu-3-8B-SFT", M["llama"], "Released Tülu 3 SFT; the SFT run here reproduces its recipe.")
+    mk("tdpo", "Llama-3.1-Tulu-3-8B-DPO", "checkpoint", "allenai/Llama-3.1-Tulu-3-8B-DPO", M["tsft"], "Released Tülu 3 DPO; the DPO run here starts from the released SFT.")
+    mk("t31", "Llama-3.1-Tulu-3.1-8B", "checkpoint", "allenai/Llama-3.1-Tulu-3.1-8B", M["tdpo"], "Released Tülu 3.1 (GRPO); the GRPO run here reproduces it.")
+    mk("o2", "OLMo-2-1124-7B", "base", "allenai/OLMo-2-1124-7B")
+    mk("o2dpo", "OLMo-2-1124-7B-DPO", "checkpoint", "allenai/OLMo-2-1124-7B-DPO", M["o2"], "Released OLMo 2 7B DPO.")
+    mk("o2inst", "OLMo-2-1124-7B-Instruct", "checkpoint", "allenai/OLMo-2-1124-7B-Instruct", M["o2dpo"], "Released OLMo 2 7B Instruct (PPO-trained); the docs say the GRPO run here outperforms it.")
+    mk("qwen", "Qwen2.5-7B", "external", "Qwen/Qwen2.5-7B")
+    ctx_models(ctx, M)
+    specs = [  # id, key, name, kind, base, stage, keep-tags, prompts, group, desc
+        ("ai2-tulu3-8b-sft", "tulu3-8b-sft", "tulu3-8b-sft-repro", "sft", M["llama"], "SFT", ("train_loss", "learning_rate", "total_tokens", "per_device_tps"), None, None),
+        ("ai2-tulu3-8b-dpo", "tulu3-8b-dpo", "tulu3-8b-dpo-repro", "dpo", M["tsft"], "DPO", None, None, None),
+        ("ai2-tulu31-8b-grpo", "tulu31-8b-grpo", "tulu3.1-8b-grpo-repro", "rl", M["tdpo"], "RL", None, 48, 16),
+        ("ai2-olmo2-7b-grpo", "olmo2-7b-grpo", "olmo2-7b-grpo", "rl", M["o2dpo"], "RL", None, 48, 16),
+        ("ai2-olmo2-7b-grpo-zero", "olmo2-7b-grpo-zero", "olmo2-7b-grpo-zero", "rl", M["o2"], "RL (zero)", None, 48, 16),
+        ("ai2-qwen25-7b-grpo-zero", "qwen25-7b-grpo-zero", "qwen2.5-7b-grpo-zero", "rl", M["qwen"], "RL (zero)", None, 48, 16),
+    ]
+    for src_id, key, name, kind, base, stage, keep, P, G_ in specs:
+        meta = load(f"public-runs/{src_id}/run.json")
+        rows = load(f"public-runs/{src_id}/metrics.jsonl.gz")
+        rows = thin(rows, 400)
+        run_id = rid("run", pid, key)
+        drop = {"step", "episode", "epoch", "training_step", "objective/kl3", "objective/kl3_avg", "objective/kl2", "objective/kl2_avg"}
+        mrows = []
+        for r in rows:
+            for k, v in r.items():
+                if k in drop or v is None or (keep and k not in keep) or isinstance(v, (str, list, dict)):
+                    continue
+                if isinstance(v, float) and (math.isnan(v) or math.isinf(v)):
+                    continue
+                mrows.append({"run_id": run_id, "tag": k, "step": int(r["step"]), "value": float(v)})
+                ctx.tags.add(k)
+        w.add_many("metrics", mrows)
+        t0 = dt.datetime.fromisoformat(meta["started_at"].replace("Z", "+00:00")).timestamp()
+        t1 = dt.datetime.fromisoformat(meta["updated_at"].replace("Z", "+00:00")).timestamp()
+        last = rows[-1]["step"]
+        n = min(60, len(rows))
+        pick = sorted({rows[round(i * (len(rows) - 1) / max(1, n - 1))]["step"] for i in range(n)})
+        steps = []
+        prev = t0
+        for s in pick:
+            t = t0 + (t1 - t0) * s / last
+            r = next(x for x in rows if x["step"] == s)
+            cr = r.get("objective/verifiable_correct_rate")
+            steps.append({"run_id": run_id, "step": s, "phase": "train", "started_at": prev, "ended_at": t, "prompts": P, "rollouts": (P * G_) if P else 0,
+                          "rollouts_stored": 0, "reward_mean": cr, "pass_rate": cr, "tokens": None, "groups_all_pass": None, "groups_all_fail": None,
+                          "groups_mixed": None, "infra_errors": None, "truncated": None})
+            prev = t
+        w.add_many("run_steps", steps)
+        w.add_many("run_events", [{"run_id": run_id, "t": t0, "step": 0, "kind": "start", "severity": "info", "title": "Run started", "body": meta["method"]},
+                                  {"run_id": run_id, "t": t1, "step": last, "kind": "end", "severity": "info", "title": "Run completed", "body": ""}])
+        primary = {"sft": "train_loss", "dpo": "train_loss"}.get(kind, "objective/verifiable_correct_rate")
+        w.add("runs", {
+            "id": run_id, "project_id": pid, "name": name, "kind": kind, "stage": stage,
+            "algorithm": {"sft": "SFT", "dpo": "DPO (length-normalized)", "rl": "GRPO"}[kind], "framework": "open_instruct", "status": "completed",
+            "status_reason": "", "base_model_id": base, "output_model_id": None, "started_at": t0, "ended_at": t1, "updated_at": t1,
+            "steps_planned": last, "steps_done": last, "primary_metric": primary, "gpu": None, "gpus": None, "cost_usd": None, "cost_rate": None,
+            "owner": "Ai2 (open-instruct)", "tags": ["earlier", "published"], "code_ref": OI, "config": "", "config_format": "yaml",
+            "hyperparams": {"dataset": meta["dataset"], "method": meta["method"]}, "parent_run_id": None, "group_name": "tulu-3" if "tulu" in key else "olmo-2",
+            "description": meta["title"] + ". " + meta["note"], "source": meta["url"], "provenance": "published"})
+    write_metric_defs(w, pid, ctx.tags, {}, dpo=True)
+    kit.report(
+        w, pid, "lineage", "What OLMo 3 kept from Tülu 3", "Ai2 OLMo team (technical report)", at("2025-12-15 00:00"),
+        "Where the OLMo 3 report says it builds on Tülu 3 and OLMo 2, and what changed.",
+        [{"claim": "OLMo 3 keeps Tülu 3's length-normalized DPO (dpo_norm, beta 5).", "verdict": "upheld",
+          "evidence": "Every OLMo 3 DPO config logs dpo_loss_type dpo_norm and dpo_beta 5 (W&B 1e5w41io, 19pb8hi1, fy6xccpa, haxulm5u; report A.6.2); the "
+                      "Tülu 3 8B DPO reproduction here used the same loss and beta with lr 5e-7 (its run notes)."},
+         {"claim": "OLMo 3 keeps Tülu 3's decontamination and reuses its persona, safety and chat subsets.", "verdict": "upheld",
+          "evidence": "§4.2.1: the Tülu 3 8-gram procedure on all three stages; Tables 17, 19 and 30 list Tülu 3 persona MATH/GSM/Algebra/Python/IF, "
+                      "CoCoNot, WildGuardMix, WildJailbreak, WildChat and OpenAssistant subsets."},
+         {"claim": "RLVR grew from math and IF (Tülu 3) to code and judge-scored chat (OLMo 3).", "verdict": "upheld",
+          "evidence": "The Tülu 3.1 and OLMo 2 GRPO runs here reward GSM8K, MATH and IFEval constraints only; OLMo 3 adds code, stdin/stdout code and a "
+                      "Qwen3-32B judge (§4.4.1)."},
+         {"claim": "OLMo 3 replaced the older UltraFeedback-style pipeline with delta learning plus a modernised, delta-aware judge.", "verdict": "upheld",
+          "evidence": "Table 32: OLMo 2 preference data 55.5 vs delta learning + GPT pairs 60.4 on the Instruct dev average."}],
+        run_keys=("tulu3-8b-sft", "tulu3-8b-dpo", "tulu31-8b-grpo", "olmo2-7b-grpo", "olmo2-7b-grpo-zero", "qwen25-7b-grpo-zero"))
diff --git a/viewer/build/labs/openthoughts.py b/viewer/build/labs/openthoughts.py
new file mode 100644
index 0000000000000000000000000000000000000000..487137aef420747814e4b2456d4498507e0b9ece
--- /dev/null
+++ b/viewer/build/labs/openthoughts.py
@@ -0,0 +1,808 @@
+"""OpenThoughts: OpenThoughts-Agent (data recipes for terminal and SWE agents).
+
+Published (inputs/openthoughts, see SOURCE.md): five SFT loss curves from released trainer_state.json
+files (32B on the 94,334-trace set, both 8B cold-start SFTs, the 8B 100K run, v1), the RL hero run's
+launch config, 265 Terminal-Bench 2.0 trials of the released RL checkpoint with transcripts, real
+task ids and texts; every score in the paper's tables (written below next to its source).
+Simulated: the RL runs' per-step curves and rollouts (no RL logs are public), shaped to the paper's
+published start, peak, collapse and step-48 values; per-task results behind published scores.
+"""
+import dataclasses
+import gzip
+import json
+import math
+import random
+import re
+from collections import defaultdict
+from pathlib import Path
+
+from .. import kit
+from ..sim import attempt, rid, rng, solve_skill, stable_seed
+from ..training import Bench, benchmark, eval_run
+
+INPUTS = Path(__file__).resolve().parent.parent / "inputs" / "openthoughts"
+PAPER = "https://arxiv.org/abs/2606.24855"
+BLOG = "https://www.openthoughts.ai/blog/openthoughts-agent"
+BLOG_V1 = "https://www.openthoughts.ai/blog/agent"
+REPO = "https://github.com/open-thoughts/OpenThoughts-Agent"
+RL_PIPE = "https://github.com/open-thoughts/OpenThoughts-Agent/blob/3bd1917e62c9d03d73063b433f5c442c279c0563/docs/RL_PIPELINE.md"
+DS_GEN = "https://github.com/open-thoughts/OpenThoughts-Agent/blob/3bd1917e62c9d03d73063b433f5c442c279c0563/docs/DATASET_GENERATION.md"
+CARD_32B = "https://huggingface.co/open-thoughts/OpenThinkerAgent-32B"
+CARD_RL = "https://huggingface.co/open-thoughts/OpenThinkerAgent-8B-RL"
+RL_CFG = CARD_RL + "/blob/main/swesmith-fixthink-pymethods2test_rl_config.json"
+CARD_COLD = "https://huggingface.co/open-thoughts/OpenThinkerAgent-8B-ColdStartSFTForRL"
+COLD_FIX = "https://huggingface.co/laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink"
+G1_8B = "https://huggingface.co/DCAgent/g1_diverse_tezos_100k_8b"
+CARD_V1 = "https://huggingface.co/open-thoughts/OpenThinker-Agent-v1"
+CARD_V1SFT = "https://huggingface.co/open-thoughts/OpenThinker-Agent-v1-SFT"
+DS_100K = "https://huggingface.co/datasets/open-thoughts/OpenThoughts-Agent-SFT-100K"
+DS_COLD = "https://huggingface.co/datasets/open-thoughts/OpenThoughts-Agent-SFT-ColdStartForRL-10K"
+DS_RL5K = "https://huggingface.co/datasets/open-thoughts/OpenThoughts-Agent-RL-5K"
+DS_V1RL = "https://huggingface.co/datasets/open-thoughts/OpenThoughts-Agent-v1-RL"
+DS_V1SFT = "https://huggingface.co/datasets/open-thoughts/OpenThoughts-Agent-v1-SFT"
+TASKTROVE = "https://huggingface.co/datasets/open-thoughts/TaskTrove"
+TBLITE = "https://huggingface.co/datasets/open-thoughts/OpenThoughts-TBLite"
+TBDEV = "https://huggingface.co/datasets/open-thoughts/OpenThoughts-TB-dev"
+TB2_TRACES = "https://huggingface.co/datasets/DCAgent2/terminal_bench_2_rl_swesmith_fixthink_pymethods2test_45_20260504_234427"
+
+# RL task sources (paper Table 9; public packagings: the paper does not say which version each run used)
+SOURCES = [
+    # key, title, domain, task_count, packaging url, grader kind, reward, rank, SWE-V-100, TBLite, TB2, raw avg, train reward (start, end), published?
+    ("pymethods2test", "pymethods2test (OpenThoughts-Agent-RL-5K)", "code", 5000, DS_RL5K, "pytest", "binary", 1, 35.67, 16.02, 13.48, 21.72, None, True),
+    ("r2egym", "r2egym (TaskTrove r2egym-patched-full-oracle-v3)", "swe", 2574, TASKTROVE, "repo_tests", "binary", 2, 28.67, 16.84, 6.74, 17.42, (0.12, 0.22), False),
+    ("nemotron-code-oracle", "nemotron-code-oracle (TaskTrove)", "code", 15165, TASKTROVE, "pytest", "binary", 3, 25.00, 16.78, 6.74, 16.17, (0.06, 0.36), True),
+    ("llm-verifier-freelancer", "llm-verifier-freelancer (DCAgent)", "terminal", 8580, "https://huggingface.co/datasets/DCAgent/exp_llmve_llm-verifier-freelancer-sandboxes", "llm_judge", "scalar", 4, 22.33, 14.87, 8.61, 15.27, (0.54, 0.73), True),
+    ("inferredbugs", "inferredbugs (TaskTrove)", "swe", 9659, TASKTROVE, "pytest", "binary", 5, 26.00, 14.30, 6.37, 15.56, (0.21, 0.46), True),
+    ("swesmith", "swesmith (TaskTrove swesmith-oracle-filtered-v2)", "swe", 12927, TASKTROVE, "repo_tests", "binary", 6, 24.33, 14.30, 6.74, 15.12, (0.15, 0.25), False),
+    ("code-contests", "code-contests (open-thoughts/CodeContests)", "code", 9644, "https://huggingface.co/datasets/open-thoughts/CodeContests", "pytest", "binary", 7, 23.67, 13.75, 7.87, 15.10, (0.06, 0.14), True),
+    ("nl2bash", "nl2bash (OpenThoughts-Agent-v1-RL)", "terminal", 728, DS_V1RL, "expected_output", "binary", 8, 21.00, 14.51, 6.74, 14.08, (0.30, 0.38), False),
+]
+SEC_TB2 = {"break-filter-js-from-html", "crack-7z-hash", "custom-memory-heap-crash", "feal-differential-cryptanalysis",
+           "feal-linear-cryptanalysis", "filter-js-from-html", "fix-code-vulnerability", "git-leak-recovery",
+           "model-extraction-relu-logits", "password-recovery", "sanitize-git-repo", "vulnerable-secret"}
+
+
+def _load(name):
+    if name.endswith(".gz"):
+        with gzip.open(INPUTS / name, "rt") as fh:
+            return json.load(fh)
+    return json.loads((INPUTS / name).read_text())
+
+
+def _fix_score(w, eval_id, value):
+    """Keep a published score exactly when simulated per-task results can only approximate it."""
+    w.conn.execute("UPDATE evals SET score=? WHERE id=?", (round(value, 5), eval_id))
+
+
+def _stderr_of(w, eval_ids):
+    ses = [w.conn.execute("SELECT stderr FROM evals WHERE id=?", (e,)).fetchone()[0] for e in eval_ids]
+    if not ses or any(s is None for s in ses):
+        return None
+    return round((sum(s * s for s in ses) ** 0.5) / len(ses), 5)
+
+
+def _logit(p):
+    p = min(0.98, max(0.02, p))
+    return math.log(p / (1 - p))
+
+
+# ------------------------------------------------------------------ SFT runs from real trainer_state.json
+
+def _sft_import(w, pid, key, name, state, *, base, out, datasets, start, runtime_s, gpus, gpu, batch, seq_len, lr, epochs,
+                status, reason, description, source, stride, extra_hp, tags=("published",)):
+    run_id = kit.run_id(pid, key)
+    log = state["log"]
+    steps_total = state["summary"]["max_steps"]
+    done = state["summary"]["global_step"]
+    keep = [x for i, x in enumerate(log) if i % stride == 0 or i == len(log) - 1]
+    series = {"train/loss": [(x["step"], x["loss"]) for x in keep],
+              "train/grad_norm": [(x["step"], x["grad_norm"]) for x in keep if "grad_norm" in x],
+              "train/learning_rate": [(x["step"], x["learning_rate"]) for x in keep if "learning_rate" in x],
+              "train/epoch": [(x["step"], x["epoch"]) for x in keep if "epoch" in x]}
+    kit.import_metrics(w, run_id, series)
+    per = runtime_s / max(1, done)
+    rows = []
+    for s in range(1, done + 1, max(1, done // 40)):
+        rows.append({"run_id": run_id, "step": s, "phase": "train", "started_at": start + per * (s - 1), "ended_at": start + per * s,
+                     "prompts": batch, "rollouts": 0, "rollouts_stored": 0, "reward_mean": None, "pass_rate": None, "tokens": None,
+                     "groups_all_pass": None, "groups_all_fail": None, "groups_mixed": None, "infra_errors": None, "truncated": None})
+    end = start + runtime_s
+    hp = {"lr": lr, "global_batch": batch, "max_seq_len": seq_len, "epochs": epochs, "steps": steps_total}
+    hp.update(extra_hp or {})
+    w.add("runs", {"id": run_id, "project_id": pid, "name": name, "kind": "sft", "stage": "SFT", "algorithm": "SFT",
+                   "framework": "LLaMA-Factory (fork)", "status": status, "status_reason": reason, "base_model_id": base,
+                   "output_model_id": out, "started_at": start, "ended_at": end, "updated_at": end, "steps_planned": steps_total,
+                   "steps_done": done, "primary_metric": "train/loss", "gpu": gpu, "gpus": gpus, "cost_usd": None, "cost_rate": None,
+                   "owner": "OpenThoughts-Agent team", "tags": list(tags), "code_ref": "open-thoughts/OpenThoughts-Agent (LLaMA-Factory fork)",
+                   "config": "\n".join(f"{k}: {v}" for k, v in hp.items()), "config_format": "yaml", "hyperparams": hp,
+                   "parent_run_id": None, "group_name": "ot-agent-sft",
+                   "description": description + f" Real: the loss, grad-norm and learning-rate log of the published trainer_state.json (every {5 * stride}th step kept here, first and last always).",
+                   "source": source, "provenance": "published"})
+    for ds, wt in datasets:
+        w.add("run_inputs", {"run_id": run_id, "kind": "dataset", "ref_id": ds, "weight": wt})
+    w.add_many("run_steps", rows)
+    w.add_many("run_events", [
+        {"run_id": run_id, "t": start, "step": 0, "kind": "start", "severity": "info", "title": "Run started",
+         "body": f"SFT, global batch {batch}, cutoff {seq_len:,} tokens, {epochs} epochs planned."},
+        {"run_id": run_id, "t": end, "step": done, "kind": "end", "severity": "info" if status == "completed" else "warning",
+         "title": {"completed": "Run completed", "stopped": "Published log ends here"}.get(status, "Run ended"), "body": reason}])
+    return run_id, end
+
+
+# ------------------------------------------------------------------ RL runs (simulated per step)
+
+def _rl_sim(w, pid, key, name, *, env, base, out, start, steps, step_seconds, target, timeouts, entropy, grad, turns, tokens,
+            staleness, store_groups, description, source, overrides=None, hyperparams=None, config="", release_step=None,
+            group_name="ot-agent-rl", judge_scale=False, tags=(), anchors=None, cap=None):
+    """64 prompts × 8 attempts per step, every attempt simulated; per-step reward target and agent-timeout share follow
+    the given functions of the step. A dry pass measures how far truncations and timeouts pull the realized reward below
+    the target and the recorded pass corrects for it. anchors {step: reward} pins published values exactly; cap bounds
+    every other step by reflection (so a published peak stays the peak). Returns ({step: facts}, end time)."""
+    run_id = kit.run_id(pid, key)
+    pool = [t for t in env.tasks if t.status not in ("excluded", "invalid")]
+    diffs = [t.difficulty for t in (pool if len(pool) <= 300 else random.Random(stable_seed(pid, key, "d")).sample(pool, 300))]
+
+    def one_pass(tgt, seed, record):
+        r = random.Random(seed)
+        series = defaultdict(list)
+        step_rows, rolls, facts, realized = [], [], {}, {}
+        t = start
+        for s in range(1, steps + 1):
+            p = min(0.985, max(0.005, tgt(s)))
+            want = (8 * p - 1) / 6 if judge_scale else p  # judge rewards are Beta(1+6p, 1+6(1-p)): mean (1+6p)/8
+            skill = solve_skill(diffs, min(0.99, max(0.01, want)))
+            tau = timeouts(s)
+            env_s = dataclasses.replace(env, timeout_rate=min(0.97, tau / max(0.03, 1 - p)),
+                                        turns=(max(2, int(round(turns(s)))), env.turns[1]), tokens_out=tokens(s))
+            dur = step_seconds * math.exp(r.gauss(0, 0.08)) * (1 + 0.6 * tau)
+            n = scored = infra = tout = trunc = all0 = all1 = anyp = 0
+            rew_sum = tok_sum = turn_sum = 0.0
+            for g in range(64):
+                task = pool[r.randrange(len(pool))]
+                atts = [attempt(r, env_s, task, skill) for _ in range(8)]
+                for a in atts:  # terminus-2 has no turn cap: long failed trials end at the 1,800 s agent timeout
+                    if a["outcome"] == "max_turns":
+                        a["outcome"], a["stop_reason"] = "timeout", "agent_timeout"
+                vals = [a["reward"] for a in atts]
+                sc = [v for v in vals if v is not None]
+                if sc:
+                    all0 += all(v <= 0 for v in sc)
+                    all1 += all(v >= 1 for v in sc)
+                anyp += any(a["outcome"] == "passed" for a in atts)
+                mean = sum(sc) / len(sc) if sc else 0.0
+                sd = (sum((v - mean) ** 2 for v in sc) / len(sc)) ** 0.5 if sc else 0.0
+                for j, a in enumerate(atts):
+                    n += 1
+                    tok_sum += a["tokens_out"]
+                    turn_sum += a["turns"]
+                    if a["reward"] is None:
+                        infra += 1
+                    else:
+                        scored += 1
+                        rew_sum += a["reward"]
+                    tout += a["outcome"] == "timeout"
+                    trunc += a["outcome"] == "truncated"
+                    if record and g < store_groups:
+                        loo = None
+                        if a["reward"] is not None and len(sc) > 1:
+                            loo_mean = (sum(sc) - a["reward"]) / (len(sc) - 1)
+                            loo = round((a["reward"] - loo_mean) / (sd + 1e-6), 4) if sd > 0 else 0.0
+                        rolls.append({"id": rid("roll", run_id, s, g, j), "run_id": run_id, "eval_id": None, "step": s, "phase": "train",
+                                      "group_id": rid("grp", run_id, s, g), "sample": j, "task_id": task.id, "env_id": env.id,
+                                      "harness": env.harness, "model_id": base, "reward": a["reward"], "advantage": loo, "scores": None,
+                                      "outcome": a["outcome"], "stop_reason": {"timeout": "AgentTimeoutError", "truncated": "ContextLengthExceededError",
+                                                                               "infra_error": "DaytonaError"}.get(a["outcome"], a["stop_reason"]),
+                                      "turns": a["turns"], "tool_calls": a["tool_calls"], "tokens_in": a["tokens_in"], "tokens_out": a["tokens_out"],
+                                      "tokens_cached": a["tokens_cached"], "duration_s": a["duration_s"], "timing": a["timing"],
+                                      "staleness": r.choice([0, 1, 2, 2, 3, 4, 6]), "flags": None, "seed": stable_seed(run_id, s, g, j),
+                                      "trained": 0 if a["outcome"] in ("infra_error", "timeout", "truncated") else 1})
+            reward = rew_sum / max(1, scored)
+            realized[s] = reward
+            if not record:
+                continue
+            if anchors and s in anchors:
+                reward = anchors[s]
+            elif cap is not None and reward > cap:  # reflect below a published peak instead of clipping to a flat top
+                reward = max(0.0, 2 * cap - reward)
+            vals = {"reward/avg_raw_reward": reward, "reward/avg_pass_at_8": anyp / 64, "reward/frac_all_zero": all0 / 64,
+                    "reward/frac_all_one": all1 / 64, "env/error_rate": infra / max(1, n), "env/timeout_rate": tout / max(1, n),
+                    "env/truncated_rate": trunc / max(1, n), "generate/avg_num_tokens": tok_sum / max(1, n), "generate/avg_turns": turn_sum / max(1, n),
+                    "policy/policy_entropy": entropy(s) * math.exp(r.gauss(0, 0.04)), "policy/raw_grad_norm": grad(s) * math.exp(r.gauss(0, 0.25)),
+                    "policy/policy_loss": r.gauss(0, 0.01), "policy/ppo_clip_ratio": abs(r.gauss(0.003, 0.0015)),
+                    "policy/policy_lr": (hyperparams or {}).get("lr", 5e-6), "async/staleness_mean": staleness(s) * math.exp(r.gauss(0, 0.15)),
+                    "timing/step": dur, "timing/generate": dur * r.uniform(0.78, 0.86), "timing/policy_train": dur * r.uniform(0.08, 0.12)}
+            vals.update((overrides or {}).get(s, {}))
+            for k_, v in vals.items():
+                series[k_].append((s, v))
+            rew_row = vals["reward/avg_raw_reward"]
+            any_n = int(round(vals["reward/avg_pass_at_8"] * 64))
+            all1_n = min(all1, any_n)
+            step_rows.append({"run_id": run_id, "step": s, "phase": "train", "started_at": t, "ended_at": t + dur, "prompts": 64,
+                              "rollouts": 512, "rollouts_stored": store_groups * 8, "reward_mean": round(rew_row, 4), "pass_rate": round(rew_row, 4),
+                              "tokens": int(tok_sum), "groups_all_pass": all1_n, "groups_all_fail": 64 - any_n, "groups_mixed": any_n - all1_n,
+                              "infra_errors": infra, "truncated": trunc})
+            facts[s] = {"t": t, "end": t + dur, "reward": rew_row, "skill": skill}
+            t += dur
+        return realized, series, step_rows, rolls, facts, t
+
+    dry, *_ = one_pass(target, stable_seed(pid, key, "dry"), False)
+    ratio = {}
+    for s in range(1, steps + 1):
+        win = [x for x in range(s - 12, s + 13) if 1 <= x <= steps]
+        tm = sum(target(x) for x in win) / len(win)
+        rm = sum(dry[x] for x in win) / len(win)
+        ratio[s] = min(1.5, max(0.8, tm / max(1e-3, rm)))
+    _, series, step_rows, rolls, facts, t = one_pass(lambda s: target(s) * ratio[s], stable_seed(pid, key), True)
+    w.add("runs", {"id": run_id, "project_id": pid, "name": name, "kind": "rl", "stage": "RL", "algorithm": "RLOO (rloo_n)",
+                   "framework": "SkyRL fork + Harbor", "status": "completed", "status_reason": "", "base_model_id": base,
+                   "output_model_id": out, "started_at": start, "ended_at": t, "updated_at": t, "steps_planned": steps,
+                   "steps_done": steps, "primary_metric": "reward/avg_raw_reward", "gpu": "A100-SXM4-80GB", "gpus": 24,
+                   "cost_usd": None, "cost_rate": None, "owner": "OpenThoughts-Agent team", "tags": ["simulated"] + list(tags),
+                   "code_ref": "penfever/SkyRL@ada3bd4f + harbor@94f358bc + OpenThoughts-Agent@4e2b8422", "config": config,
+                   "config_format": "yaml", "hyperparams": hyperparams or {}, "parent_run_id": None, "group_name": group_name,
+                   "description": description, "source": source, "provenance": "simulated"})
+    w.add("run_inputs", {"run_id": run_id, "kind": "environment", "ref_id": env.id, "weight": 1.0})
+    kit.import_metrics(w, run_id, series)
+    w.add_many("run_steps", step_rows)
+    w.add_many("rollouts", rolls)
+    ev = [{"run_id": run_id, "t": start, "step": 0, "kind": "start", "severity": "info", "title": "Run started",
+           "body": "64 prompts × 8 attempts per step; fully async (max staleness 16), 768 generation workers, 280 concurrent Daytona trials."}]
+    for s in range(5, steps + 1, 5):
+        ev.append({"run_id": run_id, "t": facts[s]["end"], "step": s, "kind": "checkpoint", "severity": "info",
+                   "title": f"HF export step {s}", "body": "hf_save_interval=5"})
+        w.add("checkpoints", {"id": rid("ckpt", run_id, s), "run_id": run_id, "step": s, "model_id": out if s == release_step else None,
+                              "path": f"hf://laion/{key}-{s}", "size_gb": 16.4, "created_at": facts[s]["end"], "kept": 1})
+    ev.append({"run_id": run_id, "t": t, "step": steps, "kind": "end", "severity": "info", "title": "Run completed", "body": ""})
+    w.add_many("run_events", ev)
+    return facts, t
+
+
+# ------------------------------------------------------------------ build
+
+def build(w, now):
+    org_id = kit.org(w, "openthoughts", "OpenThoughts",
+                     about="Open data-recipe project (Stanford, UC Berkeley, JSC/LAION, Bespoke Labs, Laude Institute, BenchFlow and others): OpenThoughts reasoning data and OpenThoughts-Agent for terminal and SWE agents.",
+                     url="https://www.openthoughts.ai")
+    pid = kit.project(
+        w, org_id, "openthoughts-agent", "OpenThoughts-Agent",
+        "Data recipes for terminal and SWE agents: 100+ SFT ablations at 10K traces, a 94,334-trace SFT set (OpenThinkerAgent-32B reaches 44.8% averaged over seven agentic benchmarks, 26.2% on Terminal-Bench 2.0), and 8B cold-start SFT + RLOO, where the RL task source moved the core-3 average by 7.6 points.",
+        [{"title": "OpenThoughts-Agent: Data Recipes for Agentic Models (arXiv 2606.24855)", "url": PAPER},
+         {"title": "OpenThoughts-Agent blog (2026-06-10)", "url": BLOG}, {"title": "v1 launch blog (2025-12-05)", "url": BLOG_V1},
+         {"title": "OpenThoughts-Agent repo", "url": REPO}, {"title": "RL_PIPELINE.md (operations notes)", "url": RL_PIPE},
+         {"title": "OpenThinkerAgent-32B", "url": CARD_32B}, {"title": "OpenThinkerAgent-8B-RL and its RL config", "url": RL_CFG},
+         {"title": "OpenThoughts-Agent-SFT-100K", "url": DS_100K}, {"title": "OpenThoughts-Agent-RL-5K", "url": DS_RL5K},
+         {"title": "TaskTrove", "url": TASKTROVE}, {"title": "OpenThoughts-TBLite", "url": TBLITE},
+         {"title": "Public TB2 trials of the RL checkpoint (DCAgent2)", "url": TB2_TRACES}],
+        "Scores are the paper's and the model cards' (Tables 1, 9, 10, 11, 20, 23). SFT curves are the published trainer_state.json "
+        "logs. No RL logs are public ('available on request'), so every RL run's per-step curve and rollouts are simulated with the "
+        "published recipe (64 prompts × 8, lr 5e-6, 24 A100s) and shaped to the published numbers: the hero run's 0.47 start, 0.51 "
+        "peak near step 35, collapse with ~80% agent timeouts, and its step-48 metrics exactly; the ablations' published start and "
+        "end rewards where given. Terminal-Bench 2.0 trials of the released RL checkpoint (265, one public job) are real, with "
+        "transcripts, except 12 security-related tasks whose transcripts are withheld. Dates are placed around the published "
+        "ones (RL start 2026-02-27, releases); costs are not published.",
+        kit.ts("2025-11-01 00:00"), pins=["reward/avg_raw_reward", "env/timeout_rate", "train/loss", "reward/avg_pass_at_8"])
+
+    # models ---------------------------------------------------------------
+    q8 = kit.model(w, pid, "qwen3-8b", "Qwen3-8B", "base", hf_repo="Qwen/Qwen3-8B", arch="dense", params_total=8.19,
+                   notes="Base of all 8B SFT and RL work (8,190,735,360 BF16 parameters in the fine-tunes); 8B SFT uses the qwen3_nothink template.", source=PAPER)
+    q32 = kit.model(w, pid, "qwen3-32b", "Qwen3-32B", "base", hf_repo="Qwen/Qwen3-32B", arch="dense", params_total=32.76,
+                    notes="Base of the 32B SFT ladder (qwen3 thinking template).", source=PAPER)
+    kit.model(w, pid, "glm47-awq", "GLM-4.7-AWQ (teacher)", "teacher", arch="MoE",
+              notes="'trajectories are generated by GLM-4.7-AWQ acting as the teacher in the terminus-2 harness inside Daytona sandboxes'. Won the teacher ablation (18.16) against Kimi K2.5 (18.59), GLM 5 (18.27), GLM 4.6 AWQ (16.45) and GPT-5.3-Codex (11.94) — kept for cost. SFT rows record model 'hosted_vllm/glm'.", source=PAPER)
+    kit.model(w, pid, "glm46-awq", "GLM-4.6-AWQ (v1 teacher)", "teacher", hf_repo="QuantTrio/GLM-4.6-AWQ", arch="MoE",
+              notes="Teacher of all 15,209 rows of OpenThoughts-Agent-v1-SFT.", source=DS_V1SFT)
+    kit.model(w, pid, "gpt5-nano", "gpt-5-nano (judge and task-weighting signal)", "judge",
+              notes="Its response length weights SFT task upsampling; it scores llm-verifier-freelancer tasks 0-1.", source=PAPER)
+    ot32 = kit.model(w, pid, "ot-32b", "OpenThinkerAgent-32B", "checkpoint", hf_repo="open-thoughts/OpenThinkerAgent-32B", arch="dense",
+                     params_total=32.76, context_len=40960, parent_id=q32, run_key="sft-32b-100k", step=3600, stage="SFT",
+                     created_at=kit.ts("2026-06-08 12:00"), status="released",
+                     notes="Released checkpoint is step 3,600 of the planned 4,520 (epoch 3.98 of 5); weights byte-identical to DCAgent/g1_diverse_tezos_100k_32b_step3600. SFT only. apache-2.0.", source=CARD_32B)
+    cold_rel = kit.model(w, pid, "cold-released", "OpenThinkerAgent-8B-ColdStartSFTForRL", "checkpoint",
+                         hf_repo="open-thoughts/OpenThinkerAgent-8B-ColdStartSFTForRL", arch="dense", params_total=8.19, parent_id=q8,
+                         run_key="coldstart-released", step=4130, stage="SFT", created_at=kit.ts("2026-06-09 12:00"), status="released",
+                         notes="Weights equal laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k, not the '-fixthink' variant the RL config starts from.", source=CARD_COLD)
+    cold = kit.model(w, pid, "cold-fixthink", "OT-Agent-ColdSFT (…-131k-fixthink, the RL start)", "checkpoint",
+                     hf_repo="laion/GLM-4_7-swesmith-sandboxes-with_tests-oracle_verified_120s-maxeps-131k-fixthink", arch="dense",
+                     params_total=8.19, parent_id=q8, run_key="coldstart-fixthink", step=4130, stage="SFT", created_at=kit.ts("2026-02-21 00:00"),
+                     status="available", notes="'a distilled 8B checkpoint (OT-Agent-ColdSFT) trained on SWE-Smith traces generated by a GLM 4.7 AWQ teacher with thinking'; model.path of the released RL config (snapshot 0e3bff0c).", source=RL_CFG)
+    rl8 = kit.model(w, pid, "ot-8b-rl", "OpenThinkerAgent-8B-RL (OT-Agent-ColdSFT+RL-8B)", "checkpoint", hf_repo="open-thoughts/OpenThinkerAgent-8B-RL",
+                    arch="dense", params_total=8.19, parent_id=cold, run_key="rl-pymethods2test", step=45, stage="RL",
+                    created_at=kit.ts("2026-03-02 12:00"), status="released",
+                    notes="RL step 45; byte-identical to laion/rl_swesmith-fixthink-pymethods2test-45 (created 2026-03-02); published on open-thoughts 2026-06-09. The card lists its scores as 'TBD'; the paper reports them (Tables 9-11).", source=CARD_RL)
+    g1 = kit.model(w, pid, "g1-100k-8b", "g1_diverse_tezos_100k_8b (DCAgent)", "checkpoint", hf_repo="DCAgent/g1_diverse_tezos_100k_8b",
+                   arch="dense", params_total=8.19, parent_id=q8, run_key="sft-8b-100k", step=6328, stage="SFT", created_at=kit.ts("2026-05-03 00:00"),
+                   status="available", notes="The leaderboard's 100K 8B point (7 epochs, 6,328 steps). Probably the paper's OT-Agent-SFT-8B (100K); not confirmed.", source=G1_8B)
+    sft8_100k = kit.model(w, pid, "ot-sft-8b-100k", "OT-Agent-SFT-8B (100K)", "checkpoint", arch="dense", params_total=8.19, parent_id=q8, stage="SFT",
+                          status="unreleased", notes="Paper Table 10 model. Its linked repo open-thoughts/OpenThinkerAgent-8B-SFT-100K returns 401; DCAgent/g1_diverse_tezos_100k_8b is the likely match (unconfirmed). 8B at 100K 'reaches 39.7% on SWE-bench Verified-100 and 10.9% on Terminal-Bench 2.0'.", source=PAPER)
+    sft8_10k = kit.model(w, pid, "ot-sft-8b-10k", "OT-Agent-SFT-8B (10K)", "checkpoint", arch="dense", params_total=8.19, parent_id=q8, stage="SFT",
+                         status="unreleased", notes="Paper Tables 10-11: 8B SFT on 10K traces of the final recipe.", source=PAPER)
+    noSFT = kit.model(w, pid, "rl-qwen3-8b-nosft", "RL on Qwen3-8B (no SFT)", "checkpoint", arch="dense", params_total=8.19, parent_id=q8, stage="RL",
+                      status="internal", notes="Table 11 ablation: the same RL directly on Qwen3-8B, no cold-start SFT.", source=PAPER)
+    v1sft = kit.model(w, pid, "v1-sft", "OpenThinker-Agent-v1-SFT", "checkpoint", hf_repo="open-thoughts/OpenThinker-Agent-v1-SFT", arch="dense",
+                      params_total=8.19, parent_id=q8, run_key="v1-sft", step=6657, stage="SFT", created_at=kit.ts("2025-12-05 12:00"),
+                      status="released", notes="v1 (Dec 2025): SFT on 15,209 NL2Bash and InferredBugs traces from GLM-4.6-AWQ.", source=CARD_V1SFT)
+    v1 = kit.model(w, pid, "v1", "OpenThinker-Agent-v1", "checkpoint", hf_repo="open-thoughts/OpenThinker-Agent-v1", arch="dense",
+                   params_total=8.19, parent_id=v1sft, stage="RL", created_at=kit.ts("2025-12-05 12:00"), status="released",
+                   notes="v1 SFT + RL on OpenThoughts-Agent-v1-RL (NL2Bash) with SkyRL + Harbor; the RL run's settings are not published, so no run is shown. TB2 is 4.9 on the card and 3.7 in the paper's Table 23.", source=CARD_V1)
+    refs = {}
+    for key, name, notes in (("nemotron-terminal-32b", "Nemotron-Terminal-32B", "264K SFT"), ("swe-lego-32b", "SWE-Lego-Qwen3-32B", "18K SFT"),
+                             ("sera-32b", "SERA-32B", "25K SFT"), ("sa-swe-32b", "SA-SWE-32B", "4.5K RL"), ("deepswe", "DeepSWE-Preview", "4.5K RL (Agentica)"),
+                             ("nemotron-terminal-8b", "Nemotron-Terminal-8B", "264K SFT"), ("swe-lego-8b", "SWE-Lego-Qwen3-8B", "18K SFT"),
+                             ("endless-terminals", "Endless Terminals", "15K + 3K SFT + RL, from OpenThinker-Agent-v1-SFT"),
+                             ("kimi-k25", "Kimi-K2.5", "frontier reference (Table 23)"), ("glm5", "GLM-5", "frontier reference (Table 23)"),
+                             ("qwen35-27b", "Qwen3.5-27B", "frontier reference (Table 23)"), ("glm47-fp8", "GLM-4.7-FP8", "frontier reference, teacher family (Table 23)")):
+        refs[key] = kit.model(w, pid, key, name, "external", notes=f"Evaluated by the OpenThoughts-Agent team in the paper; {notes}.", source=PAPER)
+
+    # datasets ---------------------------------------------------------------
+    tb = _load("tasks_and_benchmarks.json.gz")
+    samples = []
+    for s_ in tb["sft100k_samples"]:
+        src = s_["task"].split("-")[0]
+        samples.append({"source": {"swesmith": "swe-smith", "superuser": "stackexchange-superuser", "issue": "issue-tasks",
+                                   "tezos": "stackexchange-tezos"}.get(src, src), "category": "terminal" if src in ("superuser", "tezos") else "swe",
+                        "data": {"messages": s_["messages"], "task": s_["task"], "result": s_["result"], "messages_total": s_["n_msgs"],
+                                 "note": f"row {s_['row']}; first 8 of {s_['n_msgs']} messages, each cut at 1,200 characters"}})
+    ds100k = kit.dataset(
+        w, pid, "sft-100k", "OpenThoughts-Agent-SFT-100K (OpenThoughts-Agent-v2)", "sft", rows=94334, hf_repo="open-thoughts/OpenThoughts-Agent-SFT-100K",
+        license="apache-2.0", version="v2",
+        description="terminus-2 traces from GLM-4.7-AWQ in Daytona sandboxes on four task sources chosen by the SFT ablations. The card says 'Rows: 100,000'; the data have 94,334 (the Figure 4 sum). Traces were not filtered for success: 32,764 end in AgentTimeoutError. Token count not published.",
+        sources=[{"name": "swe-smith (synthetic issue-resolution tasks; 9,998 tasks in)", "category": "swe", "rows": 25000, "synthetic": True, "generator": "GLM-4.7-AWQ", "license": "apache-2.0", "url": DS_100K},
+                 {"name": "issue-tasks (synthetic GitHub issues; 4,830 tasks in)", "category": "swe", "rows": 25000, "synthetic": True, "generator": "GLM-4.7-AWQ", "license": "apache-2.0", "url": DS_100K},
+                 {"name": "stackexchange-superuser (human-written Linux questions; 12,817 tasks in)", "category": "terminal", "rows": 22848, "synthetic": False, "generator": "GLM-4.7-AWQ", "license": "apache-2.0", "url": DS_100K},
+                 {"name": "stackexchange-tezos (997 unique questions × ~11 rewrites)", "category": "terminal", "rows": 21486, "synthetic": True, "generator": "GLM-4.7-AWQ", "license": "apache-2.0", "url": DS_100K}],
+        processing=[{"step": "source selection", "rows_in": None, "rows_out": None, "note": "95 task-generation strategies ablated at 10K traces; top-4 kept (swe-smith, superuser, tezos, issue-tasks). Top-8 / Top-16 at 100K did not reliably help (Table 8)."},
+                    {"step": "synthetic augmentation (Tezos)", "rows_in": 997, "rows_out": None, "note": "'expanding their distinct surface forms from ~902 to over 21K without introducing any new underlying problems' (rewriting model not named)."},
+                    {"step": "weighted upsample", "rows_in": None, "rows_out": None, "note": "gpt-5-nano response length used as upsampling weight; every unique task gets at least one rollout."},
+                    {"step": "generate traces", "rows_in": None, "rows_out": None, "note": "GLM-4.7-AWQ in terminus-2 inside Daytona sandboxes (all rows: agent terminus-2, model hosted_vllm/glm)."},
+                    {"step": "filter: at least 5 turns", "rows_in": None, "rows_out": 94334, "note": "'filter out traces with fewer than 5 turns'. Figure 4 flow: SWE-Smith 9,998 tasks → 25,000 rows; Issue Tasks 4,830 → 25,000; SuperUser 12,817 → 22,848; Tezos 997 × 11 → 21,486."},
+                    {"step": "no success filter", "rows_in": 94334, "rows_out": 94334, "note": "result: 60,296 null, 32,764 AgentTimeoutError, 916 ContextLengthExceededError, 143 DaytonaNotFoundError, 136 DaytonaError, 46 CancelledError, 27 RuntimeError, 6 AgentEnvironmentTimeoutError. trace_source: 75,879 main, 6,560 summarization sub-traces, 11,895 null. Messages per trace: median 22, max 449."},
+                    {"step": "decontam", "rows_in": None, "rows_out": None, "note": "Not described in the paper; the repo has 8-gram decontamination utilities."}],
+        samples=samples, created_at=kit.ts("2026-04-16 00:00"), source=DS_100K,
+        fields={"conversations": "list of {role, content}", "task": "task id", "result": "null or error name", "trace_source": "main / summarization"})
+    ds_cold = kit.dataset(w, pid, "cold-10k", "OpenThoughts-Agent-SFT-ColdStartForRL-10K", "sft", rows=9437, hf_repo="open-thoughts/OpenThoughts-Agent-SFT-ColdStartForRL-10K",
+                          description="SWE-Smith task traces from GLM-4.7-AWQ with thinking, used for the 8B cold-start SFT before RL.",
+                          sources=[{"name": "SWE-Smith task traces (GLM-4.7-AWQ with thinking)", "category": "swe", "rows": 9437, "synthetic": True, "generator": "GLM-4.7-AWQ", "url": DS_COLD}],
+                          processing=[{"step": "oracle verification", "rows_in": None, "rows_out": 9437, "note": "card: 'oracle-verified (120s verifier timeout)'; the result column still shows TypeError in 1,120 rows and DaytonaError in 76; mean 43.5 messages per trace."}],
+                          created_at=kit.ts("2026-02-15 00:00"), source=DS_COLD)
+    ds_rl5k = kit.dataset(w, pid, "rl-5k", "OpenThoughts-Agent-RL-5K (pymethods2test-large)", "rl_prompts", rows=5000, hf_repo="open-thoughts/OpenThoughts-Agent-RL-5K",
+                          license="apache-2.0", description="Competitive-programming problems recast as single-function Python contracts with synthesized docstring task descriptions and auto-generated unittest suites; Harbor format (instruction.md, Dockerfile, pytest verifier).",
+                          sources=[{"name": "pymethods2test: Codeforces / CodeChef / TopCoder problems as Python function contracts", "category": "code", "rows": 5000, "synthetic": True, "url": DS_RL5K}],
+                          processing=[{"step": "task packaging", "rows_in": None, "rows_out": 5000, "note": "Reference solutions ~20 lines, descriptions ~200 words. Repo note: pass rate '0% → 40%' after auto-copying any .py to solution.py."}],
+                          samples=[{"source": "pymethods2test", "category": "code", "data": {"task": x["id"], "prompt": x["text"]}}
+                                   for x in tb["pymethods2test"] if x["id"] in ("pymethods2test-0000", "pymethods2test-0003", "pymethods2test-1234") and x["text"]],
+                          created_at=kit.ts("2026-02-20 00:00"), source=DS_RL5K)
+    ds_v1rl = kit.dataset(w, pid, "v1-rl", "OpenThoughts-Agent-v1-RL (NL2Bash)", "rl_prompts", rows=728, hf_repo="open-thoughts/OpenThoughts-Agent-v1-RL",
+                          description="NL2Bash-seeded terminal tasks whose instructions and commands were permuted by GPT-5 Mini, which also wrote the tests.",
+                          sources=[{"name": "NL2Bash-seeded tasks (GPT-5 Mini)", "category": "terminal", "rows": 728, "synthetic": True, "generator": "GPT-5 Mini", "url": DS_V1RL}],
+                          processing=[{"step": "filter_by_pass_rate", "rows_in": 10000, "rows_out": 728, "note": "'removing any tasks GPT-5-Codex gets zero reward on. This results in a set of approximately 700 tasks (from 10,000 originally generated tasks)'."}],
+                          created_at=kit.ts("2025-12-01 00:00"), source=DS_V1RL)
+    ds_v1sft = kit.dataset(w, pid, "v1-sft", "OpenThoughts-Agent-v1-SFT", "sft", rows=15209, hf_repo="open-thoughts/OpenThoughts-Agent-v1-SFT",
+                           description="v1 SFT traces on NL2Bash and InferredBugs tasks.",
+                           sources=[{"name": "NL2Bash and InferredBugs task traces", "category": "terminal", "rows": 15209, "synthetic": True, "generator": "QuantTrio/GLM-4.6-AWQ", "url": DS_V1SFT}],
+                           processing=[{"step": "source ablation", "rows_in": None, "rows_out": 15209, "note": "v1 blog: '15 different approaches' ablated for instruction sourcing."}],
+                           created_at=kit.ts("2025-11-20 00:00"), source=DS_V1SFT)
+    kit.dataset(w, pid, "sft-ablations", "SFT pipeline ablation sets (10K traces per strategy)", "sft", rows=10000,
+                description="Each of the 100+ SFT ablations generated 10,000 GLM-4.7-AWQ terminus-2 traces for one strategy (95 task sources, 6 mixes, 7 augmentations, 5 task filters, 5 teachers, 3 trace filters) and fine-tuned Qwen3-8B on them (lr 4e-5, batch 96, 7 epochs, 32K context). Strategies were ranked by the average z-score over SWE-bench Verified-100, OpenThoughts-TBLite and Terminal-Bench 2.0 (n = 3). Rows is per strategy; the sets are not released individually.",
+                processing=[{"step": "per-strategy generation", "rows_in": None, "rows_out": 10000, "note": "'Each 10,000 finetune takes 160 GPU-hours on GH200s' (Table 19's ~4 h on 24 × 4 GH200 would be ~384)."}],
+                created_at=kit.ts("2026-03-15 00:00"), source=PAPER, provenance="published")
+
+    # graders and environments (RL task sources) ----------------------------------
+    graders = {
+        "pytest": kit.grader(w, pid, "pytest", "pytest verifier", "unit_tests", "The task's pytest suite (test_solution.py / test_state.py) runs after the agent finishes; binary reward on verifier success.",
+                             [{"name": "tests", "weight": 1.0, "rule": "1 if every test's expected PASS/FAIL holds, else 0."}]),
+        "repo_tests": kit.grader(w, pid, "repo-tests", "Repository tests at a pinned commit", "unit_tests", "Repository tests pinned to a trusted commit run after the agent finishes.",
+                                 [{"name": "tests", "weight": 1.0, "rule": "1 if the target tests pass, else 0."}]),
+        "llm_judge": kit.grader(w, pid, "gpt5-nano-judge", "gpt-5-nano judge", "llm_judge", "A gpt-5-nano judge writes a 0-1 score for the deliverable (tests/test_state.py calls the judge).",
+                                [{"name": "judge", "weight": 1.0, "rule": "Judge score in [0, 1]."}]),
+        "expected_output": kit.grader(w, pid, "expected-output", "Expected-output comparison", "exact_match", "The produced output is compared against expected_output.txt.",
+                                      [{"name": "output", "weight": 1.0, "rule": "1 if the output matches, else 0."}]),
+    }
+    examples = tb["sources"]
+    pym_texts = [x for x in tb["pymethods2test"] if x["text"]]
+    envs = {}
+    for key, title, domain, count, url, gkind, rkind, rank, *_rest in SOURCES:
+        start_end, published = _rest[-2], _rest[-1]
+        if key == "pymethods2test":
+            chosen = pym_texts[:2000]
+            bank = (lambda chosen: lambda _r, i: (chosen[i]["id"], chosen[i]["text"]))(chosen)
+            n_store = len(chosen)
+        else:
+            ex_key = {"nemotron-code-oracle": "nemotron-code-oracle", "code-contests": "code-contests"}.get(key, key)
+            ex = [] if key == "llm-verifier-freelancer" else examples.get(ex_key, {}).get("examples", [])
+            n_store = min(2000, count)
+
+            def bank(_r, i, ex=ex, key=key, count=count, n_store=n_store):
+                if i < len(ex):
+                    e = ex[i]
+                    return e["id"], (e["title"] + "\n\n" + e["text"]) if e.get("title") and not e["text"].startswith(e["title"]) else e["text"]
+                if key == "llm-verifier-freelancer":
+                    return f"llm_verifier_freelancer#{i:05d}", "Freelance job-post deliverable scored 0-1 by a gpt-5-nano judge. Instruction not copied: the public task files embed a hard-coded API key."
+                j = int(i * count / n_store)
+                return f"{key}#{j:05d}", f"Task {j + 1:,} of {count:,} in the public packaging ({url}); instruction not copied into the demo."
+        turns_prof = {"code": (35, 150), "swe": (45, 150), "terminal": (25, 150)}[domain]
+        env = kit.environment(
+            w, pid, key, title, domain, n_tasks=n_store, bank=bank, grader_id=graders[gkind], harness="terminus-2 (Harbor)",
+            tools=["keystrokes"], reward_kind=rkind, sandbox={"provider": "Daytona", "cpu": 1, "memory_gb": 2, "storage_gb": 2, "agent_timeout_s": 1800, "verifier_timeout_s": 120},
+            description=(f"RL task source ranked {rank} of 8 in the paper's source ablation (Table 9). Harbor task format: instruction.md, a Dockerfile environment and a pytest-style verifier. "
+                         f"Stored: {n_store:,} of the packaging's {count:,} tasks" + (" with their real ids and descriptions." if key == "pymethods2test" else
+                                                                                  "; real ids and texts for the first public examples, numbered placeholders for the rest.")),
+            version="", source=url, provenance="mixed", task_count=count, created_at=kit.ts("2026-02-20 00:00"), difficulty=(0.0, 1.6),
+            profile={"turns": turns_prof, "tokens_out": 9000, "tokens_in": 2500, "seconds": 700, "infra_rate": 0.01, "timeout_rate": 0.12,
+                     "max_tokens": 32768, "judge": rkind == "scalar"},
+            checks=([{"name": "Verifier records failures", "status": "pass", "detail": "TaskTrove v3.1 audit: verifiers that raised RewardFileNotFoundError were dropped instead of scored 0, 'silently biasing the reward distribution toward 1.0'; fixed, and no-op-passing tasks removed.", "source": TASKTROVE}] if key == "code-contests" else
+                    [{"name": "Credential in task files", "status": "fail", "detail": "Every public task embeds a hard-coded API key in tests/test_state.py; the demo copies no task text.", "source": url}] if key == "llm-verifier-freelancer" else
+                    [{"name": "Solution file naming", "status": "pass", "detail": "Verified at 0% until any .py file was auto-copied to solution.py (agents name files differently): 0% → 40%.", "source": DS_GEN}] if key == "pymethods2test" else None))
+        envs[key] = (env, start_end, published)
+
+    # SFT runs (real curves) -----------------------------------------------------------
+    sft = _load("sft_trainer_states.json.gz")
+    r_v1, _ = _sft_import(w, pid, "v1-sft", "OpenThinker-Agent-v1-SFT (Qwen3-8B)", sft["v1_sft"], base=q8, out=v1sft,
+                          datasets=[(ds_v1sft, 1.0)], start=kit.ts("2025-11-26 00:00"), runtime_s=sft["v1_sft"]["summary"]["train_runtime"],
+                          gpus=None, gpu=None, batch=16, seq_len=32768, lr=4e-5, epochs=7, status="completed", reason="",
+                          description="v1 SFT (Dec 2025) on 15,209 NL2Bash + InferredBugs traces; loss 0.812 → 0.069 over 6,657 steps, learning rate peaking at 4.0e-5 at step 670. Global batch derived from 15,209 × 7 epochs / 6,657 steps.",
+                          source=CARD_V1SFT, stride=5, extra_hp={"schedule": "cosine"})
+    r_cold_rel, _ = _sft_import(w, pid, "coldstart-released", "Cold-start SFT, released (Qwen3-8B)", sft["coldstart_released"], base=q8, out=cold_rel,
+                                datasets=[(ds_cold, 1.0)], start=kit.ts("2026-02-18 00:00"), runtime_s=sft["coldstart_released"]["summary"]["train_runtime"],
+                                gpus=8, gpu=None, batch=16, seq_len=32768, lr=4e-5, epochs=7, status="completed", reason="",
+                                description="The 8B cold-start SFT released as OpenThinkerAgent-8B-ColdStartSFTForRL (9,437 traces, 7 epochs, 4,130 steps, 64,515 s). 16 samples per step (train_samples_per_second 1.024 / steps 0.064); 8 devices derived from 16 / (1 per device × 2 accumulation); GPU type not recorded.",
+                                source=CARD_COLD, stride=4, extra_hp={"weight_decay": 0.0, "max_grad_norm": 1e-4, "warmup_ratio": 0.1, "deepspeed": "ZeRO-3"})
+    r_cold, cold_end = _sft_import(w, pid, "coldstart-fixthink", "Cold-start SFT -fixthink (the RL start, Qwen3-8B)", sft["coldstart_fixthink"], base=q8, out=cold,
+                                   datasets=[(ds_cold, 1.0)], start=kit.ts("2026-02-20 00:00"), runtime_s=sft["coldstart_fixthink"]["summary"]["train_runtime"],
+                                   gpus=8, gpu=None, batch=16, seq_len=32768, lr=4e-5, epochs=7, status="completed", reason="",
+                                   description="The '-fixthink' cold-start SFT whose snapshot the released RL config loads (model.path …-131k-fixthink/snapshots/0e3bff0c). Same data and settings as the released cold-start model but different weights; 64,702 s.",
+                                   source=COLD_FIX, stride=4, extra_hp={"weight_decay": 0.0, "max_grad_norm": 1e-4, "warmup_ratio": 0.1})
+    r_g1, _ = _sft_import(w, pid, "sft-8b-100k", "SFT on the 100K set (Qwen3-8B, DCAgent g1)", sft["g1_100k_8b"], base=q8, out=g1,
+                          datasets=[(ds100k, 1.0)], start=kit.ts("2026-05-01 00:00"), runtime_s=30 * 3600.0, gpus=96, gpu="GH200", batch=96,
+                          seq_len=32768, lr=4e-5, epochs=7, status="completed", reason="",
+                          description="7 epochs, 6,328 steps on the top-4 100K traces (the leaderboard's 100K 8B point); loss 0.822 → 0.062. The paper's 8B 100K SFT 'takes about 30 h' on 24 × 4 GH200; whether this is exactly Table 10's OT-Agent-SFT-8B (100K) is not confirmed. The run's own train_runtime field (1.2 s) is from a resumed job and is not used.",
+                          source=G1_8B, stride=6, extra_hp={"template": "qwen3_nothink", "max_grad_norm": 1.0})
+    r_32, _ = _sft_import(w, pid, "sft-32b-100k", "OpenThinkerAgent-32B SFT (Qwen3-32B, 100K)", sft["ot32b_100k"], base=q32, out=ot32,
+                          datasets=[(ds100k, 1.0)], start=kit.ts("2026-05-20 00:00"), runtime_s=5 * 3600.0 * 3600 / 4520, gpus=96, gpu="GH200",
+                          batch=96, seq_len=32768, lr=4e-5, epochs=5, status="stopped",
+                          reason="The published trainer_state.json ends at step 3,600 of 4,520 (epoch 3.98 of 5); the release is that checkpoint. Whether the run went on is not published.",
+                          description="Qwen3-32B on the 94,334-trace set: AdamW (0.9, 0.98), weight decay 0.04, lr 4e-5 cosine with 10% warm-up, batch 96, 32,768-token cutoff, ZeRO-3, max grad norm 1e-3, 24 JUPITER Booster nodes × 4 GH200 (Table 17's caption says 24 × H100 nodes), about 5 h for the full 5 epochs. Logs 904 steps per epoch (about 86.8K examples at batch 96, not 94,334: unexplained).",
+                          source=CARD_32B, stride=3, extra_hp={"weight_decay": 0.04, "adam_betas": [0.9, 0.98], "max_grad_norm": 1e-3, "warmup_ratio": 0.1, "template": "qwen3 (thinking)"})
+
+    # RL runs (simulated) --------------------------------------------------------------
+    cfg = _load("hero_rl_config.json")
+    hero_cfg = "# SkyRL / Harbor launch arguments of the hero run (released config)\n" + "\n".join(cfg["skyrl_hydra_args"])
+    hp_rl = {"lr": 5e-6, "prompts_per_step": 64, "group_size": 8, "advantage_estimator": "rloo_n (per-prompt std normalisation)",
+             "eps_clip_low": 0.2, "eps_clip_high": 0.2, "dual_clip_c": 3, "loss_reduction": "token_mean", "kl": "none", "entropy_bonus": "none",
+             "optimizer": "AdamW (0.9, 0.999), weight decay 0", "grad_clip": 1.0, "epochs": 2, "max_generate_length": 4096,
+             "max_model_len": 32768, "temperature": 0.7, "top_p": 0.95, "top_k": 20, "max_staleness_steps": 16, "parallel_workers": 768,
+             "vllm_engines": 16, "concurrent_trials": 280, "agent_timeout_s": 1800, "verifier_timeout_s": 120, "config_max_steps": 60}
+    hero_env = envs["pymethods2test"][0]
+
+    def hero_target(s):
+        if s <= 35:  # published: 0.47 at the start, 0.51 peak near step 35 (anchored); per-step noise is about ±0.03
+            return 0.44 + 0.03 * (s - 1) / 34
+        return 0.51 - (0.51 - 0.107) * ((s - 35) / 13) ** 1.3
+
+    def hero_timeouts(s):
+        return 0.12 if s <= 28 else 0.12 + (0.80 - 0.12) * ((s - 28) / 20) ** 1.6
+
+    hero_facts, hero_end = _rl_sim(
+        w, pid, "rl-pymethods2test", "RL hero run: RLOO on pymethods2test (8B)", env=hero_env, base=cold, out=rl8,
+        start=kit.ts("2026-02-27 06:00"), steps=48, step_seconds=1.66e5 / 48 / 1.2, target=hero_target, timeouts=hero_timeouts,
+        entropy=lambda s: 0.16 - 0.088 * (s - 1) / 47, grad=lambda s: 0.03 - 0.012 * (s - 1) / 47, turns=lambda s: 40.5 + 12.8 * (s - 1) / 47,
+        tokens=lambda s: 9000 + 5000 * (s - 1) / 47, staleness=lambda s: 2.5, store_groups=6, release_step=45,
+        overrides={48: {"reward/avg_raw_reward": 0.107, "reward/avg_pass_at_8": 0.281, "policy/policy_entropy": 0.072, "policy/raw_grad_norm": 0.018}},
+        anchors={1: 0.47, 35: 0.51}, cap=0.505,
+        hyperparams=hp_rl, config=hero_cfg, source=RL_CFG, tags=("hero",),
+        description=("RLOO from the -fixthink cold-start SFT on OpenThoughts-Agent-RL-5K (pymethods2test), SkyRL fork + Harbor on NERSC "
+                     "Perlmutter: 6 nodes × 4 A100-80GB (2 policy / reference, 4 inference), FSDP2 with CPU offload, runtime 1.66 × 10^5 s "
+                     "(≈46 h; about 1,100 A100-hours, derived). Published: the recipe (config), 48 steps, the reward trajectory 0.47 → 0.51 peak "
+                     "near step 35 → collapse (~0.13-0.14 in the last time bin) with a tail-bin agent-timeout rate of ≈80%, turns 40.5 → 53.3, "
+                     "and the step-48 values stored exactly (avg_raw_reward 0.107, avg_pass_at_8 0.281, entropy 0.072, grad norm 0.018). "
+                     "Released: step 45. Simulated: every other per-step value and the rollouts. Paper: timeouts get zero reward; the config "
+                     "masks AgentTimeoutError from training, so timed-out rollouts show reward 0 and 'not trained'."))
+    run_hero = kit.run_id(pid, "rl-pymethods2test")
+    w.add("run_events", {"run_id": run_hero, "t": hero_facts[36]["t"], "step": 36, "kind": "alert", "severity": "warning",
+                         "title": "Reward peaked; agent timeouts rising",
+                         "body": "Paper: reward 'peaks near step ~35 and then collapses'; the tail bin reaches an ≈80% agent-timeout rate. Completed-trial reward fell 0.652 → 0.541 while all-trial eval accuracy rose 0.19 → 0.33 (Table 22)."})
+    w.add("run_events", {"run_id": run_hero, "t": hero_facts[45]["end"], "step": 45, "kind": "notice", "severity": "info",
+                         "title": "Released checkpoint", "body": "laion/rl_swesmith-fixthink-pymethods2test-45 = open-thoughts/OpenThinkerAgent-8B-RL."})
+    ablation_runs = {"pymethods2test": (run_hero, 45, rl8, hero_end)}
+    t_next = hero_end + 86400
+    for key, title, domain, count, url, gkind, rkind, rank, swe100, tbl, tb2s, avg, se_, published in SOURCES[1:]:
+        env, _, _ = envs[key]
+        a, b = se_
+        # attempt() also ends about a quarter of the other failures at the turn limit, which terminus-2 reports as timeouts
+        tau0, tau1 = (0.08, 0.28) if key == "llm-verifier-freelancer" else (0.02, 0.06)
+        out = kit.model(w, pid, f"rl-{key}", f"RL on {key} (8B)", "checkpoint", arch="dense", params_total=8.19, parent_id=cold,
+                        run_key=f"rl-{key}", step=48, stage="RL", status="internal", notes=f"Source-ablation checkpoint (Table 9, rank {rank}).", source=PAPER)
+        facts, end = _rl_sim(
+            w, pid, f"rl-{key}", f"RL source ablation: {key} (8B)", env=env, base=cold, out=out, start=t_next, steps=48,
+            step_seconds=1.66e5 / 48 / 1.2, target=(lambda a, b: lambda s: a + (b - a) * (1 - math.exp(-3 * (s - 1) / 47)) / (1 - math.exp(-3)))(a, b),
+            timeouts=(lambda t0_, t1_: lambda s: t0_ + (t1_ - t0_) * (s - 1) / 47)(tau0, tau1), entropy=lambda s: 0.16 - 0.04 * (s - 1) / 47,
+            grad=lambda s: 0.03, turns=lambda s: 38 + 6 * (s - 1) / 47, tokens=lambda s: 9000 + 2000 * (s - 1) / 47, staleness=lambda s: 2.5,
+            store_groups=2, hyperparams=hp_rl, config=hero_cfg.replace("exp_rpt_pymethods2test-large", key), source=PAPER,
+            judge_scale=rkind == "scalar", tags=("source-ablation",), group_name="ot-agent-rl-sources",
+            anchors={1: a, 48: b} if published else None,
+            description=(f"Same recipe as the hero run ('every run uses identical hyperparameters and evaluation criteria'), only the task source changes: {title}. "
+                         + (f"Published: training reward {a:.2f} → {b:.2f}" + (" (read as ~0.54 → ~0.73)" if key == "llm-verifier-freelancer" else "") + "; "
+                            if published else "Training reward not published: the curve's endpoints are the demo's assumption; ")
+                         + f"final core-3 scores (Table 9, rank {rank}): SWE-bench Verified-100 {swe100}, OpenThoughts-TBLite {tbl}, Terminal-Bench 2.0 {tb2s}, raw average {avg}. "
+                         "Step count assumed equal to the hero run's 48; dates assumed; per-step values and rollouts simulated."))
+        ablation_runs[key] = (kit.run_id(pid, f"rl-{key}"), 48, out, end)
+        t_next = t_next + 2 * 86400
+
+    # task pass rates for the base (cold start) and the latest policy on each source
+    for key, title, domain, count, url, gkind, rkind, rank, *_rest in SOURCES:
+        env, se_, _ = envs[key]
+        if key == "pymethods2test":
+            kit.write_tasks(w, env, base_pass=0.47, latest_pass=hero_facts[45]["reward"], attempts=8)
+        else:
+            kit.write_tasks(w, env, base_pass=se_[0] if rkind != "scalar" else (8 * se_[0] - 1) / 6,
+                            latest_pass=se_[1] if rkind != "scalar" else (8 * se_[1] - 1) / 6, attempts=8)
+
+    # metric definitions
+    kit.metric_defs(w, pid, "skyrl", extra=[
+        {"tag": "reward/avg_raw_reward", "label": "Reward", "format": "num3", "grp": "learning", "better": "up", "pinned": 1, "signal": "reward",
+         "description": "Mean verifier reward over the step's 512 trajectories (timed-out trials count 0)."},
+        {"tag": "reward/avg_pass_at_8", "label": "Pass@8", "format": "pct", "grp": "learning", "better": "up", "signal": None,
+         "description": "Share of the step's 64 prompts with at least one of 8 attempts passing."},
+        {"tag": "env/timeout_rate", "label": "Agent timeouts", "format": "pct", "grp": "infra", "better": "down", "signal": "timeout_rate",
+         "description": "Share of trials ending in AgentTimeoutError (1,800 s). The hero run's tail bin reached ≈80%."},
+        {"tag": "env/truncated_rate", "label": "Context exceeded", "format": "pct", "grp": "length", "better": "down", "signal": "truncation_rate",
+         "description": "Share of trials ending in ContextLengthExceededError (32,768-token model context)."},
+        {"tag": "policy/policy_lr", "label": "Learning rate", "format": "sci", "grp": "stability", "better": "none", "signal": "lr", "description": "Constant 5e-6."},
+        {"tag": "generate/avg_turns", "label": "Turns", "format": "num1", "grp": "length", "better": "none", "signal": "turns", "description": "Agent turns per trial (unbounded; gated by the timeout)."},
+    ])
+    kit.metric_defs(w, pid, "trl_sft", extra=[
+        {"tag": "train/epoch", "label": "Epoch", "format": "num2", "grp": "progress", "better": "none", "signal": None, "description": "Epoch reached (trainer_state.json)."}])
+
+    # benchmarks ----------------------------------------------------------------------
+    swebv = tb["swebv"]
+    by_repo = defaultdict(list)
+    for x in swebv:
+        by_repo[x["repo"]].append(x)
+    quota = {repo: len(v) * 100 / 500 for repo, v in by_repo.items()}
+    alloc = {repo: int(q) for repo, q in quota.items()}
+    for repo in sorted(quota, key=lambda k_: -(quota[k_] - alloc[k_]))[: 100 - sum(alloc.values())]:
+        alloc[repo] += 1
+    swe100 = []
+    for repo, v in sorted(by_repo.items()):
+        n_ = alloc[repo]
+        swe100 += [v[int(i * len(v) / n_)] for i in range(n_)] if n_ else []
+
+    def names_bank(items, key_id="id", key_text=None):
+        return lambda _r, i: (items[i][key_id] if isinstance(items[i], dict) else items[i],
+                              (items[i].get(key_text) if key_text and isinstance(items[i], dict) else ""))
+
+    trials = _load("tb2_rl45_trials.json.gz")
+    tb2_names = tb["tb2"]
+    instr = {}
+    for t_ in trials:
+        if t_["instruction"] and t_["task"] not in instr:
+            instr[t_["task"]] = t_["instruction"]
+    tb2_items = [{"id": n_, "text": instr.get(n_) or ("Security-related Terminal-Bench 2.0 task; instruction not shown in the demo." if n_ in SEC_TB2 else "")} for n_ in tb2_names]
+    B = {}
+    for key, name, cat, n_, k_, bank, desc in (
+            ("tb2", "Terminal-Bench 2.0", "terminal", 89, 3, names_bank(tb2_items, "id", "text"),
+             "89 tasks, Harbor terminus-2 on Daytona (32K context, 16K output cap, proactive summarization at 2,048 tokens), n = 3 re-runs; scores are the max over Terminus-2 and the model's own harness."),
+            ("swebv", "SWE-bench Verified", "swe", 500, 3, names_bank(swebv, "id", "title"),
+             "500 tasks, n = 3, max over Terminus-2 and the model's own harness."),
+            ("swebv100", "SWE-bench Verified-100", "swe", 100, 3, names_bank(swe100, "id", "title"),
+             "The paper's 100-task dev subset, stratified by repository; which 100 is not listed, so the demo takes a repository-stratified 100 of the 500 as a stand-in. Terminus-2, n = 3."),
+            ("tblite", "OpenThoughts-TBLite", "terminal", 100, 3, names_bank(tb["tblite"]),
+             "100 tasks (40 easy / 26 medium / 26 hard / 8 extreme), r = 0.911 with Terminal-Bench 2.0; Terminus-2, n = 3. Some published scores are not multiples of 1/300 (excluded trials), so they are stored as given and the simulated per-task results average to the nearest representable value."),
+            ("tbdev", "OpenThoughts-TB-dev", "terminal", 70, 3, names_bank(tb["tbdev"]), "70 tasks; used for the v1 release and as the RL runs' validation set. n = 3 assumed."),
+            ("aider", "Aider Polyglot", "code", 225, 3, None, "225 tasks, n = 3 (held-out)."),
+            ("bfcl", "BFCL-Parity", "tool_use", 123, 3, None, "123 tasks, n = 3 (held-out)."),
+            ("medagent", "MedAgentBench", "agentic", 300, 3, None, "300 tasks, n = 3 (held-out)."),
+            ("gaia", "GAIA-127", "agentic", 127, 3, None, "127 tasks, n = 3 (held-out)."),
+            ("finance", "FinanceAgent-Terminal", "agentic", 50, 3, None, "50 tasks, n = 3 (held-out).")):
+        B[key] = benchmark(w, project_id=pid, key=key, name=name, category=cat, metric="accuracy", harness="Harbor terminus-2 (Daytona)",
+                           n_tasks=n_, k=k_, bank=bank, source=PAPER, description=desc + " Per-task results are simulated to match each published score.")
+    b_avg7 = benchmark(w, project_id=pid, key="avg7", name="Seven-benchmark average", category="agentic", metric="mean accuracy",
+                       harness="Harbor", n_tasks=7, k=1, source=PAPER, store_tasks=False,
+                       description="Mean of SWE-bench Verified, Terminal-Bench 2.0, Aider Polyglot, BFCL-Parity, MedAgentBench, GAIA-127 and FinanceAgent-Terminal (Tables 1 and 10). An index: no per-task results; SE combines the seven component SEs (√Σse² / 7).")
+    b_core3 = benchmark(w, project_id=pid, key="core3", name="Core-3 raw average (SWE-V-100, TBLite, TB2)", category="agentic", metric="mean accuracy",
+                        harness="Harbor terminus-2", n_tasks=3, k=1, source=PAPER, store_tasks=False,
+                        description="The paper's ablation index: mean of SWE-bench Verified-100, OpenThoughts-TBLite and Terminal-Bench 2.0 accuracies (Tables 9 and 11). SE combines the three component SEs.")
+
+    stamp = kit.ts("2026-06-01 00:00")
+
+    def ev(bkey, model_id, pct, who, *, run_id=None, step=None, started=None, src=PAPER, prov="mixed"):
+        b = B[bkey]
+        eid = eval_run(w, b, model_id=model_id, score=pct / 100, run_id=run_id, step=step, started=started or stamp, source=src,
+                       provenance=prov, key=f"{who}|{bkey}")
+        _fix_score(w, eid, pct / 100)
+        return eid
+
+    def index(bench, model_id, pct, who, parts, *, run_id=None, step=None, started=None):
+        eval_run(w, bench, model_id=model_id, score=pct / 100, raw=True, run_id=run_id, step=step, started=started or stamp,
+                 source=PAPER, provenance="published", key=f"{who}|{bench.name}", stderr=_stderr_of(w, parts))
+
+    order7 = ("swebv", "tb2", "aider", "bfcl", "medagent", "gaia", "finance")
+    table1 = [("ot-32b", ot32, (54.0, 26.2, 32.4, 85.9, 47.8, 23.6, 44.0), 44.8), ("nemotron-terminal-32b", refs["nemotron-terminal-32b"], (41.9, 25.1, 24.9, 69.1, 62.6, 22.3, 40.7), 40.9),
+              ("swe-lego-32b", refs["swe-lego-32b"], (51.0, 16.1, 30.1, 81.0, 36.2, 12.9, 15.3), 34.7), ("sera-32b", refs["sera-32b"], (49.4, 9.7, 26.7, 69.1, 15.6, 8.7, 17.3), 28.1),
+              ("sa-swe-32b", refs["sa-swe-32b"], (39.4, 16.2, 17.3, 74.8, 15.8, 11.5, 13.3), 26.9), ("deepswe", refs["deepswe"], (42.2, 4.9, 27.3, 77.2, 8.7, 16.5, 10.0), 26.7),
+              ("qwen3-32b", q32, (29.1, 7.5, 28.9, 68.3, 6.8, 9.7, 9.3), 22.8)]
+    table10 = [("ot-8b-rl", rl8, (31.9, 13.48, 18.1, 71.5, 31.1, 6.8, 22.7), 27.9), ("ot-sft-8b-100k", sft8_100k, (38.9, 10.9, 15.9, 65.9, 36.2, 6.6, 17.3), 27.4),
+               ("nemotron-terminal-8b", refs["nemotron-terminal-8b"], (22.1, 13.1, 12.6, 59.9, 48.6, 14.4, 11.3), 26.0), ("ot-sft-8b-10k", sft8_10k, (22.7, 7.9, 14.2, 79.4, 25.8, 5.5, 14.7), 24.3),
+               ("swe-lego-8b", refs["swe-lego-8b"], (37.6, 0.7, 3.7, 75.3, 5.0, 6.0, 1.3), 18.5), ("endless-terminals", refs["endless-terminals"], (12.5, 8.2, 18.8, 48.8, 18.4, 5.2, 10.0), 17.4),
+               ("qwen3-8b", q8, (13.2, 2.2, 11.7, 34.4, 3.8, 5.0, 1.3), 10.2)]
+    for who, mid, vals, avg in table1 + table10:
+        run_kw = {}
+        if who == "ot-8b-rl":
+            run_kw = {"run_id": run_hero, "step": 45, "started": hero_facts[45]["end"] + 3600}
+        elif who == "ot-32b":
+            run_kw = {"run_id": r_32, "step": 3600, "started": stamp}
+        parts = [ev(bk, mid, v, who, **run_kw) for bk, v in zip(order7, vals)]
+        index(b_avg7, mid, avg, who, parts, **run_kw)
+    # core-3 dev benchmarks: Table 9 (sources), Table 11 (starting points), card numbers, scale-up (Table 8)
+    for key, (run_id_, step_, out_, end_) in ablation_runs.items():
+        row = next(s for s in SOURCES if s[0] == key)
+        who = "ot-8b-rl" if key == "pymethods2test" else f"rl-{key}"
+        started = end_ + 3600
+        parts = []
+        for bk, v in (("swebv100", row[8]), ("tblite", row[9])):
+            parts.append(ev(bk, out_, v, who, run_id=run_id_, step=step_, started=started))
+        if key == "pymethods2test":
+            parts.append(w.conn.execute("SELECT id FROM evals WHERE run_id=? AND step=45 AND benchmark_id=?", (run_hero, B["tb2"].id)).fetchone()[0])
+        else:
+            parts.append(ev("tb2", out_, row[10], who, run_id=run_id_, step=step_, started=started))
+        index(b_core3, out_, row[11], who, parts, run_id=run_id_, step=step_, started=started)
+    cold_parts = [ev("swebv100", cold, 23.7, "cold", run_id=run_hero, step=0, started=kit.ts("2026-02-27 05:00")),
+                  ev("tblite", cold, 14.8, "cold", run_id=run_hero, step=0, started=kit.ts("2026-02-27 05:00")),
+                  ev("tb2", cold, 6.7, "cold", run_id=run_hero, step=0, started=kit.ts("2026-02-27 05:00"))]
+    index(b_core3, cold, 15.1, "cold", cold_parts, run_id=run_hero, step=0, started=kit.ts("2026-02-27 05:00"))
+    p10k = [ev("swebv100", sft8_10k, 24.3, "ot-sft-8b-10k"), ev("tblite", sft8_10k, 15.6, "ot-sft-8b-10k"),
+            w.conn.execute("SELECT id FROM evals WHERE model_id=? AND benchmark_id=?", (sft8_10k, B["tb2"].id)).fetchone()[0]]
+    index(b_core3, sft8_10k, 15.9, "ot-sft-8b-10k", p10k)
+    ev("swebv100", noSFT, 1.0, "nosft")
+    ev("tblite", noSFT, 7.8, "nosft")
+    w.add("evals", {"id": rid("eval", b_core3.id, "nosft"), "project_id": pid, "benchmark_id": b_core3.id, "model_id": noSFT, "run_id": None,
+                    "step": None, "status": "completed", "score": 0.036, "stderr": None, "n_tasks": 3, "k": 1, "n_infra": None,
+                    "started_at": stamp, "ended_at": stamp + 3600, "cost_usd": None, "config": None, "command": "", "source": PAPER,
+                    "provenance": "published"})
+    pq8 = [ev("swebv100", q8, 5.3, "qwen3-8b"), ev("tblite", q8, 1.3, "qwen3-8b"),
+           w.conn.execute("SELECT id FROM evals WHERE model_id=? AND benchmark_id=?", (q8, B["tb2"].id)).fetchone()[0]]
+    index(b_core3, q8, 2.7, "qwen3-8b", pq8)
+    ev("swebv100", sft8_100k, 39.7, "ot-sft-8b-100k")
+    ev("swebv100", ot32, 55.7, "ot-32b-card", run_id=r_32, step=3600, src=CARD_32B)
+    ev("tblite", ot32, 41.3, "ot-32b-card", run_id=r_32, step=3600, src=CARD_32B)
+    ev("swebv100", q32, 26.7, "qwen3-32b-card", src=CARD_32B)
+    ev("tblite", q32, 13.7, "qwen3-32b-card", src=CARD_32B)
+    for mix, vals in (("Top-4", (45.33, 36.90, 21.72)), ("Top-8", (49.00, 38.87, 22.85)), ("Top-16", (40.33, 33.14, 20.60))):
+        mid = kit.model(w, pid, f"scaleup-{mix}", f"32B SFT, {mix} source mix (100K scale-up ablation)", "checkpoint", arch="dense", params_total=32.76,
+                        parent_id=q32, stage="SFT", status="internal", notes=f"Table 8 scale-up: Qwen3-32B on 100K traces from the {mix} task sources. Top-4 was kept.", source=PAPER)
+        for bk, v in zip(("swebv100", "tblite", "tb2"), vals):
+            ev(bk, mid, v, f"scaleup-{mix}")
+    for who, mid, v in (("kimi-k25", refs["kimi-k25"], 40.1), ("glm5", refs["glm5"], 46.1), ("qwen35-27b", refs["qwen35-27b"], 40.1), ("glm47-fp8", refs["glm47-fp8"], 32.7)):
+        ev("tb2", mid, v, who)
+    v1_stamp = kit.ts("2025-12-04 00:00")
+    for who, mid, vals in (("v1-sft", v1sft, (16.1, 14.7, 4.9)), ("v1", v1, (17.3, 15.7, 4.9))):
+        for bk, v in zip(("tbdev", "swebv", "tb2"), vals):
+            ev(bk, mid, v, who, started=v1_stamp, src=BLOG_V1)
+
+    # real Terminal-Bench 2.0 trials of the released RL checkpoint -----------------------
+    b_pub = benchmark(w, project_id=pid, key="tb2-public-job", name="Terminal-Bench 2.0 · public trial logs (RL checkpoint, 2026-05-04 job)",
+                      version="2.0", category="terminal", metric="passed trials / trials", harness="Harbor terminus-2 (hosted vLLM)",
+                      n_tasks=89, k=3, bank=names_bank(tb2_items, "id", "text"), source=TB2_TRACES,
+                      description="Every trial of one public evaluation job of laion/rl_swesmith-fixthink-pymethods2test-45 (= OpenThinkerAgent-8B-RL): 265 trials over 89 tasks (87 × 3, 2 × 2). 34 passed (12.8% of trials); 122 SummarizationTimeoutError, 21 AgentTimeoutError, 2 ContextLengthExceededError and 1 VerifierTimeoutError are scored as failures, as in the paper. The paper reports 13.5% for this model. Real per-task results and transcripts; 12 security-related tasks keep outcomes only.")
+    by_task = defaultdict(list)
+    for t_ in trials:
+        by_task[t_["task"]].append(t_)
+    eval_id = rid("eval", b_pub.id, "rl45-public")
+    rows, rolls, trans, per = [], [], [], []
+    env_eval = rid("env", pid, "tb2-eval")
+    for i, t in enumerate(b_pub.tasks):
+        ts_ = by_task.get(t.name, [])
+        p_ = sum(1 for x in ts_ if x["result"] == "1.0")
+        per.append(p_ / max(1, len(ts_)))
+        rows.append({"eval_id": eval_id, "task_id": t.id, "task_name": t.name, "attempts": len(ts_), "passes": p_, "infra": 0,
+                     "score": round(p_ / max(1, len(ts_)), 4), "mean_turns": round(sum(x["n_assistant"] for x in ts_) / max(1, len(ts_)), 1),
+                     "mean_tokens": None})
+        for j, x in enumerate(sorted(ts_, key=lambda z: z["trial"])):
+            res = x["result"]
+            outcome, stop = {"1.0": ("passed", "submitted"), "0.0": ("failed", "submitted"), "AgentTimeoutError": ("timeout", "AgentTimeoutError"),
+                             "SummarizationTimeoutError": ("timeout", "SummarizationTimeoutError"),
+                             "ContextLengthExceededError": ("truncated", "ContextLengthExceededError"),
+                             "VerifierTimeoutError": ("timeout", "VerifierTimeoutError")}.get(res, ("failed", res))
+            ro = rid("roll", eval_id, t.name, j)
+            msgs = x["messages"] or [{"role": "note", "content": "Transcript withheld: security-related task. The demo keeps only its outcome."}]
+            rolls.append({"id": ro, "run_id": None, "eval_id": eval_id, "step": None, "phase": "eval", "group_id": rid("grp", eval_id, t.name),
+                          "sample": j, "task_id": t.id, "env_id": env_eval, "harness": "terminus-2", "model_id": rl8,
+                          "reward": 1.0 if outcome == "passed" else 0.0, "advantage": None, "scores": None, "outcome": outcome, "stop_reason": stop,
+                          "turns": x["n_assistant"], "tool_calls": sum(len(m.get("tool_calls") or []) for m in (x["messages"] or [])) or None,
+                          "tokens_in": None, "tokens_out": None, "tokens_cached": None, "duration_s": None, "timing": None, "staleness": 0,
+                          "flags": None, "seed": stable_seed(eval_id, t.name, j), "trained": 0})
+            trans.append({"rollout_id": ro, "messages": msgs})
+    mean_task = sum(per) / len(per)
+    sd = (sum((v - mean_task) ** 2 for v in per) / (len(per) - 1)) ** 0.5
+    score = sum(r_["passes"] for r_ in rows) / sum(r_["attempts"] for r_ in rows)  # 34 / 265, the share of trials
+    t_job = kit.ts("2026-05-04 23:44")
+    w.add("evals", {"id": eval_id, "project_id": pid, "benchmark_id": b_pub.id, "model_id": rl8, "run_id": None, "step": None,
+                    "status": "completed", "score": round(score, 5), "stderr": round(sd / math.sqrt(len(per)), 5), "n_tasks": 89, "k": 3,
+                    "n_infra": None, "started_at": t_job, "ended_at": t_job + 8 * 3600, "cost_usd": None,
+                    "config": {"agent": "terminus-2", "model": "hosted_vllm/laion/rl_swesmith-fixthink-pymethods2test-45", "trials": 265},
+                    "command": "", "source": TB2_TRACES, "provenance": "published"})
+    w.add_many("eval_tasks", rows)
+    w.add("environments", {"id": env_eval, "project_id": pid, "name": "Terminal-Bench 2.0 (evaluation harness)", "domain": "terminal", "version": "2.0",
+                           "harness": "terminus-2 (Harbor)", "description": "Held-out benchmark, not used for training. Stored as an environment so the 265 real trials of the RL checkpoint link to task text. Latest pass rate: the checkpoint's per-task rate in the public job; base: not measured.",
+                           "tools": ["keystrokes"], "grader_id": graders["pytest"], "reward_kind": "binary",
+                           "sandbox": {"provider": "Daytona"}, "task_count": 89, "created_at": t_job, "source": TB2_TRACES, "provenance": "published", "checks": None})
+    w.add_many("tasks", [{"id": t.id, "env_id": env_eval, "name": t.name, "instruction": t.instruction, "difficulty": None, "tags": [],
+                          "status": "ok", "status_reason": "", "oracle_score": None, "noop_score": None, "reruns": 0, "rerun_agree": None,
+                          "base_pass": None, "latest_pass": round(per[i], 3), "attempts": rows[i]["attempts"]} for i, t in enumerate(b_pub.tasks)])
+    w.add_many("rollouts", rolls)
+    w.add_many("transcripts", trans)
+
+    # operations ---------------------------------------------------------------------------
+    cl_jup = kit.cluster(w, org_id, "jupiter", "JUPITER Booster (4 × GH200 per node)", "Jülich Supercomputing Centre", gpu="GH200", gpus=96)
+    cl_nersc = kit.cluster(w, org_id, "perlmutter", "NERSC Perlmutter (4 × A100-80GB per node)", "NERSC", gpu="A100-80GB", gpus=24)
+    cl_day = kit.cluster(w, org_id, "daytona", "Daytona sandboxes", "Daytona")
+    for rid_, name, cl, gpus in ((r_32, "OpenThinkerAgent-32B SFT", cl_jup, 96), (r_g1, "SFT on the 100K set (8B)", cl_jup, 96)):
+        r_ = w.conn.execute("SELECT started_at, ended_at, status FROM runs WHERE id=?", (rid_,)).fetchone()
+        w.add("jobs", {"id": rid("job", rid_, "train"), "project_id": pid, "run_id": rid_, "eval_id": None, "name": f"{name} · trainer",
+                       "kind": "train", "status": r_[2], "cluster_id": cl, "gpu": "GH200", "gpus": gpus, "nodes": gpus // 4, "started_at": r_[0],
+                       "ended_at": r_[1], "cost_usd": None, "exit": r_[2], "log_tail": ""})
+    for key, (rid_, _, _, end_) in ablation_runs.items():
+        r_ = w.conn.execute("SELECT started_at, name FROM runs WHERE id=?", (rid_,)).fetchone()
+        w.add("jobs", {"id": rid("job", rid_, "train"), "project_id": pid, "run_id": rid_, "eval_id": None, "name": f"{r_[1]} · policy + reference (2 nodes)",
+                       "kind": "train", "status": "completed", "cluster_id": cl_nersc, "gpu": "A100-80GB", "gpus": 8, "nodes": 2,
+                       "started_at": r_[0], "ended_at": end_, "cost_usd": None, "exit": "completed", "log_tail": ""})
+        w.add("jobs", {"id": rid("job", rid_, "infer"), "project_id": pid, "run_id": rid_, "eval_id": None, "name": f"{r_[1]} · vLLM inference (4 nodes, 16 engines)",
+                       "kind": "rollout", "status": "completed", "cluster_id": cl_nersc, "gpu": "A100-80GB", "gpus": 16, "nodes": 4,
+                       "started_at": r_[0], "ended_at": end_, "cost_usd": None, "exit": "completed", "log_tail": ""})
+        w.add("jobs", {"id": rid("job", rid_, "sandboxes"), "project_id": pid, "run_id": rid_, "eval_id": None, "name": f"{r_[1]} · Daytona trials (280 concurrent)",
+                       "kind": "rollout", "status": "completed", "cluster_id": cl_day, "gpu": None, "gpus": None, "nodes": None,
+                       "started_at": r_[0], "ended_at": end_, "cost_usd": None, "exit": "completed",
+                       "log_tail": "1 vCPU / 2 GB RAM / 2 GB storage per trial; 3 retries with 60-600 s backoff."})
+
+    # reports ----------------------------------------------------------------------------------
+    kit.report(w, pid, "rl-sources", "RL task source moves results more than rerun noise, with a caveat", "OpenThoughts-Agent (claims) · demo (evidence)",
+               kit.ts("2026-06-23 00:00"),
+               "Eight RL runs from the same cold-start 8B model with identical settings, differing only in the task source, span 7.6 points of core-3 raw average. The paper compares that with a 2.0-point rerun spread measured on different benchmarks; on the same benchmarks the rerun spread is 1.6 points.",
+               [{"claim": "Across eight task sources the core-3 raw average (SWE-bench Verified-100, OpenThoughts-TBLite, Terminal-Bench 2.0) spans 7.6 points: pymethods2test 21.72 to nl2bash 14.08.", "verdict": "upheld",
+                 "evidence": f"Table 9 ({PAPER}): pymethods2test 21.72, r2egym 17.42, nemotron-code-oracle 16.17, inferredbugs 15.56, llm-verifier-freelancer 15.27, swesmith 15.12, code-contests 15.10, nl2bash 14.08."},
+                {"claim": "'Source ablation spans a 7.6-point range in raw average accuracy, larger than the 2.0-point run-to-run reproducibility variance.'", "verdict": "open",
+                 "evidence": "The two numbers are not measured on the same set: 7.6 is the in-distribution core-3 range across sources; 2.0 is the out-of-distribution range across three near-replicate pymethods2test runs (Table 20). 'Replicate RL runs differ by only ≈1.6 points on ID and ≈2.0 points on OOD.'"},
+                {"claim": "On the same in-distribution benchmarks, the spread across sources (7.6) is larger than the spread across reruns (1.6).", "verdict": "upheld",
+                 "evidence": "Table 20 replicates, core-3 raw average: pymethods2test-45 21.72, 10-step variant 21.19, lr 5e-6 variant 19.68 (the paper calls 5e-6 non-default, yet the hero config also uses 5e-6)."},
+                {"claim": "Beyond the top source, the other seven are not clearly separated.", "verdict": "upheld",
+                 "evidence": "Ranks 2-8 lie within 3.3 points (17.42 → 14.08), about twice the 1.6-point rerun spread, with n = 3 per task; ranks 4 and 5 are even inverted between raw average (15.27 vs 15.56) and the paper's z-score ranking."},
+                {"claim": "pymethods2test wins because its tasks are single-function Python contracts with synthesized docstrings and auto-generated unittest suites that are reproducible and share one build environment.", "verdict": "open",
+                 "evidence": "The paper's explanation; no controlled ablation of these properties is published."},
+                {"claim": "The starting point matters more than the source: RL from the cold-start SFT reaches 21.7, RL directly on Qwen3-8B 3.6.", "verdict": "upheld",
+                 "evidence": "Table 11: ColdSFT+RL 21.7, SFT-8B (10K) 15.9, ColdSFT 15.1, RL on Qwen3-8B (no SFT) 3.6, Qwen3-8B 2.7."}],
+               run_keys=("rl-pymethods2test",) + tuple(f"rl-{s[0]}" for s in SOURCES[1:]))
+    kit.report(w, pid, "hero-rl", "The hero RL run: better evals, collapsing training reward", "OpenThoughts-Agent (claims) · demo (evidence)",
+               kit.ts("2026-06-23 00:00"),
+               "RL on pymethods2test lifted every core benchmark over the cold start, while its training reward peaked near step 35 and collapsed with agent timeouts; the release is step 45.",
+               [{"claim": "RL improved the cold-start model on all three core benchmarks.", "verdict": "upheld",
+                 "evidence": "Table 11 / Table 9: SWE-bench Verified-100 23.7 → 35.67, OpenThoughts-TBLite 14.8 → 16.02, Terminal-Bench 2.0 6.7 → 13.48; seven-benchmark average 27.9 against 10.2 for Qwen3-8B."},
+                {"claim": "Training reward peaked near step 35 and then collapsed, with about 80% of trials ending in agent timeouts in the last time bin.", "verdict": "upheld",
+                 "evidence": "Figure 6 / Table 22: 'RL-time reward trajectory 0.47 → 0.51 peak → 0.14 collapse', 'tail-bin agent-timeout rate ≈ 80%'; step-48 avg_raw_reward 0.107."},
+                {"claim": "Eval accuracy kept rising while the reward of completed trials fell.", "verdict": "upheld",
+                 "evidence": "Table 22: completed-trial reward 0.652 → 0.541 while all-trial eval accuracy rose 0.19 → 0.33; the paper reads it as exploration bought at the cost of stability."},
+                {"claim": "After RL the agent thinks longer and takes more turns.", "verdict": "upheld",
+                 "evidence": "Think tokens 30.3 → 65.4, turns 40.5 → 53.3, tool calls 31.3 → 40.9, tool-error rate 31.6% → 35.8%; a gpt-5 pairwise judge preferred the post-RL traces in 25 of 30 pairs."},
+                {"claim": "A public Terminal-Bench 2.0 job of the released checkpoint reproduces the paper's 13.5%.", "verdict": "open",
+                 "evidence": f"The public job ({TB2_TRACES}) passes 34 of 265 trials (12.8%); 122 trials end in SummarizationTimeoutError. The paper's number is the max over harnesses, so the protocols differ."}],
+               run_keys=("rl-pymethods2test", "coldstart-fixthink"))
+    kit.report(w, pid, "sft-recipe", "What the 100+ SFT ablations chose", "OpenThoughts-Agent (claims) · demo (evidence)", kit.ts("2026-06-23 00:00"),
+               "Each ablation fine-tuned Qwen3-8B on 10K GLM-4.7-AWQ traces; results are the raw mean of SWE-bench Verified-100, OpenThoughts-TBLite and Terminal-Bench 2.0.",
+               [{"claim": "Task source is the largest lever: 95 sources span swe-smith 18.78 (rank 1) to AgentTuning-OS 2.00; TB2 alone ranges 10.9% to 0.4%.", "verdict": "upheld", "evidence": f"Paper §4 ({PAPER})."},
+                {"claim": "Mixing the top-4 sources beats a single source.", "verdict": "upheld", "evidence": "Top-4 18.19, Top-2 18.08, Top-8 17.49, Top-1 16.65."},
+                {"claim": "No LLM-driven task augmentation reliably beats the un-augmented tasks.", "verdict": "upheld", "evidence": "Original 15.62 against, for example, harden 12.34."},
+                {"claim": "A stronger model is not a better teacher.", "verdict": "upheld",
+                 "evidence": "Kimi K2.5 18.59, GLM 5 18.27, GLM 4.7 AWQ 18.16, GLM 4.6 AWQ 16.45, GPT-5.3-Codex 11.94 (GLM-4.7-AWQ kept)."},
+                {"claim": "Filtering tasks by GPT-5 response length and traces by at least 5 turns helps.", "verdict": "upheld",
+                 "evidence": "Longest-response task filter 17.43 vs random 14.10 (~3 points); min turns ≥ 5: 19.90, filter timeouts 18.39, filter subagent traces 17.06."},
+                {"claim": "At 32B and 100K traces the top-4 mix is best.", "verdict": "open",
+                 "evidence": "Scale-up (Table 8): Top-8 49.00 / 38.87 / 22.85 beats Top-4 45.33 / 36.90 / 21.72 on all three benchmarks, Top-16 40.33 / 33.14 / 20.60; the paper nevertheless keeps Top-4 ('did not reliably help')."}],
+               run_keys=("sft-32b-100k", "sft-8b-100k"))
+    kit.report(w, pid, "ops", "Operations incidents and release mismatches", "OpenThoughts-Agent (docs) · demo", kit.ts("2026-09-02 00:00"),
+               "Documented problems in the RL pipeline and the public releases.",
+               [{"claim": "A Harbor bug made one batch of RL jobs produce 0.0 rewards while still writing checkpoints.", "verdict": "upheld",
+                 "evidence": f"RL_PIPELINE.md ({RL_PIPE}): 'Example from 2026-03-11: The _environment_definition_path bug caused batch 4 (Slurm 270441-270446) to produce 0.0 rewards but still write checkpoints'; fixed by rolling back to healthy steps. Which runs were affected is not listed."},
+                {"claim": "Missing Daytona snapshots make every trial build its Dockerfile and hit rate limits.", "verdict": "upheld", "evidence": "RL_PIPELINE.md: 'ThrottlerException: Too Many Requests'; a wrong API key gives 'Region not found'."},
+                {"claim": "Most task-generation 'failures' are infrastructure, not the agent.", "verdict": "upheld", "evidence": f"DATASET_GENERATION.md ({DS_GEN}): '50-80% of failures are DaytonaError, EnvironmentStartTimeoutError, or AgentTimeoutError'."},
+                {"claim": "code-contests verifiers biased rewards toward 1.0 by dropping failed checks.", "verdict": "upheld", "evidence": f"TaskTrove card ({TASKTROVE}): RewardFileNotFoundError was dropped instead of scored 0; fixed in v3.1."},
+                {"claim": "The public releases differ from the paper's description.", "verdict": "upheld",
+                 "evidence": "OpenThinkerAgent-32B is step 3,600 of 4,520; the released cold-start 8B is not the '-fixthink' RL start; the SFT set has 94,334 rows although labelled 100K; public llm-verifier-freelancer tasks embed a hard-coded API key."}])
+    return {"project_id": pid, "org_id": org_id}
diff --git a/viewer/build/labs/prime.py b/viewer/build/labs/prime.py
new file mode 100644
index 0000000000000000000000000000000000000000..4fc00639d7c7647d3e39ab59ad5e2c9327ce6f82
--- /dev/null
+++ b/viewer/build/labs/prime.py
@@ -0,0 +1,732 @@
+"""Prime Intellect: INTELLECT-3 (GLM-4.5-Air-Base → two SFT stages → async RL on prime-rl), INTELLECT-3.1 as far as
+published, and the public hosted runs on Prime Intellect Lab.
+
+Published (inputs/prime, see SOURCE.md, and the numbers written below next to their source): the report's recipe and
+Table 2 scores, the SFT and RL datasets' sizes and real rows, the environments' task counts, graders and real task texts;
+every metric step and every stored sample rollout (with transcript) of five hosted Lab runs. Simulated: the INTELLECT-3
+SFT and RL curves and rollouts (no logs are public), per-task results behind published scores, dates.
+"""
+import gzip
+import json
+import math
+import random
+from collections import defaultdict
+from pathlib import Path
+
+from .. import kit
+from ..sim import rid, rng, solve_skill, stable_seed
+from ..training import benchmark, env_metric_defs, eval_run, rl_run, sft_run
+
+INPUTS = Path(__file__).resolve().parent.parent / "inputs" / "prime"
+REPORT = "https://storage.googleapis.com/intellect-3-paper/INTELLECT_3_Technical_Report.pdf"
+BLOG = "https://www.primeintellect.ai/blog/intellect-3"
+CARD = "https://huggingface.co/PrimeIntellect/INTELLECT-3"
+CARD31 = "https://huggingface.co/PrimeIntellect/INTELLECT-3.1"
+CARD_BASE = "https://huggingface.co/PrimeIntellect/INTELLECT-3-Base"
+SFT_DS = "https://huggingface.co/datasets/PrimeIntellect/INTELLECT-3-SFT"
+RL_DS = "https://huggingface.co/datasets/PrimeIntellect/INTELLECT-3-RL"
+DEEPDIVE = "https://huggingface.co/datasets/zai-org/DeepDive"
+R2E = "https://huggingface.co/datasets/R2E-Gym/R2E-Gym-Subset"
+ENVS = "https://github.com/PrimeIntellect-ai/community-environments/tree/7c0ed712714236e48239f957921203e8dae04fda/environments"
+EVAL_CFG = "https://github.com/PrimeIntellect-ai/prime-rl/tree/34ac604392d0/configs/intellect_3/evals"
+EX31 = "https://github.com/PrimeIntellect-ai/prime-rl/blob/63331ad8b170/examples/Intellect-3.1/rl.toml"
+NEMO_BLOG = "https://www.primeintellect.ai/blog/nemotron-3"
+DOCS = "https://github.com/PrimeIntellect-ai/prime-rl/blob/7d25aaa0d24685dfee6a67d347d474e984c0381d/docs/training.md"
+HUB = "https://app.primeintellect.ai/dashboard/environments"
+PI_TXT = 450  # characters of task text kept in the demo
+
+
+def _load(name):
+    with gzip.open(INPUTS / name, "rt") as fh:
+        return json.load(fh)
+
+
+def _fix_score(w, eval_id, value):
+    """Keep a published score exactly when simulated per-task results can only approximate it."""
+    w.conn.execute("UPDATE evals SET score=? WHERE id=?", (round(value, 5), eval_id))
+
+
+def _logit(p):
+    p = min(0.98, max(0.02, p))
+    return math.log(p / (1 - p))
+
+
+def _cut(s, n=PI_TXT):
+    s = (s or "").strip()
+    return s if len(s) <= n else s[:n].rstrip() + " …"
+
+
+def _sft(w, pid, key, *, tags_to=None, drop=("eval/loss",), **kw):
+    """training.sft_run, then prime-rl's own tag names (loss/mean, optim/lr, …) and framework label."""
+    out = sft_run(w, project_id=pid, key=key, framework="trl_sft", **kw)
+    run_id = out["run_id"]
+    for tag in drop:
+        w.conn.execute("DELETE FROM metrics WHERE run_id=? AND tag=?", (run_id, tag))
+    for a, b in (tags_to or {}).items():
+        w.conn.execute("UPDATE metrics SET tag=? WHERE run_id=? AND tag=?", (b, run_id, a))
+    w.conn.execute("UPDATE runs SET framework='prime-rl (SFT trainer)', primary_metric='loss/mean' WHERE id=?", (run_id,))
+    return out
+
+
+PRIME_SFT_TAGS = {"train/loss": "loss/mean", "train/learning_rate": "optim/lr", "train/grad_norm": "optim/grad_norm",
+                  "train/tokens_per_second": "perf/throughput", "train/num_tokens": "progress/num_tokens"}
+
+
+def _intellect3(w, org_id, now):
+    pid = kit.project(
+        w, org_id, "intellect-3", "INTELLECT-3",
+        "INTELLECT-3: GLM-4.5-Air-Base (106B MoE, 12B active) → SFT on general reasoning → agentic SFT → large-scale asynchronous RL with prime-rl on Environments Hub environments (math, code, science, logic, deep research, SWE). INTELLECT-3.1 continued the RL.",
+        [{"title": "INTELLECT-3 technical report", "url": REPORT}, {"title": "INTELLECT-3 blog", "url": BLOG},
+         {"title": "INTELLECT-3 model card", "url": CARD}, {"title": "INTELLECT-3.1 model card", "url": CARD31},
+         {"title": "INTELLECT-3-SFT", "url": SFT_DS}, {"title": "INTELLECT-3-RL", "url": RL_DS},
+         {"title": "Environment sources (pre-cleanup commit)", "url": ENVS}, {"title": "prime-rl INTELLECT-3 eval configs", "url": EVAL_CFG},
+         {"title": "prime-rl INTELLECT-3.1 example", "url": EX31}, {"title": "prime-rl metrics guide", "url": DOCS},
+         {"title": "Environments Hub", "url": HUB}],
+        "No training logs of INTELLECT-3 or INTELLECT-3.1 are public (the report shows curves only as figures). The SFT and RL "
+        "runs here are simulated with the report's recipe (256 prompts × 16 rollouts, 65,536 context, max_off_policy_steps 8, "
+        "Muon lr 1e-6, 60 nodes of 8 H200, ~1,500 s per step) and end at the published Table 2 scores; values read off the "
+        "report's figures are marked approximate. The RL environment mix and per-environment rewards are not published and are "
+        "the demo's assumption. Datasets, task counts, graders and task texts are real (2,000 real rows per environment). "
+        "Dates are placed within the two months the report gives; no costs are published.",
+        kit.ts("2025-09-09 00:00"), pins=["reward/mean", "metrics/correct", "mismatch_kl/mean", "loss/mean"])
+
+    # models -----------------------------------------------------------------
+    air_base = kit.model(w, pid, "glm-4.5-air-base", "GLM-4.5-Air-Base", "base", hf_repo="zai-org/GLM-4.5-Air-Base", arch="MoE",
+                         params_total=106, params_active=12, context_len=131072, created_at=kit.ts("2025-07-20 00:00"),
+                         notes="Z.ai base model: 106B total, 12B active; 46 layers, 128 routed experts + 1 shared, 8 per token. The HF checkpoint holds 110,468,824,832 parameters, probably including the MTP layer.",
+                         source="https://huggingface.co/zai-org/GLM-4.5-Air-Base")
+    i3_base = kit.model(w, pid, "intellect-3-base", "INTELLECT-3-Base", "base", hf_repo="PrimeIntellect/INTELLECT-3-Base", arch="MoE",
+                        params_total=106, params_active=12, context_len=131072, parent_id=air_base, created_at=kit.ts("2025-09-09 00:00"),
+                        notes="'A clone of GLM-4.5-Air-Base model with a custom chat template adapted from Qwen3-Coder'. The INTELLECT-3.1 prime-rl example starts from it.",
+                        source=CARD_BASE)
+    sft1 = kit.model(w, pid, "sft-1", "INTELLECT-3 SFT stage 1 (unreleased)", "checkpoint", arch="MoE", params_total=106, params_active=12,
+                     parent_id=i3_base, run_key="sft-1", stage="SFT", status="internal", notes="General chat and reasoning SFT at 65K context.", source=REPORT)
+    sft2 = kit.model(w, pid, "sft-2", "INTELLECT-3 SFT stage 2 (unreleased)", "checkpoint", arch="MoE", params_total=106, params_active=12,
+                     parent_id=sft1, run_key="sft-2", stage="SFT", status="internal", notes="Agentic SFT at up to 98K context; the RL starting point.", source=REPORT)
+    i3 = kit.model(w, pid, "intellect-3", "INTELLECT-3", "checkpoint", hf_repo="PrimeIntellect/INTELLECT-3", arch="MoE", params_total=106,
+                   params_active=12, context_len=131072, parent_id=sft2, run_key="rl", step=300, stage="RL", created_at=kit.ts("2025-11-26 12:00"),
+                   status="released",
+                   notes="'106B (A12B) parameter Mixture-of-Experts reasoning model post-trained from GLM-4.5-Air-Base using SFT followed by large-scale RL'. HF safetensors 106,852,251,264 parameters; always reasons; serve with the qwen3_coder tool parser and deepseek_r1 reasoning parser (BF16 on 2 × H200). MIT. The RL step it was taken from is not stated; step 300 is the demo run's last step.",
+                   source=CARD)
+    kit.model(w, pid, "intellect-3-fp8", "INTELLECT-3-FP8", "checkpoint", hf_repo="PrimeIntellect/INTELLECT-3-FP8", arch="MoE", context_len=131072,
+              parent_id=i3, stage="quantized", created_at=kit.ts("2025-11-26 12:00"), status="released",
+              notes="FP8 variant; 'can be served on a single H200'.", source="https://huggingface.co/PrimeIntellect/INTELLECT-3-FP8")
+    i31 = kit.model(w, pid, "intellect-3.1", "INTELLECT-3.1", "checkpoint", hf_repo="PrimeIntellect/INTELLECT-3.1", arch="MoE", params_total=106,
+                    params_active=12, context_len=131072, parent_id=i3, stage="RL", created_at=kit.ts("2026-01-20 12:00"), status="released",
+                    notes=("'Built as a continued training of INTELLECT-3 with additional reinforcement learning on math, coding, software "
+                           "engineering, and agentic tasks' (card). No report, no eval table, no step count or compute published, so no run is shown. "
+                           "Prime's docs say the prime-rl example 'reproduces our INTELLECT-3.1 training run': 2,048 rollouts per step (oversampling 2), "
+                           "environment ratios 0.3 / 0.2 / 0.3 / 0.2 / 0.2 over mini-swe-agent-plus, deepdive, math-env, logic-env and code-env, "
+                           "Muon lr 1e-6, sequence length 131,072, 4 trainer + 12 inference nodes, online difficulty filtering, evals every 25 steps on "
+                           "SWE-Bench-Verified-Quick and AIME 2025. That example starts from INTELLECT-3-Base, which conflicts with the card."),
+                    source=CARD31)
+    pre31 = kit.model(w, pid, "intellect-3.1-pre-deepdive", "INTELLECT-3.1 run, before DeepDive training", "checkpoint", arch="MoE", parent_id=i3,
+                      stage="RL", status="internal",
+                      notes="The checkpoint the Nemotron-3 blog measures before training on DeepDive ('lifted BrowseComp from 7.8%'). Which checkpoint it is, is not stated.",
+                      source=NEMO_BLOG)
+    r1 = kit.model(w, pid, "deepseek-r1-0528", "DeepSeek R1 0528", "teacher", hf_repo="deepseek-ai/DeepSeek-R1-0528", arch="MoE",
+                   notes="Generated the reasoning traces of the stage-1 SFT sources and the stage-2 Environments Mix; also a Table 2 baseline (official API via OpenRouter).", source=REPORT)
+    kit.model(w, pid, "compassverifier-7b", "CompassVerifier-7B", "judge", hf_repo="opencompass/CompassVerifier-7B", arch="dense", params_total=7,
+              notes="Re-checks math answers the rule-based verifier marked wrong ('a non-negligible fraction of false negatives').", source=REPORT)
+    refs = {"GLM-4.5-Air": kit.model(w, pid, "glm-4.5-air", "GLM-4.5-Air", "external", arch="MoE", params_total=106, params_active=12,
+                                     notes="Z.ai's own post-trained model on the same base; OpenRouter → official z-AI API, temperature 0.6.", source=REPORT),
+            "GLM-4.5": kit.model(w, pid, "glm-4.5", "GLM-4.5", "external", arch="MoE", notes="OpenRouter → official z-AI API, temperature 0.6.", source=REPORT),
+            "GLM-4.6": kit.model(w, pid, "glm-4.6", "GLM-4.6", "external", arch="MoE", notes="OpenRouter → official z-AI API, temperature 0.6; HLE as reported by the AA Index.", source=REPORT),
+            "DeepSeek R1 0528": r1,
+            "DeepSeek v3.2": kit.model(w, pid, "deepseek-v3.2", "DeepSeek v3.2", "external", arch="MoE", notes="Official API (deepseek-reasoner).", source=REPORT),
+            "GPT-OSS 120B (high)": kit.model(w, pid, "gpt-oss-120b", "GPT-OSS 120B (high)", "external", arch="MoE",
+                                             notes="Served by TogetherAI because OpenRouter ran it at a lower reasoning effort.", source=REPORT)}
+
+    # datasets ------------------------------------------------------------------
+    sft_sources = [("openreasoning_math (Nemotron-Post-Training-Dataset-v1 math)", "math", 2044407), ("openreasoning_code (OpenCodeReasoning-2)", "code", 1896395),
+                   ("openreasoning_science (OpenScienceReasoning-2)", "science", 1600812), ("openreasoning_tool (Nemotron-Post-Training-Dataset-v1 tool_calling)", "tool_use", 310051),
+                   ("am_chat (AM-DeepSeek-R1-0528-Distilled)", "chat", 952046), ("am_if (AM-DeepSeek-R1-0528-Distilled)", "if", 54720),
+                   ("swe_swiss (SWESwiss-SFT-Merged-10K), stage 2 only", "swe", 10254), ("toucan_tool (Toucan-1.5M SFT subset), stage 2 only", "tool_use", 115724)]
+    ds_sft = kit.dataset(
+        w, pid, "i3-sft", "INTELLECT-3-SFT", "sft", rows=6984409, hf_repo="PrimeIntellect/INTELLECT-3-SFT",
+        description="The released SFT mix: 6,984,409 rows over 8 configs (HF). Report Table 1 gives about 6.0M examples for stage 1 and adds a 38.4K-example Environments Mix for stage 2. Two row counts disagree with Table 1 (science 1,600,812 vs 310K; tool 310,051 vs 800K), and Table 1's token column is close to the HF byte sizes, so it may be bytes.",
+        sources=[{"name": n, "category": c, "rows": r_, "synthetic": True, "generator": "DeepSeek-R1-0528" if i < 6 else None, "url": SFT_DS}
+                 for i, (n, c, r_) in enumerate(sft_sources)],
+        processing=[{"step": "report Table 1 (examples / tokens)", "rows_in": None, "rows_out": None,
+                     "note": "OpenReasoning-Math 2M / 78.1B; -Code 1.9M / 94.3B; -Science 310K / 32B; -Tool 800K / 3.8B; AM General Chat 952K / 8.4B; AM Instruction Following 54K / 400M; SWE Swiss 10.3K / 700M; Toucan Tool 116K / 700M; Environments Mix 38.4K / 1.9B."},
+                    {"step": "tool-call formatting, English filter, standardisation (stage 2)", "rows_in": None, "rows_out": None,
+                     "note": "'All datasets were processed to ensure consistent tool call formatting, filtered for English content, and standardized so that they are compatible with our trainer.'"}],
+        samples=[{"source": "am_chat", "category": "chat", "data": {"messages": [
+                     {"role": "user", "content": "Find any typos or grammatical errors in the sentence and edit it accordingly. She was to excited to notice her mistake."},
+                     {"role": "assistant", "content": "<think>…</think> Corrected sentence: She was too excited to notice her mistake."}]}},
+                 {"source": "toucan_tool", "category": "tool_use", "data": {"messages": [
+                     {"role": "user", "content": "I want to host a 'Two Truths and a Twist' round that references the current market price of Ethereum. Could you fetch the latest ETH price in USDT and then create a round where the price-related statement is the twist?"},
+                     {"role": "assistant", "content": "I'll fetch the latest Ethereum price first.", "tool_calls": [{"id": "c1", "name": "coin-price-fetcher-getTokenPrice", "arguments": "{\"symbol\": \"ETH\"}"}]},
+                     {"role": "tool", "tool_call_id": "c1", "name": "coin-price-fetcher-getTokenPrice", "content": "4043.72"},
+                     {"role": "assistant", "content": "", "tool_calls": [{"id": "c2", "name": "two-truths-and-a-twist-create_round", "arguments": "{…}"}]},
+                     {"role": "tool", "tool_call_id": "c2", "name": "two-truths-and-a-twist-create_round", "content": "Round created successfully with ID: 6"}]}},
+                 {"source": "swe_swiss", "category": "swe", "data": {"messages": [
+                     {"role": "user", "content": "We are currently solving the following issue within our repository… Tags not being applied when creating a database in Glue"},
+                     {"role": "assistant", "content": "<think>We are given an issue: Tags not being applied when creating a database in Glue… (14,289 characters)"}]}}],
+        created_at=kit.ts("2025-11-28 00:00"), source=SFT_DS)
+    ds_sft1 = kit.dataset(w, pid, "i3-sft-stage1", "INTELLECT-3 SFT stage-1 mix", "sft", rows=6858431, parent_key="i3-sft", version="stage 1",
+                          description="The six stage-1 configs (math, code, science, tool, AM chat, AM IF) 'at natural ratios', one epoch at 65K context.",
+                          processing=[{"step": "select stage-1 configs", "rows_in": 6984409, "rows_out": 6858431, "note": "Excludes swe_swiss and toucan_tool (stage 2 only)."}],
+                          source=REPORT)
+    ds_envmix = kit.dataset(w, pid, "env-mix", "Environments Mix (agentic SFT traces)", "sft", rows=38400,
+                            description="Synthetic trajectories generated with DeepSeek-R1-0528 in Environments Hub environments; stage 2 only; which environments is not listed; not released.",
+                            sources=[{"name": "trajectories generated in Environments Hub environments", "category": "agentic", "rows": 38400, "synthetic": True, "generator": "DeepSeek-R1-0528"}],
+                            processing=[{"step": "report Table 1", "rows_in": None, "rows_out": 38400, "note": "38.4K examples, 1.9B tokens."}],
+                            source=REPORT, provenance="published")
+    rows = _load("i3_rl_rows.json.gz")
+    ds_math = kit.dataset(w, pid, "i3-rl-math", "INTELLECT-3-RL / math", "rl_prompts", rows=21161, hf_repo="PrimeIntellect/INTELLECT-3-RL",
+                          description="Curated from Skywork-OR1, AceReason-Math, DAPO and ORZ-Hard; difficulty-annotated with Qwen3-4B-Thinking-2507 (8 generations).",
+                          sources=[{"name": "Skywork-OR1, AceReason-Math, DAPO, ORZ-Hard (curated)", "category": "math", "rows": 21161, "synthetic": False, "url": RL_DS}],
+                          processing=[{"step": "difficulty annotation", "rows_in": None, "rows_out": 21161, "note": "avg@8 of Qwen3-4B-Thinking-2507 (and -Instruct-2507)."},
+                                      {"step": "filter_by_pass_rate", "rows_in": 21161, "rows_out": None, "note": "'filter out samples which are too easy at various stages'; thresholds not published. The math split has 21,161 rows in every HF revision; the env README says '24k train examples (pre-filtering)'."}],
+                          samples=[{"source": "math", "category": "math", "data": {"prompt": x["q"], "answer": x["a"], "avg@8_qwen3_4b_thinking": x["p_think"]}} for x in rows["math"][:6]],
+                          created_at=kit.ts("2025-11-07 00:00"), source=RL_DS)
+    ds_code = kit.dataset(w, pid, "i3-rl-code", "INTELLECT-3-RL / code", "rl_prompts", rows=8579, hf_repo="PrimeIntellect/INTELLECT-3-RL",
+                          description="SYNTHETIC-2-based, DeepCoder-inspired Python problems with test cases (at most 15 per problem).",
+                          sources=[{"name": "SYNTHETIC-2 based Python problems with tests", "category": "code", "rows": 8579, "url": RL_DS}],
+                          processing=[{"step": "successive re-uploads", "rows_in": 24287, "rows_out": 9341, "note": "Nov 7-8 2025: 24,287 → 21,573 → 20,710 → 20,182 → 19,882 → 17,705 → 17,320 → 11,960 → 9,943 → 9,637 → 9,341 ('Upload dataset')."},
+                                      {"step": "filter_by_pass_rate", "rows_in": 9341, "rows_out": 8579, "note": "Commit b134d9be2f 'Remove examples with 1 reward'."},
+                                      {"step": "test subsampling", "rows_in": None, "rows_out": None, "note": "At most 15 test cases per problem."}],
+                          samples=[{"source": "code", "category": "code", "data": {"prompt": x["q"], "function": x["fn"], "tests": x["n_tests"]}} for x in rows["code"][:6]],
+                          created_at=kit.ts("2025-11-08 00:00"), source=RL_DS)
+    ds_sci = kit.dataset(w, pid, "i3-rl-science", "INTELLECT-3-RL / science", "rl_prompts", rows=29307, hf_repo="PrimeIntellect/INTELLECT-3-RL",
+                         description="Curated and filtered from MegaScience; physics, chemistry, biology.",
+                         sources=[{"name": "MegaScience (curated and filtered)", "category": "science", "rows": 29307, "url": RL_DS}],
+                         processing=[{"step": "difficulty annotation", "rows_in": None, "rows_out": 33775, "note": "avg@16 of Qwen3-4B-Instruct-2507; commit f888ef16ca 'Merge scores in science split'."},
+                                     {"step": "quality_filter", "rows_in": 33775, "rows_out": 29307, "note": "Commit 1bdbfabd2f 'Remove examples with long answers and zero reward'."}],
+                         samples=[{"source": "science", "category": "science", "data": {"prompt": x["q"], "answer": x["a"]}} for x in rows["science"][:8]],
+                         created_at=kit.ts("2025-11-08 00:00"), source=RL_DS)
+    ds_logic = kit.dataset(w, pid, "i3-rl-logic", "INTELLECT-3-RL / logic", "rl_prompts", rows=11647, hf_repo="PrimeIntellect/INTELLECT-3-RL",
+                           description="SynLogic problems and verifiers, 29 task types (sudoku, zebra puzzles, minesweeper, word sorting, ARC-AGI and others).",
+                           sources=[{"name": "SynLogic problems and verifiers (29 task types)", "category": "other", "rows": 11647, "synthetic": True, "url": RL_DS}],
+                           processing=[{"step": "difficulty annotation", "rows_in": None, "rows_out": 11647, "note": "avg@16 of Qwen3-4B-Instruct-2507. Env README: '33k train examples (pre-filtering)'."},
+                                       {"step": "task exclusion", "rows_in": None, "rows_out": None, "note": "i3-logic skips arc_agi, arc_agi_2 and buggy_tables by default (tasks_to_skip)."}],
+                           samples=[{"source": x["task"], "category": "logic", "data": {"prompt": x["q"]}} for x in rows["logic"] if x["row"] in (250, 2750, 3750, 5750, 7500)],
+                           created_at=kit.ts("2025-11-07 00:00"), source=RL_DS)
+    deep = _load("deepdive_qa_rl.json.gz")
+    ds_deep = kit.dataset(w, pid, "deepdive", "DeepDive (zai-org)", "rl_prompts", rows=4108, hf_repo="zai-org/DeepDive",
+                          description="'complex, multi-step questions extracted from open knowledge graphs with the help of LLMs'. Report: '1K samples for SFT trajectory generation and 2.2K samples for RL'.",
+                          sources=[{"name": "qa_rl split (RL prompts)", "category": "agentic", "rows": 2234, "synthetic": True, "url": DEEPDIVE},
+                                   {"name": "qa_sft split (questions for SFT trajectories)", "category": "agentic", "rows": 1016, "synthetic": True, "url": DEEPDIVE},
+                                   {"name": "trajectories_sft split", "category": "agentic", "rows": 858, "synthetic": True, "url": DEEPDIVE}],
+                          processing=[{"step": "train/eval split in the env", "rows_in": 2234, "rows_out": None, "note": "Takes qa_rl and holds out 10% (test_size 0.1, seed 2025)."}],
+                          samples=[{"source": "qa_rl", "category": "search", "data": {"prompt": x["q"], "answer": x["a"]}} for x in deep if x["id"] in (0, 4, 5)],
+                          source=DEEPDIVE)
+    r2e = _load("r2e_gym_subset.json.gz")
+    meta, stmts = r2e["meta"], {int(k): v for k, v in r2e["statements"].items()}
+    ds_r2e = kit.dataset(w, pid, "r2e-gym-subset", "R2E-Gym-Subset (SWE environments' default task set)", "rl_prompts", rows=4578, hf_repo="R2E-Gym/R2E-Gym-Subset",
+                         license="apache-2.0", description="Default task set of the deepswe and mini-swe-agent-plus environments. Which SWE tasks entered INTELLECT-3 RL is not stated; the report names R2E-Gym, SWE-smith and Multi-SWE-bench formats and 'over 20,000 images'.",
+                         sources=[{"name": "R2E-Gym procedurally built issue-resolution tasks", "category": "swe", "rows": 4578, "synthetic": True, "url": R2E}],
+                         samples=[{"source": meta[i]["repo"], "category": "swe", "data": {"prompt": stmts[i]["text"]}} for i in (590, 1739, 3134) if i in stmts],
+                         source=R2E)
+
+    # graders ------------------------------------------------------------------
+    g = {
+        "math": kit.grader(w, pid, "math-hybrid", "math-verify + CompassVerifier-7B", "math_verify",
+                           "math-verify on the last \\boxed{} answer; answers marked wrong are re-checked by CompassVerifier-7B (A = correct, B = incorrect, C = incomplete / repetitive / refusal).",
+                           [{"name": "math_verify", "weight": 1.0, "rule": "1 if the boxed answer is equivalent to the reference, else the judge decides."}]),
+        "code": kit.grader(w, pid, "code-tests", "Test cases in Prime Sandboxes", "unit_tests",
+                           "Up to 15 test cases per problem run in Prime Sandboxes (10 s per test by default); a sandbox failure masks the completion instead of scoring it.",
+                           [{"name": "passed", "weight": 1.0, "rule": "1 if every test case passes, else 0."}]),
+        "science": kit.grader(w, pid, "science-hybrid", "math-verify + LLM judge", "math_verify", "Same hybrid rubric as i3-math (judge not named for science).",
+                              [{"name": "correct", "weight": 1.0, "rule": "1 if the answer matches the reference, else 0."}]),
+        "logic": kit.grader(w, pid, "synlogic", "SynLogic per-task verifiers", "other", "task2verifier map adapted from SynLogic, applied to the parsed answer.",
+                            [{"name": "verified", "weight": 1.0, "rule": "1 if the task's verifier accepts the answer, else 0."}]),
+        "deepdive": kit.grader(w, pid, "deepdive-judge", "LLM judge against the gold answer", "llm_judge",
+                               "A judge compares the final answer with the gold answer (env default gpt-4.1-mini; the training judge is not stated). The query-redundancy penalty was set to 0 for INTELLECT-3.",
+                               [{"name": "judge", "weight": 1.0, "rule": "1 if judged correct, else 0."}]),
+        "swe": kit.grader(w, pid, "swe-tests", "Repository tests (failing → passing)", "unit_tests",
+                          "After submission the repository test suite runs; solved if the right tests change from failing to passing. Sandbox failures mask the completion and cancel generation.",
+                          [{"name": "tests", "weight": 1.0, "rule": "1 if the target tests flip to passing, else 0."}]),
+    }
+
+    # environments with real task texts -----------------------------------------------
+    def bank_of(items):
+        return lambda _r, i: items[i]
+
+    def env_from(key, name, domain, items, count, grader, harness, tools, profile, desc, diffs=None, tags=None, source=ENVS, checks=None, sandbox=None, version=""):
+        env = kit.environment(w, pid, key, name, domain, n_tasks=len(items), bank=bank_of(items), grader_id=grader, harness=harness,
+                              tools=tools, reward_kind="binary", sandbox=sandbox, description=desc, version=version, source=source,
+                              provenance="mixed", task_count=count, created_at=kit.ts("2025-09-25 00:00"), profile=profile, checks=checks)
+        rr = rng("prime-diff", key)
+        for i, t in enumerate(env.tasks):
+            if diffs is not None and diffs[i] is not None:
+                t.difficulty = -_logit(diffs[i]) + rr.gauss(0, 0.5)
+            if tags:
+                t.tags = [x for x in [tags[i]] if x]
+        return env
+
+    m_items = [(f"math-row-{x['row']:05d}", _cut(x["q"])) for x in rows["math"]]
+    e_math = env_from("i3-math", "primeintellect/i3-math", "math", m_items, 21161, g["math"], "verifiers SingleTurnEnv (MaybeThink parser, \\boxed{} answer)", [],
+                      {"turns": (1, 1), "tokens_out": 9000, "tokens_in": 300, "seconds": 240, "infra_rate": 0.001, "max_tokens": 65536},
+                      "Single-turn math with a boxed answer. Stored: 2,000 real rows spread over the 21,161 (difficulty follows each row's published Qwen3-4B-Thinking avg@8).",
+                      diffs=[None if x["p_think"] is None else (x["p_think"] * 8 + 0.5) / 9 for x in rows["math"]])
+    c_items = [(f"code-row-{x['row']:05d}" + (f"-{x['fn']}" if x["fn"] else ""), _cut(x["q"])) for x in rows["code"]]
+    e_code = env_from("i3-code", "primeintellect/i3-code", "competitive_code", c_items, 8579, g["code"], "verifiers CodeEnv (single-turn Python)", ["sandbox"],
+                      {"turns": (1, 1), "tokens_out": 8000, "tokens_in": 500, "seconds": 200, "infra_rate": 0.008, "max_tokens": 65536},
+                      "Single-turn Python problems graded by test cases in Prime Sandboxes ('over 4000 concurrent sandboxes' during training). Stored: 2,000 real rows (difficulty from the published Qwen3-4B-Instruct avg@8).",
+                      diffs=[None if x["p_inst"] is None else (x["p_inst"] * 8 + 0.5) / 9 for x in rows["code"]], tags=[x["fn"] for x in rows["code"]],
+                      sandbox={"provider": "Prime Sandboxes", "per_test_timeout_s": 10},
+                      checks=[{"name": "Hub smoke eval", "status": "pass", "detail": "gpt-5-nano 0.933 on 5 examples × 3 rollouts (2025-11-24).", "source": HUB}])
+    s_items = [(f"science-row-{x['row']:05d}", _cut(x["q"])) for x in rows["science"]]
+    e_sci = env_from("i3-science", "primeintellect/i3-science", "science", s_items, 29307, g["science"], "verifiers SingleTurnEnv (Nov 2025 version)", [],
+                     {"turns": (1, 1), "tokens_out": 6000, "tokens_in": 300, "seconds": 150, "infra_rate": 0.002, "max_tokens": 65536},
+                     "Single-turn physics, chemistry and biology questions. The Sept 2026 Hub version (v0.1.1) is a sandbox agent, not this single-turn one. Stored: 2,000 real rows (difficulty from Qwen3-4B-Instruct avg@16).",
+                     diffs=[None if x["p_inst"] is None else (x["p_inst"] * 16 + 0.5) / 17 for x in rows["science"]])
+    l_items = [(f"{x['task'] or 'logic'}-row-{x['row']:05d}", _cut(x["q"])) for x in rows["logic"][:2000]]
+    e_logic = env_from("i3-logic", "primeintellect/i3-logic", "math", l_items, 11647, g["logic"], "verifiers SingleTurnEnv", [],
+                       {"turns": (1, 1), "tokens_out": 7000, "tokens_in": 400, "seconds": 150, "infra_rate": 0.001, "max_tokens": 65536},
+                       "Logic puzzles and games (SynLogic, 29 task types) with programmatic verifiers; shown under the math domain. Stored: 2,000 real rows with their task type (difficulty from Qwen3-4B-Instruct avg@16).",
+                       diffs=[None if x["p_inst"] is None else (x["p_inst"] * 16 + 0.5) / 17 for x in rows["logic"][:2000]],
+                       tags=[x["task"] for x in rows["logic"][:2000]],
+                       checks=[{"name": "Hub smoke eval", "status": "warn", "detail": "gpt-5 0.533, gpt-5-nano 0.0 on 5 examples × 3 rollouts.", "source": HUB}])
+    d_items = [(f"deepdive-{x['id']:04d}", _cut(x["q"])) for x in deep[:2000]]
+    e_deep = env_from("deepdive", "primeintellect/deepdive", "search", d_items, 2234, g["deepdive"], "verifiers ToolEnv (max 32 turns)",
+                      ["search", "click", "open", "finish"],
+                      {"turns": (8, 32), "tokens_out": 12000, "tokens_in": 1200, "seconds": 400, "infra_rate": 0.01, "timeout_rate": 0.02, "max_tokens": 65536},
+                      "Deep-research questions answered with a Serper search tool, click / open for pages (results cut at 20,000 characters) and finish; a judge scores the answer. Stored: 2,000 of the 2,234 qa_rl questions.",
+                      source=ENVS + "/deepdive",
+                      checks=[{"name": "Environment trains a small model", "status": "pass",
+                               "detail": "Qwen3-4B-Instruct-2507: SFT on public DeepDive traces (26 steps × 34), then 122 RL steps (group 16, batch 512); mean reward about 0.1 → 0.7 (Figure 7, read off the plot).", "source": REPORT}])
+    stride = 4578 / 2000.0
+    picks = sorted({int(i * stride) for i in range(2000)} | set(stmts))[:2000]
+
+    def swe_item(i):
+        m_ = meta[i]
+        st = stmts.get(i)
+        return (f"{m_['repo']}@{m_['commit'][:10]}", st["text"] if st else
+                f"Resolve the issue behind commit {m_['commit']} of {m_['repo']} ({m_.get('files')} non-test file(s), {m_.get('lines')} lines changed upstream). Problem statement not copied into the demo.")
+    swe_items = [swe_item(i) for i in picks]
+    e_swe = env_from("deepswe", "primeintellect/deepswe (R2E-Gym scaffold)", "swe", swe_items, 4578, g["swe"],
+                     "modified R2E-Gym scaffold (turns capped at 200)", ["file_editor", "execute_bash", "search", "submit"],
+                     {"turns": (40, 200), "tokens_out": 30000, "tokens_in": 3000, "seconds": 1500, "infra_rate": 0.02, "timeout_rate": 0.04, "max_tokens": 65536},
+                     "R2E-Gym-Subset tasks in a modified R2E-Gym scaffold (finish() replaced by submit()); Prime Sandboxes with a custom registry of over 20,000 prebuilt images. Stored: 2,000 of 4,578 (real repo@commit ids; 11 with their problem statements).",
+                     sandbox={"provider": "Prime Sandboxes", "images": "custom registry, >20,000"}, source=ENVS + "/deepswe",
+                     checks=[{"name": "Hub smoke eval", "status": "warn", "detail": "gpt-5 0.4 on 5 examples × 1.", "source": HUB}])
+    picks2 = [i for i in range(1, 4578, 4)][:1000]
+    e_mini = env_from("mini-swe-agent-plus", "primeintellect/mini-swe-agent-plus", "swe", [swe_item(i) for i in picks2], 4578, g["swe"],
+                      "mini-swe-agent-plus with native tool calling (max 200 turns)", ["execute_bash", "str_replace"],
+                      {"turns": (35, 200), "tokens_out": 28000, "tokens_in": 3000, "seconds": 1400, "infra_rate": 0.02, "timeout_rate": 0.04, "max_tokens": 65536},
+                      "Supports R2E-Gym-Subset, SWE-bench Lite / Verified and Multi-SWE-RL (C/C++ rows dropped) through the R2E-Gym, SWE-smith and Multi-SWE-bench test harnesses. Task count shown is the R2E-Gym-Subset default; stored: 1,000 of its tasks.",
+                      sandbox={"provider": "Prime Sandboxes"}, source=ENVS + "/mini_swe_agent_plus")
+
+    # SFT runs (simulated around the report's settings) ------------------------------------
+    t_sft1 = kit.ts("2025-09-12 00:00")
+    o1 = _sft(w, pid, "sft-1", tags_to=PRIME_SFT_TAGS, name="INTELLECT-3 SFT stage 1: general reasoning", datasets=[(ds_sft1, 1.0)],
+              base_model_id=i3_base, output_model_id=sft1, steps=1500, start=t_sft1, step_seconds=60.0, loss=(0.39, 0.33),
+              lr=5e-5, warmup=0.2, schedule="constant", global_batch=512, seq_len=65536, epochs=1, gpu="H200", gpus=512,
+              tokens_per_step=33e6, ckpt_every=500, config="optimizer: muon\nlr: 5e-5\nweight_decay: 0.01\nwarmup: linear from 1e-8 over 300 steps\nseq_len: 65536\ntokens_per_step: ~33M\nparallelism: FSDP 64 x DP replicate 8 (512 H200)\ndata: natural ratios, 1 epoch",
+              hyperparams={"optimizer": "Muon", "weight_decay": 0.01, "warmup": "linear from 1e-8 over 300 steps", "tokens_per_step": "~33M",
+                           "parallelism": "FSDP 64 × DP replicate 8", "global_batch": None},
+              owner="Prime Intellect", tags=("simulated",), provenance="simulated", source=REPORT,
+              description="Stage 1: math, code, science and tool splits of Nemotron-Post-Training-Dataset-v1 plus AM chat and instruction following, all with DeepSeek-R1-0528 traces, one epoch at 65K context. Published: the settings, and Figure 8a's smooth loss about 0.39 → 0.33 over about 1,500 steps (read off the plot; the step count is not stated). Simulated: the curve itself and the dates.")
+    t_sft2 = o1["end"] + 3 * 86400
+    o2 = _sft(w, pid, "sft-2", tags_to=PRIME_SFT_TAGS, name="INTELLECT-3 SFT stage 2: agentic", datasets=[(ds_sft, 0.97), (ds_envmix, 0.03)],
+              base_model_id=sft1, output_model_id=sft2, steps=800, start=t_sft2, step_seconds=90.0, loss=(0.6, 0.2), lr=5e-8, warmup=0.0,
+              schedule="linear", global_batch=512, seq_len=98304, epochs=2, gpu="H200", gpus=512, tokens_per_step=33e6, ckpt_every=400,
+              config="optimizer: muon\nlr: 5e-8  # as printed; possibly 5e-5\nschedule: linear decay over 800 steps\nepochs: 2\nseq_len: 98K (context parallelism)\nresume: final stage-1 checkpoint",
+              hyperparams={"optimizer": "Muon", "lr_note": "'starting with a learning rate of 5e-8' (as printed; possibly a typo)", "global_batch": None},
+              owner="Prime Intellect", tags=("simulated",), provenance="simulated", source=REPORT,
+              description="Stage 2: every Table 1 source including SWE-Swiss, Toucan Tool and the 38.4K Environments Mix, two epochs to 800 steps at up to 98K context via context parallelism. Published: the settings, and Figure 8b's loss about 0.6 → 0.2 with step drops (read off the plot). Simulated: the curve (one drop placed at the epoch boundary, step 400), the GPU count (not stated separately), and the dates.")
+    r_sft2 = o2["run_id"]
+    rr = rng("prime-sft2-drop")
+    for step, value in list(w.conn.execute("SELECT step, value FROM metrics WHERE run_id=? AND tag='loss/mean'", (r_sft2,))):
+        x = step / 800
+        base = (0.6 - 0.1 * (1 - math.exp(-6 * x))) if step <= 400 else (0.33 - 0.12 * (1 - math.exp(-5 * (x - 0.5))))
+        w.conn.execute("UPDATE metrics SET value=? WHERE run_id=? AND tag='loss/mean' AND step=?", (round(base + rr.gauss(0, 0.006), 6), r_sft2, step))
+    w.conn.execute("UPDATE runs SET gpus=NULL, cost_usd=NULL, cost_rate=NULL WHERE id=?", (r_sft2,))
+    w.conn.execute("UPDATE runs SET cost_usd=NULL, cost_rate=NULL WHERE id=?", (o1["run_id"],))
+    w.add("run_events", {"run_id": r_sft2, "t": t_sft2 + 400 * 90, "step": 400, "kind": "notice", "severity": "info", "title": "Second epoch",
+                         "body": "The loss steps down at the epoch boundary (Figure 8b shows step drops; their exact positions are read off the plot)."})
+
+    # RL run (simulated) ---------------------------------------------------------------------
+    mix = [(e_math, 0.25, (0.55, 0.66)), (e_code, 0.20, (0.48, 0.60)), (e_sci, 0.15, (0.52, 0.60)), (e_logic, 0.15, (0.45, 0.58)),
+           (e_deep, 0.10, (0.35, 0.55)), (e_swe, 0.10, (0.25, 0.38)), (e_mini, 0.05, (0.22, 0.35))]
+    t_rl = o2["end"] + 5 * 86400
+    rl_cfg = "\n".join([
+        "# Published facts about the INTELLECT-3 RL run (report §2-3); the full config is not public",
+        "trainer: prime-rl (FSDP2 trainer + orchestrator + vLLM inference, disaggregated)", "batch_size: 256 prompts x 16 rollouts",
+        "max_seq_len: 65536", "optimizer: muon  # distributed via all-to-all (Dion)", "lr: 1e-6", "max_off_policy_steps: 8",
+        "loss: masked token-level importance sampling (IcePop): ratios outside [0.5, 5] masked; rollout masked if any token ratio < 1e-5",
+        "advantage: reward minus the mean of the prompt's 16 rollouts (no std normalisation)",
+        "online_difficulty_filtering: true  # easy / normal / hard pools; prompts with pass rate 1 not sampled again",
+        "in_flight_weight_updates: true  # continuous batching; >2x slower without", "nodes: 60 x 8 H200 (16 trainer, 44 inference)",
+        "online_eval_every: 15 steps (AIME24, AIME25, LiveCodeBench, HLE, GPQA)", "env_mix: 'carefully tuned' (weights not published)"])
+    res = rl_run(w, project_id=pid, key="rl", name="INTELLECT-3 RL: async multi-environment RL", framework="prime_rl",
+                 envs=[(e, wt) for e, wt, _ in mix], base_model_id=sft2, output_model_id=i3, steps=300, group_size=16, prompts_per_step=256,
+                 sample_groups=48, store_groups=2, start=t_rl, step_seconds=1500.0, env_targets={e.id: tr for e, _, tr in mix},
+                 shape=2.0, noise=0.01, algorithm="IcePop-masked token-level IS (CISPO-like)", async_rl=True, lr=1e-6, gpu="H200", gpus=480,
+                 entropy=(0.42, 0.36), grad_norm=0.1, train_infer_kl=0.0012, ckpt_every=50, owner="Prime Intellect", tags=("simulated",),
+                 code_ref="PrimeIntellect-ai/prime-rl", config=rl_cfg, source=REPORT, provenance="simulated",
+                 hyperparams={"lr": 1e-6, "optimizer": "Muon", "max_context": 65536, "max_off_policy_steps": 8, "importance_mask": [0.5, 5],
+                              "rollout_mask_if_any_ratio_below": 1e-5, "online_difficulty_filtering": True, "in_flight_weight_updates": True,
+                              "env_mix": "not published (demo assumption: math 0.25, code 0.20, science 0.15, logic 0.15, deepdive 0.10, deepswe 0.10, mini-swe-agent-plus 0.05)"},
+                 description=("Asynchronous RL from the stage-2 SFT checkpoint on seven Environments Hub environments. Published: batch 256 prompts × 16 "
+                              "rollouts, 65,536 max context, Muon lr 1e-6, max_off_policy_steps 8, IcePop masking, online difficulty filtering, 60 nodes of 8 H200 "
+                              "(16 trainer, 44 inference), ~1,500 s per step with in-flight weight updates, online evals every 15 steps, and the final scores. "
+                              "Not published, so simulated: the environment mix, per-environment rewards, every per-step value and the rollouts. The step count is "
+                              "not stated (Figure 9's axis reaches about step 600); the demo simulates 300 steps, its per-run limit, so its step axis is compressed "
+                              "about 2× against the figure."))
+    run_rl = res["run_id"]
+    w.conn.execute("UPDATE runs SET cost_usd=NULL, cost_rate=NULL WHERE id=?", (run_rl,))
+    w.add_many("run_events", [
+        {"run_id": run_rl, "t": t_rl, "step": 0, "kind": "notice", "severity": "info", "title": "Why IcePop masking",
+         "body": "Report: trainer-inference probability mismatch caused runs 'to crash multiple days into the experiments, if not explicitly addressed'; double-sided masking of importance ratios outside [0.5, 5] fixed it (masking instead of CISPO-style clipping)."},
+        {"run_id": run_rl, "t": t_rl, "step": 0, "kind": "notice", "severity": "info", "title": "Online difficulty filtering",
+         "body": "Prompts sit in easy / normal / hard pools by observed solve rate; prompts every rollout solves are not sampled again."}])
+    for e, _, (a, b) in mix:
+        kit.write_tasks(w, e, base_pass=a, latest_pass=b, attempts=16)
+    kit.metric_defs(w, pid, "prime_rl", pinned=("reward", "pass_rate"), extra=[
+        {"tag": "loss/mean", "label": "Loss", "format": "num3", "grp": "learning", "better": "down", "signal": "loss", "pinned": 1,
+         "description": "SFT loss ('main signal. Should decrease through the run')."},
+        {"tag": "optim/lr", "label": "Learning rate", "format": "sci", "grp": "stability", "better": "none", "signal": "lr", "description": "Optimizer learning rate."},
+        {"tag": "optim/grad_norm", "label": "Gradient norm", "format": "num3", "grp": "stability", "better": "none", "signal": "grad_norm",
+         "description": "'spikes precede divergence'."},
+        {"tag": "perf/throughput", "label": "Throughput", "format": "compact", "grp": "throughput", "better": "up", "signal": "throughput", "description": "Tokens per second."},
+        {"tag": "progress/num_tokens", "label": "Tokens trained", "format": "compact", "grp": "progress", "better": "none", "signal": "tokens_trained", "description": "Dataset progress in tokens."},
+        {"tag": "mismatch_kl/mean", "label": "Trainer vs sampler KL", "format": "num4", "grp": "consistency", "better": "down", "signal": "train_infer_kl",
+         "description": "KL between the trainer's policy and the older inference policy that sampled the rollouts; 'a sustained, growing mean is the early-warning sign for off-policy collapse'."},
+        {"tag": "loss/is_masked", "label": "Masked tokens", "format": "pct", "grp": "stability", "better": "none", "signal": "clip_frac",
+         "description": "Share of tokens masked by the importance-ratio trust region (ratios outside [0.5, 5])."},
+    ] + env_metric_defs(pid, [e for e, _, _ in mix]))
+
+    # benchmarks and evals (Table 2 + online evals) ----------------------------------------------
+    def aime_bank(year):
+        return lambda _r, i: (f"AIME {year} {'I' if i < 15 else 'II'}-{i % 15 + 1}", "")
+    B = {
+        "aime24": benchmark(w, project_id=pid, key="aime24", name="AIME 2024", category="math", metric="avg@32", harness="primeintellect/aime2024",
+                            n_tasks=30, k=32, bank=aime_bank(2024), source=REPORT, description="30 problems, 32 generations each, math-verify without a judge (Appendix A; prime-rl eval config: 32 rollouts per example)."),
+        "aime25": benchmark(w, project_id=pid, key="aime25", name="AIME 2025", category="math", metric="avg@32", harness="primeintellect/aime2025",
+                            n_tasks=30, k=32, bank=aime_bank(2025), source=REPORT, description="30 problems, 32 generations each."),
+        "lcb": benchmark(w, project_id=pid, key="lcb-v6", name="LiveCodeBench v6", category="code", metric="avg@2", harness="primeintellect/livecodebench",
+                         n_tasks=454, k=2, bank=lambda _r, i: (f"lcb-v6-{i + 1:03d}", ""), source=REPORT,
+                         description="454 problems from Aug 2024 to May 2025, 2 generations each, tests run in Prime Sandboxes."),
+        "gpqa": benchmark(w, project_id=pid, key="gpqa-d", name="GPQA Diamond", category="science", metric="avg@4", harness="primeintellect/gpqa",
+                          n_tasks=198, k=4, bank=lambda _r, i: (f"gpqa-diamond-{i + 1:03d}", ""), source=REPORT, description="198 questions, 4 generations each, boxed-letter exact match."),
+        "hle": benchmark(w, project_id=pid, key="hle", name="HLE (text-only, no tools)", category="knowledge", metric="avg@1", harness="primeintellect/hle",
+                         n_tasks=2158, k=1, bank=lambda _r, i: (f"hle-text-{i + 1:04d}", ""), source=REPORT, description="2,158 text-only questions, one sample each, no tools."),
+        "mmlupro": benchmark(w, project_id=pid, key="mmlu-pro", name="MMLU-Pro", category="knowledge", metric="avg@1", harness="primeintellect/mmlu-pro",
+                             n_tasks=1000, k=1, bank=lambda _r, i: (f"mmlu-pro-{i + 1:04d}", ""), source=REPORT,
+                             description="The report gives '12K' questions without an exact count; the demo stores a 1,000-question stand-in (its limit when a count is not published), so the SE shown is that of 1,000 questions and overstates the real one."),
+        "math500": benchmark(w, project_id=pid, key="math500", name="MATH-500", category="math", metric="avg@2", harness="primeintellect/math500",
+                             n_tasks=500, k=2, bank=lambda _r, i: (f"math500-{i + 1:03d}", ""), source=CARD, description="500 problems, 2 generations each (model card only)."),
+    }
+    table2 = {  # report Table 2 / card: INTELLECT-3 and baselines
+        "aime24": (90.8, {"GLM-4.5-Air": 84.6, "GLM-4.5": 85.8, "GLM-4.6": 92.0, "DeepSeek R1 0528": 83.2, "DeepSeek v3.2": 88.1, "GPT-OSS 120B (high)": 75.8}),
+        "aime25": (88.0, {"GLM-4.5-Air": 82.0, "GLM-4.5": 83.3, "GLM-4.6": 90.3, "DeepSeek R1 0528": 73.4, "DeepSeek v3.2": 84.7, "GPT-OSS 120B (high)": 77.7}),
+        "lcb": (69.3, {"GLM-4.5-Air": 61.5, "GLM-4.5": 64.5, "GLM-4.6": 73.0, "DeepSeek R1 0528": 62.5, "DeepSeek v3.2": 71.6, "GPT-OSS 120B (high)": 69.9}),
+        "gpqa": (74.4, {"GLM-4.5-Air": 73.3, "GLM-4.5": 77.0, "GLM-4.6": 78.8, "DeepSeek R1 0528": 77.5, "DeepSeek v3.2": 81.4, "GPT-OSS 120B (high)": 70.0}),
+        "hle": (14.6, {"GLM-4.5-Air": 13.3, "GLM-4.5": 14.8, "GLM-4.6": 13.3, "DeepSeek R1 0528": 15.9, "DeepSeek v3.2": 17.9, "GPT-OSS 120B (high)": 10.6}),
+        "mmlupro": (81.9, {"GLM-4.5-Air": 73.9, "GLM-4.5": 83.5, "GLM-4.6": 83.1, "DeepSeek R1 0528": 75.3, "DeepSeek v3.2": 84.6, "GPT-OSS 120B (high)": 67.1}),
+        "math500": (98.1, {"GLM-4.5-Air": 97.8, "GLM-4.5": 97.0, "DeepSeek R1 0528": 87.3, "DeepSeek v3.2": 96.8, "GPT-OSS 120B (high)": 96.0}),
+    }
+    end_rl = res["end"]
+    t_eval = kit.ts("2025-11-20 00:00")
+    for bk, (score, ref) in table2.items():
+        src = CARD if bk == "math500" else REPORT
+        eid = eval_run(w, B[bk], model_id=i3, score=score / 100, run_id=run_rl, step=300, started=end_rl + 3600, source=src, provenance="mixed", key="i3|final")
+        _fix_score(w, eid, score / 100)
+        for name, v in ref.items():
+            eid = eval_run(w, B[bk], model_id=refs[name], score=v / 100, started=t_eval, source=src, provenance="mixed", key=f"{name}|ref")
+            _fix_score(w, eid, v / 100)
+    # online evals every 15 steps (Figure 9: start values read off the plot; the last point is Table 2)
+    online = {"aime24": (0.86, 0.908, None, 0.012), "aime25": (0.85, 0.880, None, 0.015), "lcb": (0.66, 0.693, None, 0.008),
+              "gpqa": (0.74, 0.744, 0.77, 0.010), "hle": (0.12, 0.146, None, 0.004)}
+    facts = {f["step"]: f["t"] for f in res["facts"]}
+    ro = rng("prime-online")
+    for bk, (a, b, peak, sd) in online.items():
+        bench = B[bk]
+        for step in range(0, 300, 15):
+            x = step / 300
+            if peak is None:
+                v = a + (b - a) * (1 - math.exp(-2.5 * x)) / (1 - math.exp(-2.5))
+            elif x < 0.5:  # GPQA: 'a peak near 0.77' mid-run, then back to the final 74.4
+                v = a + (peak - a) * math.sin(math.pi * x)
+            else:
+                v = peak + (b - peak) * (x - 0.5) / 0.5
+            if step:
+                v += ro.gauss(0, sd)
+            bench.store_tasks = step == 0
+            eval_run(w, bench, model_id=sft2 if step == 0 else None, score=min(0.99, max(0.01, v)), run_id=run_rl, step=step,
+                     started=(facts.get(step) or t_rl) + 600, duration=1800.0, source=REPORT, provenance="simulated", key=f"online|{step}")
+        bench.store_tasks = True
+    # BrowseComp (INTELLECT-3.1, Nemotron-3 blog)
+    b_bc = benchmark(w, project_id=pid, key="browsecomp", name="BrowseComp", category="search", metric="accuracy", harness="not stated",
+                     n_tasks=1000, k=1, bank=lambda _r, i: (f"browsecomp-{i + 1:04d}", ""), source=NEMO_BLOG,
+                     description="Only two numbers are published: 'Training INTELLECT-3.1 on the DeepDive environment lifted BrowseComp from 7.8% → 14.2%'. The blog gives no task count or harness; the demo stores a 1,000-question stand-in (its limit when a count is not published), so the SE is that of 1,000 questions.")
+    t31 = kit.ts("2026-01-15 00:00")
+    eval_run(w, b_bc, model_id=pre31, score=0.078, started=t31 - 20 * 86400, source=NEMO_BLOG, provenance="mixed", key="pre31")
+    eval_run(w, b_bc, model_id=i31, score=0.142, started=t31, source=NEMO_BLOG, provenance="mixed", key="i31")
+
+    # operations ------------------------------------------------------------------------------
+    cl = kit.cluster(w, org_id, "h200", "Prime Intellect H200 cluster (64 nodes × 8 H200)", "Prime Intellect", gpu="H200", gpus=512)
+    cl_sb = kit.cluster(w, org_id, "sandboxes", "Prime Sandboxes (Kubernetes + gVisor)", "Prime Intellect")
+    for run_id_, name, gpus, a, b_, kind in ((o1["run_id"], "INTELLECT-3 SFT stage 1 · trainer (FSDP 64 × DP 8)", 512, t_sft1, o1["end"], "train"),
+                                            (r_sft2, "INTELLECT-3 SFT stage 2 · trainer (context parallel)", None, t_sft2, o2["end"], "train"),
+                                            (run_rl, "INTELLECT-3 RL · trainer (16 nodes)", 128, t_rl, end_rl, "train"),
+                                            (run_rl, "INTELLECT-3 RL · vLLM inference (44 nodes, multi-client orchestrator)", 352, t_rl, end_rl, "rollout")):
+        w.add("jobs", {"id": rid("job", run_id_, name), "project_id": pid, "run_id": run_id_, "eval_id": None, "name": name, "kind": kind,
+                       "status": "completed", "cluster_id": cl, "gpu": "H200", "gpus": gpus, "nodes": gpus // 8 if gpus else None, "started_at": a,
+                       "ended_at": b_, "cost_usd": None, "exit": "completed", "log_tail": ""})
+    w.add("jobs", {"id": rid("job", run_rl, "sandboxes"), "project_id": pid, "run_id": run_rl, "eval_id": None,
+                   "name": "INTELLECT-3 RL · code and SWE sandboxes", "kind": "rollout", "status": "completed", "cluster_id": cl_sb, "gpu": None,
+                   "gpus": None, "nodes": None, "started_at": t_rl, "ended_at": end_rl, "cost_usd": None, "exit": "completed",
+                   "log_tail": "Over 4,000 concurrent sandboxes; 256 sandboxes per node; cold start under 10 s with push-based readiness; >20,000 SWE images in a private registry with lazy pulling."})
+
+    # reports ------------------------------------------------------------------------------------
+    kit.report(w, pid, "rl-stability", "Keeping large-scale asynchronous RL stable", "Prime Intellect (report) · demo", kit.ts("2025-11-30 00:00"),
+               "What the INTELLECT-3 report says it had to fix to train with 8-step off-policy RL on 480 H200s.",
+               [{"claim": "Double-sided masking of token importance ratios (outside [0.5, 5]) was required; without it runs crashed days into training.", "verdict": "upheld",
+                 "evidence": f"Report §2.1 ({REPORT}): 'We found double-sided masking critical to combat the trainer-inference mismatch'; rollouts are also masked if any token ratio falls below 1e-5."},
+                {"claim": "GSPO collapsed on the async-8 testbed while CISPO kept improving.", "verdict": "upheld",
+                 "evidence": "Figure 10 (read off the plot): GSPO reward falls from about 0.8 to about 0.3 between steps ~310 and ~360; CISPO keeps rising to about 0.8 by step ~470. The ablation's model and data are not stated, so it is not simulated here."},
+                {"claim": "In-flight weight updates are essential for throughput.", "verdict": "upheld",
+                 "evidence": "About 1,500 s per step at 65,536 tokens with in-flight updates; 'more than 2×' slower without."},
+                {"claim": "Rule-based math verification alone produces false negatives.", "verdict": "upheld",
+                 "evidence": "CompassVerifier-7B re-checks answers math-verify marks wrong ('a non-negligible fraction of false negatives')."},
+                {"claim": "Scores were still rising when RL stopped.", "verdict": "upheld",
+                 "evidence": "'The reasoning benchmark scores generally trend up and do not seem to have reached a plateau' (Figure 9)."},
+                {"claim": "Expert parallelism and ring-attention context parallelism were not worth it at this scale.", "verdict": "upheld",
+                 "evidence": "EP lowered throughput; ring-attention CP 'halved our data-parallelism degree and additionally exhibited accuracy degradations'; activation offloading reached 72K instead."}],
+               run_keys=("rl",))
+    kit.report(w, pid, "vs-glm", "INTELLECT-3 against GLM-4.5-Air: which gains exceed noise", "demo, from report Table 2", kit.ts("2025-11-30 00:00"),
+               "Both are post-trained from the same GLM-4.5-Air base (Z.ai's own GLM-4.5-Air is the comparison). Standard errors come from the task counts and generations per task.",
+               [{"claim": "INTELLECT-3 beats GLM-4.5-Air on AIME 2024 (90.8 vs 84.6), AIME 2025 (88.0 vs 82.0), LiveCodeBench v6 (69.3 vs 61.5) and MMLU-Pro (81.9 vs 73.9).", "verdict": "upheld",
+                 "evidence": "Each gap is several standard errors on the Evals page (30 problems × 32 generations for AIME; 454 × 2 for LiveCodeBench)."},
+                {"claim": "INTELLECT-3 beats GLM-4.5-Air on GPQA Diamond.", "verdict": "open",
+                 "evidence": "74.4 vs 73.3 is 1.1 points on 198 questions × 4 generations, well within one standard error (about 2.5 points)."},
+                {"claim": "INTELLECT-3 beats GLM-4.5-Air on HLE.", "verdict": "open",
+                 "evidence": "14.6 vs 13.3 on 2,158 questions with one sample each: about 1.7 standard errors, and per-question results are not published to pair them."},
+                {"claim": "INTELLECT-3 matches the larger GLM-4.6 on math.", "verdict": "rejected",
+                 "evidence": "GLM-4.6 leads on AIME 2024 (92.0 vs 90.8), AIME 2025 (90.3 vs 88.0), LiveCodeBench (73.0 vs 69.3) and GPQA (78.8 vs 74.4)."}],
+               run_keys=("rl",))
+    kit.report(w, pid, "intellect-3.1", "INTELLECT-3.1: what is published", "demo", kit.ts("2026-06-05 00:00"),
+               "INTELLECT-3.1 has a model card and a prime-rl example config, but no report, eval table, step count or compute.",
+               [{"claim": "Training INTELLECT-3.1 on DeepDive raised BrowseComp from 7.8% to 14.2%.", "verdict": "upheld", "evidence": f"Nemotron-3 blog ({NEMO_BLOG})."},
+                {"claim": "INTELLECT-3.1 continues from INTELLECT-3.", "verdict": "open",
+                 "evidence": f"The card says so ({CARD31}); the example Prime says reproduces the run starts from INTELLECT-3-Base ({EX31})."},
+                {"claim": "The reasoning stage of every INTELLECT model uses opencode-math, -science, -cp and -lean.", "verdict": "open",
+                 "evidence": "The Nemotron-3 blog says so; the INTELLECT-3 report names the i3-math, i3-code, i3-science and i3-logic environments instead."}])
+    return pid
+
+
+# ------------------------------------------------------------------ hosted runs
+
+HOSTED = [
+    # run id, env name, env version, owner, examples per step, group, max tokens per turn, lr, env args, steps planned, reward kind
+    ("pi-calendar-scheduling-qwen3-30b-a3b", "prime/calendar-scheduling", "0.1.0", "Prime Intellect applied research", 128, 8, 768, None,
+     "easy, 512 examples, up to 18 turns", 100, "partial"),
+    ("pi-prime-grep-qwen35-35b-a3b", "prime/prime-grep", "0.4.6", "Prime Intellect applied research", 128, 8, 2048, 1e-4, "5 turns", 100, "scalar"),
+    ("pi-webvoyager-qwen3-4b-browserbase", "browserbase/webvoyager-no-anti-bot", "0.1.2", "a Browserbase user", 64, 8, 1024, 5e-5,
+     "DOM tools: act, extract, navigate, observe", 100, "binary"),
+    ("pi-webvoyager-qwen3-vl-8b", "prime/webvoyager-no-anti-bot", "0.1.5", "Prime Intellect applied research", 32, 8, 512, 1e-4,
+     "computer-use mode, 800 × 600 viewport, 2 recent screenshots kept", 200, "binary"),
+    ("pi-wikispeedia-nemotron3-nano-30b", "prime/langchain-deep-agents-wikispeedia", "0.1.4", "Prime Intellect applied research", 64, 16, 16384, None,
+     "links only, target paths of 4-6 links, up to 40 turns, efficiency weight 0.2", 200, "scalar"),
+]
+BASES = {"Qwen/Qwen3-30B-A3B-Instruct-2507": ("MoE", 30.5, 3.3), "Qwen/Qwen3.5-35B-A3B": ("MoE", None, None), "Qwen/Qwen3-4B-Instruct-2507": ("dense", 4.0, None),
+         "Qwen/Qwen3-VL-8B-Instruct": ("dense", 8.0, None), "nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16": ("hybrid-mamba-MoE", None, None)}
+GRADERS = {"prime/calendar-scheduling": ("calendar-score", "Submission score", "rubric",
+                                         "0 if any hard constraint (required attendees, hard local-time limits, room availability) is violated; otherwise the weighted average attendee utility; 0 without a submission.",
+                                         "final_score_from_submission"),
+           "prime/prime-grep": ("grep-spans", "Span precision / recall with a submission bonus", "rubric",
+                                "Scores the submitted code spans by precision, recall and span overlap, plus a bonus for submitting, so the reward can exceed 1.", "span_score"),
+           "browserbase/webvoyager-no-anti-bot": ("webvoyager-judge-bb", "LLM judge of task completion", "llm_judge",
+                                                  "A judge decides from the final state whether the web task was completed (judge_task_completion).", "judge_task_completion"),
+           "prime/webvoyager-no-anti-bot": ("webvoyager-judge", "LLM judge of task completion", "llm_judge",
+                                            "A judge decides from the final state whether the web task was completed (judge_task_completion).", "judge_task_completion"),
+           "prime/langchain-deep-agents-wikispeedia": ("wikispeedia", "Reached target, weighted by path efficiency", "rubric",
+                                                       "Rewards reaching the target page, weighted by path efficiency (weight 0.2) against the shortest path.", "reached_target")}
+SIGNAL_OF = {"reward/mean": "reward", "reward/all/mean": "reward", "batch/solve_none": "all_fail_share", "solve_none/all": "all_fail_share",
+             "batch/solve_all": "all_pass_share", "solve_all/all": "all_pass_share", "is_truncated/mean": "truncation_rate",
+             "stop_condition/all/generation_truncated": "truncation_rate", "num_turns/mean": "turns", "num_turns/all/mean": "turns",
+             "error/mean": "infra_error_rate", "seq_len/mean": "context_len", "seq_len/all/mean": "context_len", "decode_len/mean": "response_len",
+             "decode_len/all/mean": "response_len", "completion_len/mean": "response_len", "time/step": "step_time",
+             "stop_condition/all/timeout_reached": "timeout_rate"}
+
+
+def _hosted(w, org_id, now):
+    pid = kit.project(
+        w, org_id, "hub-hosted-runs", "Environments Hub hosted runs",
+        "Public LoRA RL runs on Prime Intellect Lab (hosted prime-rl) against Environments Hub environments: calendar scheduling, code search, web browsing (DOM and computer use) and Wikipedia link racing. Small models, 100-200 steps; not INTELLECT-3.",
+        [{"title": "Prime Intellect Lab shared runs", "url": "https://app.primeintellect.ai/training/shared/wxhl0r3gqmj6qxgpcg35m605"},
+         {"title": "prime-rl metrics guide", "url": DOCS}, {"title": "Environments Hub", "url": HUB}],
+        "Every metric step and every stored sample rollout (with its transcript) is copied from the runs' public pages; nothing is simulated "
+        "except the placement of step times inside each run's published start. Hosted runs expose no loss, KL or entropy. The Lab keeps 8 "
+        "sample rollouts every 10th step drawn from several prompts, so a stored group holds 1-4 of a prompt's attempts and its mean is not the "
+        "step's mean. Environment sizes are not published except calendar-scheduling's 512 examples.",
+        kit.ts("2026-02-26 00:00"), pins=["reward/mean", "reward/all/mean", "batch/solve_none"])
+    data = _load("pi_runs.json.gz")
+    rolls = _load("pi_rollouts.json.gz")
+    by_run_rolls = {k.replace("-rollouts", ""): v for k, v in rolls.items()}
+    cl = kit.cluster(w, org_id, "lab", "Prime Intellect Lab (hosted)", "Prime Intellect")
+    base_ids, env_ids, all_tags = {}, {}, set()
+    for run_key, env_name, env_ver, owner, per_step, group, max_tok, lr, env_args, planned, rkind in HOSTED:
+        d = data[run_key]
+        run = d["run"]
+        mets = d["metrics"]
+        base_name = run["base_model"]
+        if base_name not in base_ids:
+            arch, pt, pa = BASES.get(base_name, (None, None, None))
+            base_ids[base_name] = kit.model(w, pid, base_name, base_name.split("/")[-1], "base", hf_repo=base_name, arch=arch, params_total=pt,
+                                            params_active=pa, source=f"https://huggingface.co/{base_name}")
+        base = base_ids[base_name]
+        run_id = kit.run_id(pid, run_key)
+        out = kit.model(w, pid, run_key + "-lora", run["model"], "checkpoint", arch="LoRA adapter", parent_id=base, run_key=run_key,
+                        step=mets[-1]["step"] + 1, stage="RL (LoRA)", created_at=None, status="available",
+                        notes=f"LoRA adapter trained on Prime Intellect Lab by {owner}; shared publicly.", source=run["url"])
+        # environment and tasks
+        env_key = (env_name, env_ver)
+        if env_key not in env_ids:
+            gkey, gname, gkind, gdesc, comp = GRADERS[env_name]
+            gid = kit.grader(w, pid, gkey + env_ver, gname, gkind, gdesc, [{"name": comp, "weight": 1.0, "rule": gdesc}])
+            env_id = rid("env", pid, env_name, env_ver)
+            env_ids[env_key] = (env_id, gid)
+            tasks = {}
+            rr = by_run_rolls.get(run_key)
+            if rr:
+                for a in rr["attempts"]:
+                    tasks.setdefault(a["task"], {"prompt": a["prompt"], "early": [], "late": [], "n": 0})
+                    half = (planned // 2)
+                    tasks[a["task"]]["early" if a["version"] < half else "late"].append(a["reward"])
+                    tasks[a["task"]]["n"] += 1
+            count = 512 if env_name == "prime/calendar-scheduling" else None
+            w.add("environments", {"id": env_id, "project_id": pid, "name": env_name, "domain": {"prime/calendar-scheduling": "tool_use", "prime/prime-grep": "code",
+                                                                                                  "prime/langchain-deep-agents-wikispeedia": "search"}.get(env_name, "agentic"),
+                                   "version": env_ver, "description": f"Environments Hub environment ({env_args})." + (
+                                       f" Stored: the {len(tasks)} tasks that appear in the published sample rollouts; base and latest pass rates are the mean rewards of those rollouts in the first and second half of the run." if tasks else
+                                       " No task list is published with the run."),
+                                   "harness": "verifiers (hosted)", "tools": [], "grader_id": gid, "reward_kind": rkind, "sandbox": None,
+                                   "task_count": count, "created_at": kit.ts(run["started_at"][:16].replace("T", " ")), "source": HUB + "?env=" + env_name,
+                                   "provenance": "published", "checks": None})
+            if tasks:
+                w.add_many("tasks", [{"id": rid("task", env_id, name), "env_id": env_id, "name": name, "instruction": t["prompt"], "difficulty": None,
+                                      "tags": [], "status": "ok", "status_reason": "", "oracle_score": None, "noop_score": None, "reruns": 0,
+                                      "rerun_agree": None, "base_pass": round(sum(t["early"]) / len(t["early"]), 3) if t["early"] else None,
+                                      "latest_pass": round(sum(t["late"]) / len(t["late"]), 3) if t["late"] else None, "attempts": t["n"]}
+                                     for name, t in sorted(tasks.items())])
+        env_id, gid = env_ids[env_key]
+        # metrics and steps
+        series = defaultdict(list)
+        for row in mets:
+            for k_, v in row.items():
+                if k_ == "step" or not isinstance(v, (int, float)) or isinstance(v, bool):
+                    continue
+                series[k_].append((row["step"], float(v)))
+        all_tags |= set(series)
+        kit.import_metrics(w, run_id, series)
+        t0 = kit.ts(run["started_at"][:16].replace("T", " "))
+        rew_tag = "reward/mean" if "reward/mean" in series else "reward/all/mean"
+        none_tag = "batch/solve_none" if "batch/solve_none" in series else "solve_none/all"
+        all_tag = "batch/solve_all" if "batch/solve_all" in series else "solve_all/all"
+        err_tag = "error/mean" if "error/mean" in series else None
+        trunc_tag = "is_truncated/mean" if "is_truncated/mean" in series else "stop_condition/all/generation_truncated"
+        step_rows, t = [], t0
+        stored = defaultdict(int)
+        for a in (by_run_rolls.get(run_key) or {}).get("attempts", []):
+            stored[a["version"]] += 1
+        for row in mets:
+            s = row["step"]
+            dur = row.get("time/step") or 60.0
+            sn, sa = row.get(none_tag), row.get(all_tag)
+            n_none = None if sn is None else int(round(sn * per_step))
+            n_all = None if sa is None else int(round(sa * per_step))
+            step_rows.append({"run_id": run_id, "step": s, "phase": "train", "started_at": t, "ended_at": t + dur, "prompts": per_step,
+                              "rollouts": per_step * group, "rollouts_stored": stored.get(s, 0), "reward_mean": row.get(rew_tag),
+                              "pass_rate": row.get(rew_tag) if rkind == "binary" else None, "tokens": None, "groups_all_pass": n_all,
+                              "groups_all_fail": n_none, "groups_mixed": None if n_none is None or n_all is None else per_step - n_none - n_all,
+                              "infra_errors": None if err_tag is None or row.get(err_tag) is None else int(round(row[err_tag] * per_step * group)),
+                              "truncated": None if row.get(trunc_tag) is None else int(round(row[trunc_tag] * per_step * group))})
+            t += dur
+        stopped = run_key == "pi-webvoyager-qwen3-vl-8b"
+        w.add("runs", {"id": run_id, "project_id": pid, "name": run["title"], "kind": "rl", "stage": "RL (LoRA)", "algorithm": "GRPO-style group rollouts (hosted prime-rl)",
+                       "framework": "prime-rl (Prime Intellect Lab, hosted)", "status": "stopped" if stopped else "completed",
+                       "status_reason": "Stopped at step 114 of 200 after 5 h 46 m." if stopped else "", "base_model_id": base, "output_model_id": out,
+                       "started_at": t0, "ended_at": t, "updated_at": t, "steps_planned": planned, "steps_done": mets[-1]["step"] + 1,
+                       "primary_metric": rew_tag, "gpu": None, "gpus": None, "cost_usd": None, "cost_rate": None, "owner": owner,
+                       "tags": ["published", "hosted", "lora"], "code_ref": f"{env_name}@{env_ver}",
+                       "config": "\n".join([f"environment: {env_name}@{env_ver}", f"env_args: {env_args}", f"examples_per_step: {per_step}",
+                                            f"rollouts_per_example: {group}", f"max_tokens_per_turn: {max_tok}"] + ([f"lr: {lr}"] if lr else [])),
+                       "config_format": "yaml", "hyperparams": {"prompts_per_step": per_step, "group_size": group, "max_tokens_per_turn": max_tok, "lr": lr},
+                       "parent_run_id": None, "group_name": "lab-hosted", "description": run["note"] + " Real: every metric step" +
+                       (" and every stored sample rollout with its transcript." if run_key in by_run_rolls else "."),
+                       "source": run["url"], "provenance": "published"})
+        w.add("run_inputs", {"run_id": run_id, "kind": "environment", "ref_id": env_id, "weight": 1.0})
+        w.add_many("run_steps", step_rows)
+        ev = [{"run_id": run_id, "t": t0, "step": 0, "kind": "start", "severity": "info", "title": "Run started",
+               "body": f"{per_step} examples × {group} rollouts per step on {env_name}@{env_ver}."},
+              {"run_id": run_id, "t": t, "step": mets[-1]["step"], "kind": "end", "severity": "warning" if stopped else "info",
+               "title": "Run stopped" if stopped else "Run completed", "body": "Stopped at step 114 of 200." if stopped else ""}]
+        w.add_many("run_events", ev)
+        w.add("jobs", {"id": rid("job", run_id, "lab"), "project_id": pid, "run_id": run_id, "eval_id": None, "name": f"{run['title']} · hosted trainer",
+                       "kind": "train", "status": "stopped" if stopped else "completed", "cluster_id": cl, "gpu": None, "gpus": None, "nodes": None,
+                       "started_at": t0, "ended_at": t, "cost_usd": None, "exit": "stopped" if stopped else "completed", "log_tail": ""})
+        # sample rollouts with transcripts
+        rr = by_run_rolls.get(run_key)
+        if rr:
+            groups = defaultdict(list)
+            for a in rr["attempts"]:
+                groups[(a["version"], a["task"])].append(a)
+            rows, trans = [], []
+            for (ver, task), atts in sorted(groups.items()):
+                gid_ = rid("grp", run_id, ver, task)
+                for j, a in enumerate(sorted(atts, key=lambda z: (z["group"], z["index"]))):
+                    rew = a["reward"]
+                    if rkind == "binary":
+                        outcome = "passed" if rew >= 1 else "failed"
+                    else:
+                        outcome = "passed" if rew >= 1 else ("failed" if rew <= 0 else "partial")
+                    ro_id = rid("roll", run_id, a["id"])
+                    rub = a.get("rubric") or {}
+                    comp = GRADERS[env_name][4]
+                    counters = ("num_turns", "total_tool_calls", "score_checks_used", "score_checks_remaining")
+                    scores = [{"name": k_, "value": float(v), "weight": 1.0 if k_ == comp else None,
+                               "explanation": "The reward." if k_ == comp else "Rubric metric logged with the rollout (not the reward)."}
+                              for k_, v in rub.items() if isinstance(v, (int, float)) and not isinstance(v, bool)
+                              and (k_ == comp or (0 <= v <= 1 and not k_.endswith("_calls") and not k_.startswith("filter/") and k_ not in counters))]
+                    for sc in scores:
+                        if sc["weight"] is None:
+                            sc.pop("weight")
+                    rows.append({"id": ro_id, "run_id": run_id, "eval_id": None, "step": ver, "phase": "train", "group_id": gid_, "sample": j,
+                                 "task_id": rid("task", env_id, task), "env_id": env_id, "harness": f"{env_name}@{env_ver}", "model_id": base,
+                                 "reward": rew, "advantage": None, "scores": scores, "outcome": outcome, "stop_reason": "completed",
+                                 "turns": a["turns"], "tool_calls": a["tool_calls"], "tokens_in": a.get("tokens_in"), "tokens_out": a.get("tokens_out"),
+                                 "tokens_cached": None, "duration_s": (a.get("seconds") or {}).get("agent_execution"),
+                                 "timing": {"agent": (a.get("seconds") or {}).get("agent_execution")}, "staleness": 0, "flags": None,
+                                 "seed": stable_seed(ro_id), "trained": None})
+                    trans.append({"rollout_id": ro_id, "messages": a["messages"]})
+            w.add_many("rollouts", rows)
+            w.add_many("transcripts", trans)
+    # metric definitions: canonical signals for the tags these runs log
+    defs = []
+    for tag in sorted(all_tags):
+        signal = SIGNAL_OF.get(tag)
+        if tag == "errored_rollouts/all":
+            signal = None
+        fmt = "pct" if signal in ("all_fail_share", "all_pass_share", "truncation_rate", "infra_error_rate", "timeout_rate") else (
+            "duration" if tag == "time/step" else "num3")
+        defs.append({"tag": tag, "label": tag, "format": fmt, "grp": tag.split("/")[0], "better": "up" if signal == "reward" else "none",
+                     "signal": signal, "pinned": 1 if tag in ("reward/mean", "reward/all/mean") else 0,
+                     "description": {"reward/mean": "Mean rollout reward ('should trend upward over hundreds of steps').",
+                                     "reward/all/mean": "Mean rollout reward over all environments."}.get(tag, "Logged by the hosted run.")})
+    kit.metric_defs(w, pid, "prime_rl", extra=defs)
+    kit.report(w, pid, "hosted-notes", "What the hosted runs show", "demo, from the runs' public pages", kit.ts("2026-05-05 00:00"),
+               "Five public Lab runs, read off their own logs.",
+               [{"claim": "The computer-use WebVoyager run learned: reward 0.063 → 0.750 in 114 steps and no prompt left unsolved.", "verdict": "upheld",
+                 "evidence": "reward/mean first → last 0.063 → 0.750 (max 0.844 at step 112); batch/solve_none 0.75 → 0; turns 14.9 → 5.6."},
+                {"claim": "The calendar-scheduling run peaked early.", "verdict": "upheld",
+                 "evidence": "reward/mean 0.614 at step 0, maximum 0.880 at step 30, 0.746 at step 99; turns 8.1 → 12.3."},
+                {"claim": "prime-grep's reward is not a success rate.", "verdict": "upheld",
+                 "evidence": "It can exceed 1 because of the submission bonus (0.141 → 0.989 over 100 steps)."},
+                {"claim": "The Wikispeedia run dipped before it improved.", "verdict": "upheld",
+                 "evidence": "reward/all/mean 0.601 at step 0, minimum 0.214 at step 18, 0.779 at step 199 over about 46 h."}])
+    return pid
+
+
+def build(w, now):
+    org_id = kit.org(w, "prime-intellect", "Prime Intellect",
+                     about="Open AI infrastructure lab: the prime-rl asynchronous RL trainer, the verifiers library and Environments Hub, Prime Sandboxes, Prime Intellect Lab (hosted RL) and the INTELLECT models.",
+                     url="https://www.primeintellect.ai")
+    pid = _intellect3(w, org_id, now)
+    _hosted(w, org_id, now)
+    return {"project_id": pid, "org_id": org_id}
diff --git a/viewer/build/live.py b/viewer/build/live.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2aa2d10368b442d2ae4d4733823aa465a0d71ad
--- /dev/null
+++ b/viewer/build/live.py
@@ -0,0 +1,887 @@
+"""Build the live database from our own run records: python3 -m viewer.build.live [--records DIR] [--out PATH]
+
+The records are the ones ~/benchflow/pta-work/fw_sync.py writes, one folder per run (a folder whose name starts with "_"
+is not a run): run.json (what the run is), metrics.jsonl (the recipe's own metrics, verbatim), attempts.jsonl (one line
+per attempt), traces/<attempt>.json (transcript, verifier output, spans) and prompts/<hash>.json (system prompt and
+tools). This module maps them onto PROTOCOL.md. Everything it writes is a real value from those records, or computed
+from them (provenance "published"); what the records don't have (cost, validation runs, the policy version behind
+each attempt) stays empty rather than estimated.
+
+How the records map:
+- A training run (run.json kind "training") becomes a run of kind "rl". Its steps are fw_sync's rebuilt batches: an
+  attempt's `version` is the 0-based optimizer step that trained on it, so step = version + 1, and `trained` says
+  whether an update used it (the last batch can be sampled and never trained on).
+- A sampling-only run (kind "baseline" or "screen") becomes evals: its held-out attempts (kind "eval") an eval of the
+  held-out benchmark, its training-task attempts (kind "train") an eval of that task pool's benchmark.
+- A retried attempt counts once, as its last try: the recipe reruns an attempt that produced nothing trainable.
+- An attempt without a reward (its model call failed at Fireworks, its sandbox failed, it was cancelled, or it ended
+  before the verifier ran) is an infrastructure error: stored, counted separately, never scored as zero.
+"""
+import argparse
+import sqlite3
+import json
+import math
+import re
+import time
+from collections import Counter, defaultdict
+from datetime import datetime
+from pathlib import Path
+
+from .. import db
+from . import kit
+from . import signals as sig
+from .sim import World, rid
+
+RECORDS = Path.home() / "benchflow/pta-work/fw-rl/viewer"
+OUT = db.DATA / "live.sqlite"
+
+SUMMARY = ("GRPO with LoRA on Qwen3.8-27B through Fireworks' serverless trainer, with the OpenCode agent working in "
+           "Daytona sandboxes; Terminal-Bench 2.0 is the held-out eval.")
+
+# How an attempt ended, from the exception Harbor recorded, as a stop reason.
+EXCEPTION_STOP = {
+    "AgentTimeoutError": "agent_timeout", "NonZeroAgentExitCodeError": "agent_exit_nonzero", "CancelledError": "cancelled",
+    "SandboxBuildFailedError": "sandbox_build_failed", "EnvironmentStartTimeoutError": "sandbox_start_timeout",
+    "DaytonaError": "sandbox_error", "DaytonaConnectionError": "sandbox_connection_lost", "ApiRateLimitError": "rate_limited",
+    "NetworkConnectionError": "network_error", "RuntimeError": "runtime_error",
+}
+# Why an attempt without a reward was not scored, in words.
+UNSCORED = {
+    "SandboxBuildFailedError": "the task's sandbox image did not build",
+    "EnvironmentStartTimeoutError": "the sandbox did not start in time",
+    "DaytonaError": "the Daytona sandbox returned an error",
+    "DaytonaConnectionError": "the connection to the Daytona sandbox was lost",
+    "CancelledError": "the run stopped while the attempt was running",
+    "NonZeroAgentExitCodeError": "the agent process failed before the verifier ran",
+    "AgentTimeoutError": "the agent hit its time limit before the verifier ran",
+    "ApiRateLimitError": "a provider refused a call for too many requests",
+    "NetworkConnectionError": "a network connection failed",
+    "RuntimeError": "the harness raised a runtime error",
+}
+
+# Canonical signals (build/signals.py) and the tag that carries each in these records. Tags under attempts/ are computed
+# here from attempts.jsonl; the rest are the recipe's own.
+SIGNAL_TAGS = {
+    "rollout/raw_reward": "reward", "attempts/pass_rate": "pass_rate", "train/mean_loss": "loss",
+    "train/grad_norm": "grad_norm", "train/ppo_clip_frac": "clip_frac", "train/lr": "lr",
+    "train/inference_k3": "train_infer_kl", "attempts/tokens_out_mean": "response_len", "attempts/turns_mean": "turns",
+    "attempts/truncation_rate": "truncation_rate", "attempts/all_fail_share": "all_fail_share",
+    "attempts/all_pass_share": "all_pass_share", "attempts/mixed_share": "mixed_share",
+    "attempts/infra_error_rate": "infra_error_rate", "attempts/timeout_rate": "timeout_rate",
+    "async/version_offset_mean": "staleness", "perf/step_time": "step_time", "perf/train_time": "train_time",
+    "train/active_tokens": "tokens_trained", "perf/step_tokens_per_s": "throughput",
+    "async/in_flight_samples_mean": "active_sandboxes",
+}
+TAG_DESCRIPTIONS = {
+    "rollout/raw_reward": "Mean reward of the attempts this optimizer step trained on, as the recipe logged it (before any filtering).",
+    "attempts/pass_rate": "Share of this step's scored attempts whose reward is 1 (every test passed). Attempts without a reward are left out.",
+    "attempts/reward_mean": "Mean reward of this step's scored attempts; on trained steps it equals rollout/raw_reward.",
+    "attempts/all_pass_share": "Share of this step's task groups in which every scored attempt passed: zero advantage, no gradient.",
+    "attempts/all_fail_share": "Share of this step's task groups in which no scored attempt passed and all got the same reward (0, or one partial score): zero advantage, no gradient.",
+    "attempts/mixed_share": "Share of this step's task groups whose scored attempts got different rewards: the only groups that produce a gradient.",
+    "attempts/infra_error_rate": "Share of this step's attempts with no reward: the model call failed at Fireworks, the sandbox failed, the run was cancelled mid-attempt, or the attempt ended before the verifier ran. Excluded, not scored as zero.",
+    "attempts/timeout_rate": "Share of this step's attempts stopped at the agent's time limit; the verifier still scores what they left.",
+    "attempts/truncation_rate": "Share of this step's attempts in which a model reply stopped at the completion-token limit.",
+    "attempts/turns_mean": "Agent turns per scored attempt.",
+    "attempts/tokens_out_mean": "Tokens the model generated per scored attempt, summed over its model calls.",
+    "train/mean_loss": "Mean training loss of this optimizer step, as the Fireworks trainer logged it.",
+    "train/grad_norm": "Gradient norm of this optimizer step, as the trainer logged it.",
+    "train/ppo_clip_frac": "Share of tokens whose importance ratio was clipped.",
+    "train/lr": "Learning rate.",
+    "train/inference_k3": "k3 estimate of the KL divergence between the sampler's and the trainer's log-probs on the sampled tokens. Growth means the sampled data is off-policy for the trainer.",
+    "async/version_offset_mean": "Policy versions between sampling an attempt and training on it, averaged over the batch.",
+    "perf/step_time": "Wall-clock of the whole optimizer step, including the wait for rollouts.",
+    "perf/train_time": "Wall-clock the trainer spent on this step's update.",
+    "train/active_tokens": "Tokens that carried a training loss this step.",
+    "perf/step_tokens_per_s": "Tokens processed per second of wall-clock over the whole step.",
+    "async/in_flight_samples_mean": "Attempts in flight, each in its own sandbox, averaged over the step.",
+}
+NAMESPACE_NOTES = {
+    "producer": "Logged by the recipe's rollout producer once per producer event: this series' step is the producer event number, not the optimizer step.",
+    "tito": "From the token-in/token-out (TITO) sidecar, over this optimizer step's model calls and attempts.",
+    "train": "Logged by the Fireworks trainer for this optimizer step.",
+    "rollout": "Logged by the recipe for the batch this optimizer step trained on.",
+    "async": "Logged by the recipe's async scheduler for this optimizer step.",
+    "perf": "Timing logged by the recipe for this optimizer step.",
+    "attempts": "Computed by the viewer from this step's attempts (attempts.jsonl), each retried attempt counted once.",
+}
+PINNED = {"rollout/raw_reward", "attempts/pass_rate", "attempts/mixed_share", "attempts/infra_error_rate"}
+STATUS = {"finished": "completed", "stopped": "stopped", "failed": "failed", "running": "running", "interrupted": "stopped"}
+
+
+# ------------------------------------------------------------------ reading the records
+
+def parse_time(v):
+    """An ISO timestamp as epoch seconds, or None."""
+    if not v:
+        return None
+    try:
+        return datetime.fromisoformat(str(v).replace("Z", "+00:00")).timestamp()
+    except ValueError:
+        return None
+
+
+def jsonl(path):
+    return [json.loads(line) for line in path.read_text().splitlines() if line.strip()] if path.is_file() else []
+
+
+def plain(text):
+    """Record wording for a console that is not a competition: the held-out suite is held out, not sealed."""
+    return re.sub(r"\bsealed\b", "held-out", text) if isinstance(text, str) else text
+
+
+def final_tries(rows):
+    """One attempt per (task, dataset pass, group, index): its last try, with the tries it replaced under "earlier"."""
+    by = defaultdict(list)
+    for r in rows:
+        by[(r["task"], r.get("epoch", r["version"]), r["group"], r["index"])].append(r)
+    out = []
+    for tries in by.values():
+        tries.sort(key=lambda r: r.get("retry") or 0)
+        out.append(dict(tries[-1], earlier=tries[:-1]))
+    out.sort(key=lambda a: (a["version"], a["task"], a.get("epoch") or 0, a["group"], a["index"]))
+    return out
+
+
+class Record:
+    """One run folder of fw_sync records."""
+
+    def __init__(self, folder):
+        self.dir = folder
+        self.name = folder.name
+        self.meta = json.loads((folder / "run.json").read_text())
+        self.metrics = jsonl(folder / "metrics.jsonl")
+        self.prompts = {p.stem: json.loads(p.read_text()) for p in sorted((folder / "prompts").glob("*.json"))}
+        self.rows = jsonl(folder / "attempts.jsonl")
+        self.attempts = final_tries(self.rows)
+        for a in self.attempts:
+            trace = folder / "traces" / f"{a['id']}.json"
+            a["trace"] = json.loads(trace.read_text()) if trace.is_file() else None
+        self.kind = self.meta.get("kind") or "training"
+        self.sampling_only = self.kind != "training"
+        self.trained_steps = (self.meta.get("steps_from") or {}).get("trained_steps") or 0
+        self.steps_logged = {int(m.get("train/step", m.get("rollout/step"))): m for m in self.metrics
+                             if "rollout/step" in m and not any(k.startswith("calibration/") for k in m)}
+        self.calibration = next((m for m in self.metrics if any(k.startswith("calibration/") for k in m)), None)
+        starts = [parse_time(r.get("started_at")) for r in self.rows]
+        ends = [parse_time(r.get("finished_at")) for r in self.rows]
+        self.started_at = min((t for t in starts if t), default=parse_time(self.meta.get("started_at")))
+        self.ended_at = max((t for t in ends if t), default=None)
+        self.status = STATUS.get(self.meta.get("state"), self.meta.get("state"))
+
+    def of(self, kind):
+        return [a for a in self.attempts if a["kind"] == kind]
+
+    def sampled_by_base(self, step):
+        """Whether every attempt of this step was sampled by the untrained model: the run never finished an update, or
+        the recipe's async metrics say the newest policy version behind the batch was 0."""
+        if self.trained_steps == 0:
+            return True
+        m = self.steps_logged.get(step) or {}
+        v, off = m.get("async/trained_against_version"), m.get("async/version_offset_min")
+        return v is not None and off is not None and v - off <= 0
+
+
+def words(items):
+    items = list(items)
+    return ", ".join(items[:-1]) + " and " + items[-1] if len(items) > 1 else "".join(items)
+
+
+def reward_kinds(attempts):
+    return sorted({a.get("reward_kind") for a in attempts if a.get("reward_kind")})
+
+
+def method_params(method):
+    """The recipe settings run.json states in words, e.g. "GRPO, LoRA r64, lr 3e-5 (Fireworks serverless async RL)"."""
+    out = {}
+    if not method or method.startswith("sampling only"):
+        return out
+    out["algorithm"] = method.split(",")[0].strip()
+    m = re.search(r"LoRA r(\d+)", method)
+    if m:
+        out["lora_rank"] = int(m.group(1))
+    m = re.search(r"\blr ([0-9.]+e-?\d+|[0-9.]+)", method)
+    if m:
+        out["learning_rate"] = float(m.group(1))
+    return out
+
+
+# ------------------------------------------------------------------ one attempt as a rollout
+
+def outcome(a):
+    r = a.get("reward")
+    if r is None:
+        return "infra_error"
+    if r >= 1:
+        return "passed"
+    if a.get("exception") == "AgentTimeoutError":
+        return "timeout"
+    if a.get("truncated"):
+        return "truncated"
+    return "partial" if r > 0 else "failed"
+
+
+def stop_reason(a):
+    if a.get("discarded") and a.get("reward") is None and "model call failed" in a["discarded"]:
+        return "model_call_failed"
+    exc = a.get("exception")
+    if exc:
+        return EXCEPTION_STOP.get(exc) or re.sub(r"(?<!^)(?=[A-Z])", "_", exc).lower()
+    return {"stop": "agent_finished", "length": "max_tokens"}.get(a.get("stop"), a.get("stop"))
+
+
+def why_unscored(a):
+    if a.get("discarded") and "model call failed" in a["discarded"]:
+        return a["discarded"]
+    exc = a.get("exception")
+    if exc:
+        return UNSCORED.get(exc, f"it ended with {exc} before the verifier scored it")
+    return "the verifier recorded no reward"
+
+
+def add(*xs):
+    xs = [x for x in xs if x is not None]
+    return sum(xs) if xs else None
+
+
+def timing(a):
+    s = a.get("seconds") or {}
+    parts = {"setup": add(s.get("environment_setup"), s.get("agent_setup")), "agent": s.get("agent_execution"),
+             "generation": a.get("model_seconds"), "environment": a.get("tool_seconds"), "scoring": s.get("verifier")}
+    return {k: round(v, 1) for k, v in parts.items() if v is not None} or None
+
+
+def duration(a):
+    t0, t1 = parse_time(a.get("started_at")), parse_time(a.get("finished_at"))
+    if t0 and t1:
+        return round(t1 - t0, 1)
+    s = a.get("seconds") or {}
+    total = add(*s.values())
+    return round(total, 1) if total is not None else None
+
+
+def num(x):
+    return f"{x:.2f}".rstrip("0").rstrip(".") if isinstance(x, float) else str(x)
+
+
+def scores(a):
+    r, v = a.get("reward"), a.get("verifier") or {}
+    if r is None:
+        return [{"name": "reward", "value": None, "explanation": f"Not scored: {why_unscored(a)}. Excluded, not counted as a failure."}]
+    if v.get("total"):
+        text = f"{v['passed']} of {v['total']} tests passed"
+        if v.get("failing"):
+            text += "; failing: " + ", ".join(v["failing"][:6]) + (" …" if len(v["failing"]) > 6 else "")
+    elif v.get("summary"):
+        text = f"Verifier: {v['summary']}"
+    else:
+        text = "The verifier's output has no test summary."
+    if a.get("exception") == "AgentTimeoutError":
+        text += ". The agent hit its time limit; the verifier scored what it left"
+    partial = a.get("reward_kind") == "partial"
+    return [{"name": "tests passed (fraction)" if partial else "all tests pass", "weight": 1.0, "value": r,
+             "explanation": text + "."}]
+
+
+def arguments(args):
+    return args if isinstance(args, str) else json.dumps(args, ensure_ascii=False)
+
+
+def messages(a, prompts):
+    """The attempt's transcript in the protocol's message format, from its trace (compacted Harbor ATIF steps)."""
+    trace = a.get("trace") or {}
+    out = []
+    if a.get("earlier"):
+        tries = "; ".join(f"try {r.get('retry', 0) + 1} ended with {r.get('exception') or 'no error recorded'}"
+                          + (" (model call failed at Fireworks)" if "model call failed" in (r.get("discarded") or "") else "")
+                          for r in a["earlier"])
+        out.append({"role": "note", "content": f"The recipe ran this attempt {len(a['earlier']) + 1} times and keeps only "
+                                               f"the last try, shown here ({tries})."})
+    prompt = prompts.get(trace.get("prompt") or "")
+    if prompt and trace.get("transcript"):
+        out.append({"role": "system", "content": prompt.get("system") or ""})
+    for turn in trace.get("transcript") or []:
+        role = turn.get("role")
+        if role == "user":
+            out.append({"role": "user", "content": turn.get("text") or ""})
+        elif role == "agent":
+            m = {"role": "assistant", "content": turn.get("text") or ""}
+            if turn.get("reasoning"):
+                m["reasoning"] = turn["reasoning"]
+            calls = turn.get("calls") or []
+            if calls:
+                m["tool_calls"] = [{"id": c.get("id"), "name": c.get("name"), "arguments": arguments(c.get("args"))} for c in calls]
+            out.append(m)
+            names = {c.get("id"): c.get("name") for c in calls}
+            for res in turn.get("results") or []:
+                out.append({"role": "tool", "tool_call_id": res.get("id"), "name": names.get(res.get("id")),
+                            "content": res.get("content") or ""})
+        else:
+            out.append({"role": "note", "content": f"{role}: {turn.get('text') or ''}"})
+    if not trace.get("transcript"):
+        out.append({"role": "note", "content": "No agent transcript was recorded for this attempt."})
+    if a.get("exception"):
+        msg = (a.get("exception_message") or "").strip()
+        out.append({"role": "note", "content": f"The attempt ended with {a['exception']}" + (f": {msg[:300]}" if msg else ".")})
+    if a.get("reward") is None:
+        out.append({"role": "note", "content": f"Not scored: {why_unscored(a)}. The attempt is excluded, not counted as a failure."})
+    if trace.get("verifier_stdout"):
+        out.append({"role": "note", "content": "Verifier output, as recorded:\n" + trace["verifier_stdout"]})
+    return out
+
+
+def advantages(rewards, eps=1e-8):
+    """The recipe's GRPO advantages (training/utils/data.py compute_advantages): a z-score with the unbiased standard
+    deviation, which becomes 1 when every reward is the same."""
+    if len(rewards) < 2 or any(r is None for r in rewards):
+        return [None] * len(rewards)
+    mean = sum(rewards) / len(rewards)
+    sd = math.sqrt(sum((r - mean) ** 2 for r in rewards) / (len(rewards) - 1))
+    if sd < eps:
+        sd = 1.0
+    return [round((r - mean) / (sd + eps), 4) for r in rewards]
+
+
+def rollout_row(a, **kw):
+    return {"id": a["id"], "run_id": None, "eval_id": None, "step": None, "phase": None, "group_id": None, "sample": None,
+            "task_id": None, "env_id": None, "harness": None, "model_id": None, "reward": a.get("reward"), "advantage": None,
+            "scores": scores(a), "outcome": outcome(a), "stop_reason": stop_reason(a), "turns": a.get("turns"),
+            "tool_calls": a.get("tool_calls"), "tokens_in": a.get("tokens_in"), "tokens_out": a.get("tokens_out"),
+            "tokens_cached": a.get("tokens_cached"), "duration_s": duration(a), "timing": timing(a), "staleness": None,
+            "flags": ["retried"] if a.get("earlier") else None, "seed": None, "trained": 0, **kw}
+
+
+# ------------------------------------------------------------------ aggregates
+
+def group_facts(groups):
+    """Task groups → (all passed, all failed, mixed) counts over groups with a scored attempt. A group whose scored
+    attempts all got the same partial score counts as all failed: no attempt passed and none differed."""
+    all_pass = all_fail = mixed = 0
+    for g in groups:
+        vals = [a["reward"] for a in g if a.get("reward") is not None]
+        if not vals:
+            continue
+        if len(set(vals)) > 1:
+            mixed += 1
+        elif vals[0] >= 1:
+            all_pass += 1
+        else:
+            all_fail += 1
+    return all_pass, all_fail, mixed
+
+
+def mean(xs):
+    xs = [x for x in xs if x is not None]
+    return sum(xs) / len(xs) if xs else None
+
+
+def clustered_se(groups):
+    """Standard error of the attempt-weighted mean reward, clustered by task (per-task SE when every task has the same
+    number of attempts)."""
+    groups = [g for g in groups if g]
+    n, total = len(groups), sum(len(g) for g in groups)
+    if n < 2:
+        return None
+    p = sum(sum(g) for g in groups) / total
+    return math.sqrt(n / (n - 1) * sum((sum(g) - p * len(g)) ** 2 for g in groups)) / total
+
+
+def pass_rate(attempts):
+    vals = [a["reward"] for a in attempts if a.get("reward") is not None]
+    return (sum(1 for v in vals if v >= 1) / len(vals), len(vals)) if vals else (None, 0)
+
+
+def screen_status(results):
+    """A training task's status from the learnability screens: [(screen, reward kind, [scored rewards])]."""
+    results = [(n, k, v) for n, k, v in results if v]
+    if not results:
+        return "ok", "No scored attempt in the screens yet."
+    for n, _, v in results:
+        if len(set(v)) > 1:
+            return "ok", f"Attempts scored differently in {n} ({', '.join(num(x) for x in v)}), so GRPO gets a signal from it."
+    where = "; ".join(f"{n}: {len(v)} of {len(v)} scored {num(v[0])}" + ("" if k == "partial" else " (pass/fail reward)")
+                      for n, k, v in results)
+    allv = [x for _, _, v in results for x in v]
+    if all(x >= 1 for x in allv):
+        return "too_easy", f"Passed every attempt in the screens ({where}): no GRPO signal."
+    if all(x <= 0 for x in allv):
+        return "too_hard", f"Scored 0 on every attempt in the screens ({where}): no GRPO signal."
+    return "too_hard", f"Never fully solved, and every attempt in a screen got the same score ({where}): no GRPO signal."
+
+
+# ------------------------------------------------------------------ build
+
+def build(records_dir, out_path, now=None):
+    records_dir, out_path = Path(records_dir), Path(out_path)
+    recs = [Record(p) for p in sorted(records_dir.iterdir())
+            if p.is_dir() and not p.name.startswith("_") and (p / "run.json").is_file()]
+    if not recs:
+        raise SystemExit(f"No run records under {records_dir}")
+    ids = Counter(a["id"] for r in recs for a in r.attempts)
+    dup = [k for k, n in ids.items() if n > 1]
+    if dup:
+        raise SystemExit(f"Attempt ids repeat across runs: {dup[:3]}")
+    now = now or time.time()
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = out_path.with_suffix(".building")
+    w = World(tmp, now)
+    w.meta(source="live", now=now, built_at=time.time(), version="3", records=str(records_dir))
+    oid = kit.org(w, "benchflow", "BenchFlow")
+    first = min(r.started_at for r in recs if r.started_at)
+    names = ", ".join(r.name for r in recs)
+    pid = kit.project(
+        w, oid, "fireworks-rl", "Terminal-agent RL on Fireworks", SUMMARY, [],
+        f"Built by viewer/build/live.py from the run records fw_sync.py writes, for {len(recs)} runs: {names}. Metrics are "
+        "the recipe's own; per-step facts, pass rates and scores are computed from the attempts; transcripts are the "
+        "agents' own. A retried attempt counts once, as its last try. An attempt without a reward (its model call failed at "
+        "Fireworks, its sandbox failed, or it ended before the verifier ran) is an infrastructure error: counted separately, "
+        "never scored as zero. The records carry no cost.",
+        first, pins=sorted(PINNED))
+
+    # graders, one per reward kind
+    grader_ids = {
+        "partial": kit.grader(w, pid, "partial", "Task tests, fraction passed", "unit_tests",
+                              "The task's pytest tests run in its sandbox after the agent finishes; the reward is the share that pass.",
+                              [{"name": "tests passed (fraction)", "weight": 1.0, "rule": "Tests passed divided by tests run."}],
+                              "reward = tests passed / tests run"),
+        "binary": kit.grader(w, pid, "binary", "Task tests, pass/fail", "unit_tests",
+                             "The task's tests run in its sandbox after the agent finishes; the reward is 1 only if every test passes.",
+                             [{"name": "all tests pass", "weight": 1.0, "rule": "1 if every test passes, else 0."}],
+                             "reward = 1 if every test passes, else 0"),
+    }
+
+    # models: the base model, and each training run's adapter once an update was applied
+    meta0 = recs[0].meta
+    base_id = kit.model(w, pid, "base", meta0.get("model") or meta0.get("base_model"), kind="base",
+                        hf_repo=(meta0.get("tokenizer") or "").split("@")[0] or None, stage="base", status="available",
+                        notes=f"Served by Fireworks as {meta0.get('base_model')}; tokenizer {meta0.get('tokenizer')}.")
+
+    # environments: one per training-task pool that runs trained or screened on
+    pools = defaultdict(list)
+    for r in recs:
+        if r.of("train"):
+            pools[r.meta.get("collection") or "Training tasks"].append(r)
+    harness = meta0.get("agent")
+    tools = sorted({t["name"] for r in recs for p in r.prompts.values() for t in p.get("tools") or [] if t.get("name")})
+    instructions = {}
+    for r in recs:
+        for a in r.attempts + [e for x in r.attempts for e in x["earlier"]]:
+            tr = (a.get("trace") or {}).get("transcript") or []
+            if tr and tr[0].get("role") == "user" and tr[0].get("text"):
+                instructions.setdefault(a["task"], tr[0]["text"])
+    screens = [r for r in recs if r.sampling_only and r.of("train")]
+    envs = {}
+    for collection, runs in sorted(pools.items(), key=lambda kv: min(r.started_at for r in kv[1])):
+        name = re.sub(r"\s*\(organizer\)\s*$", "", collection).strip()
+        key = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+        env_id = rid("env", pid, key)
+        pool = sorted(set(t for r in runs for t in r.meta.get("train_pool") or []) | {a["task"] for r in runs for a in r.of("train")})
+        kinds = reward_kinds([a for r in runs for a in r.of("train")])
+        now_kind = next((k for k in reversed(kinds_by_time(runs)) if k), "binary")
+        trained = [r for r in runs if not r.sampling_only and r.trained_steps > 0]
+        latest_run = max(trained, key=lambda r: r.started_at) if trained else None
+        tasks, task_rows = {}, []
+        for t in pool:
+            base_atts = [a for s in screens for a in s.of("train") if a["task"] == t]
+            base, n_base = pass_rate(base_atts)
+            status, reason = screen_status([(s.name, (reward_kinds(s.of("train")) or ["binary"])[0],
+                                             [a["reward"] for a in s.of("train") if a["task"] == t and a.get("reward") is not None])
+                                            for s in screens])
+            latest = None
+            if latest_run:
+                steps = sorted({a["version"] for a in latest_run.of("train") if a["task"] == t and a.get("reward") is not None})
+                if steps:
+                    latest, _ = pass_rate([a for a in latest_run.of("train") if a["task"] == t and a["version"] == steps[-1]])
+            tid = rid("task", env_id, t)
+            tasks[t] = tid
+            task_rows.append({"id": tid, "env_id": env_id, "name": t, "instruction": instructions.get(t), "difficulty": None,
+                              "tags": [], "status": status, "status_reason": reason, "oracle_score": None, "noop_score": None,
+                              "reruns": None, "rerun_agree": None, "base_pass": None if base is None else round(base, 4),
+                              "latest_pass": None if latest is None else round(latest, 4), "attempts": n_base})
+        desc = (f"{len(pool)} terminal tasks from the task pool \"{name}\". The agent ({harness}) works in a "
+                f"{meta0.get('sandbox')} sandbox; the task's own tests score the final state. "
+                + ("The reward is the share of tests passed (partial credit)" if now_kind == "partial" else "The reward is pass/fail")
+                + (f"; {words(r.name for r in runs if 'binary' in reward_kinds(r.of('train')))} ran before that, with pass/fail reward"
+                   if now_kind == "partial" and "binary" in kinds else "") + ". "
+                + (f"Base pass rates are the untrained model's attempts in the screens ({words(s.name for s in screens)}). " if screens else "")
+                + (f"Latest pass rates are each task's most recent {latest_run.name} batch that scored it." if latest_run
+                   else "No run on this pool finished an update, so there are no latest-policy pass rates."))
+        checks = env_checks(runs, screens, pool)
+        w.add("environments", {"id": env_id, "project_id": pid, "name": name, "domain": "terminal", "version": "",
+                               "description": desc, "harness": harness, "tools": tools, "grader_id": grader_ids[now_kind],
+                               "reward_kind": now_kind, "sandbox": {"provider": meta0.get("sandbox")}, "task_count": len(pool),
+                               "created_at": min(r.started_at for r in runs), "source": None, "provenance": "published",
+                               "checks": checks})
+        w.add_many("tasks", task_rows)
+        envs[collection] = {"id": env_id, "name": name, "key": key, "tasks": tasks}
+
+    # benchmarks: the held-out suite, and each screened training-task pool
+    held = sorted({t for r in recs for t in r.meta.get("eval_tasks") or []} | {a["task"] for r in recs for a in r.of("eval")})
+    suite = plain(meta0.get("eval_suite") or "Held-out tasks").split(",")[0].strip()
+    k_held = max([n for r in recs for n in Counter(a["task"] for a in r.of("eval")).values()] or [1])
+    held_id = rid("bench", pid, "heldout")
+    held_kind = (reward_kinds([a for r in recs for a in r.of("eval")]) or ["binary"])[0]
+    w.add("benchmarks", {"id": held_id, "project_id": pid, "name": f"{suite} ({len(held)} held-out tasks)",
+                         "version": (re.search(r"\d+(\.\d+)+", suite) or [""])[0], "category": "terminal",
+                         "metric": f"avg@{k_held}", "harness": harness, "n_tasks": len(held), "k": k_held,
+                         "description": f"{len(held)} {suite} tasks held out from training. Each attempt runs {harness} in a "
+                                        f"{meta0.get('sandbox')} sandbox and is scored "
+                                        + ("pass/fail" if held_kind == "binary" else "by the share of tests passed")
+                                        + " by the task's own tests; the score is the mean over scored attempts, and attempts "
+                                          "the harness could not score are excluded, not counted as failures.",
+                         "source": None})
+    held_tasks = {t: rid("task", held_id, t) for t in held}
+    pool_bench = {}
+    for s in screens:
+        collection = s.meta.get("collection") or "Training tasks"
+        if collection in pool_bench or collection not in envs:
+            continue
+        env = envs[collection]
+        k = max(n for r in screens if (r.meta.get("collection") or "Training tasks") == collection
+                for n in Counter(a["task"] for a in r.of("train")).values())
+        bid = rid("bench", pid, "pool", env["key"])
+        w.add("benchmarks", {"id": bid, "project_id": pid, "name": f"{env['name']} (training tasks)", "version": "",
+                             "category": "training tasks", "metric": f"avg@{k}", "harness": harness,
+                             "n_tasks": len(env["tasks"]), "k": k,
+                             "description": "Not held out: these are training tasks, sampled with the untrained model to find the "
+                                            "ones whose attempts score differently (a learnability screen). The score is the mean "
+                                            "reward over scored attempts: the share of tests passed, or pass/fail for screens "
+                                            "that ran before the partial-credit reward.",
+                             "source": None})
+        pool_bench[collection] = bid
+
+    rollouts, transcripts, jobs = [], [], []
+    cluster_id = kit.cluster(w, oid, "fireworks", "Fireworks serverless", "Fireworks")
+    heldout_by_run = {}
+
+    def eval_record(r, kind, attempts, *, run_id=None, step=None, key=None):
+        """One eval of a record's attempts of one kind, with per-task results and every attempt as a rollout."""
+        if kind == "eval":
+            bench_id, task_ids, env_id = held_id, held_tasks, None
+        else:
+            collection = r.meta.get("collection") or "Training tasks"
+            bench_id, task_ids, env_id = pool_bench[collection], envs[collection]["tasks"], envs[collection]["id"]
+        eval_id = rid("eval", bench_id, key or r.name)
+        by_task = defaultdict(list)
+        for a in attempts:
+            by_task[a["task"]].append(a)
+        rows, groups = [], []
+        for t, atts in sorted(by_task.items()):
+            atts.sort(key=lambda a: (a["group"], a["index"]))
+            gid = rid("grp", eval_id, t)
+            for i, a in enumerate(atts):
+                rollouts.append(rollout_row(a, eval_id=eval_id, run_id=run_id, step=step, phase="eval", group_id=gid, sample=i,
+                                            task_id=task_ids.get(t) or rid("task", bench_id, t), env_id=env_id, harness=harness,
+                                            model_id=base_id if (run_id is None or step == 0) else None))
+                transcripts.append({"rollout_id": a["id"], "messages": json.dumps(messages(a, r.prompts), ensure_ascii=False)})
+            vals = [a["reward"] for a in atts if a.get("reward") is not None]
+            if not vals:
+                continue
+            groups.append(vals)
+            scored = [a for a in atts if a.get("reward") is not None]
+            rows.append({"eval_id": eval_id, "task_id": task_ids.get(t) or rid("task", bench_id, t), "task_name": t,
+                         "attempts": len(vals), "passes": sum(1 for v in vals if v >= 1), "infra": len(atts) - len(vals),
+                         "score": round(sum(vals) / len(vals), 4), "mean_turns": mean([a.get("turns") for a in scored]),
+                         "mean_tokens": mean([a.get("tokens_out") for a in scored])})
+        flat = [v for g in groups for v in g]
+        starts = [parse_time(a.get("started_at")) for a in attempts]
+        ends = [parse_time(a.get("finished_at")) for a in attempts]
+        config = {k: plain(v) for k, v in r.meta.items() if k not in ("train_pool", "eval_tasks", "updated_at")}
+        config["reward"] = reward_kinds(attempts)
+        if r.calibration:
+            config["recipe_metrics"] = {k: v for k, v in r.calibration.items() if k.startswith("calibration/")}
+        w.add("evals", {"id": eval_id, "project_id": pid, "benchmark_id": bench_id, "model_id": base_id if run_id is None or step == 0 else None,
+                        "run_id": run_id, "step": step, "status": r.status if run_id is None else "completed",
+                        "score": round(sum(flat) / len(flat), 5) if flat else None,
+                        "stderr": None if clustered_se(groups) is None else round(clustered_se(groups), 5),
+                        "n_tasks": len(groups), "k": max(Counter(a["task"] for a in attempts).values()),
+                        "n_infra": sum(1 for a in attempts if a.get("reward") is None),
+                        "started_at": min((t for t in starts if t), default=None), "ended_at": max((t for t in ends if t), default=None),
+                        "cost_usd": None, "config": json.dumps(config, indent=1, ensure_ascii=False), "command": None,
+                        "source": None, "provenance": "published"})
+        w.add_many("eval_tasks", rows)
+        if kind == "eval" and run_id is None:
+            heldout_by_run[r.name] = (sum(1 for v in flat if v >= 1), len(flat))
+        return eval_id
+
+    # evals: sampling-only records (baselines on the held-out suite, screens of training tasks)
+    for r in recs:
+        if not r.sampling_only:
+            continue
+        for kind in ("eval", "train"):
+            atts = r.of(kind)
+            if atts:
+                eid = eval_record(r, kind, atts)
+                jobs.append({"id": rid("job", eid), "project_id": pid, "run_id": None, "eval_id": eid,
+                             "name": f"{r.name} · sampling", "kind": "eval", "status": r.status, "cluster_id": cluster_id,
+                             "gpu": None, "gpus": None, "nodes": None, "started_at": r.started_at, "ended_at": r.ended_at,
+                             "cost_usd": None, "exit": r.meta.get("state"), "log_tail": None})
+
+    # runs: training records
+    series_tags = set()
+    for r in recs:
+        if r.sampling_only:
+            continue
+        collection = r.meta.get("collection") or "Training tasks"
+        env = envs.get(collection)
+        run_id = kit.run_id(pid, r.name)
+        params = method_params(r.meta.get("method"))
+        out_model = None
+        if r.trained_steps:
+            out_model = kit.model(w, pid, f"adapter:{r.name}", f"{r.name} · LoRA r{params.get('lora_rank', '?')}, step {r.trained_steps}",
+                                  kind="checkpoint", parent_id=base_id, run_key=r.name, step=r.trained_steps, stage="RL",
+                                  created_at=r.ended_at, status="expired" if r.status != "running" else "training",
+                                  notes=f"The adapter after {r.trained_steps} {params.get('algorithm', 'RL')} updates. It lived in the "
+                                        "run's Fireworks training session, which ended with the run; it was not evaluated on the held-out tasks.")
+        train = r.of("train")
+        by_step = defaultdict(list)
+        for a in train:
+            by_step[a["version"] + 1].append(a)
+        steps, values = [], {}
+        for step, atts in sorted(by_step.items()):
+            groups = defaultdict(list)
+            for a in atts:
+                groups[(a["task"], a.get("epoch") or 0, a["group"])].append(a)
+            base_step = r.sampled_by_base(step)
+            for (task, epoch, g), members in groups.items():
+                members.sort(key=lambda a: a["index"])
+                gid = rid("grp", run_id, task, epoch, g)
+                trained = all(a.get("trained") is True for a in members)
+                adv = advantages([a.get("reward") for a in members]) if trained else [None] * len(members)
+                for a, v in zip(members, adv):
+                    rollouts.append(rollout_row(a, run_id=run_id, step=step, phase="train", group_id=gid, sample=a["index"],
+                                                task_id=env["tasks"].get(task) if env else None, env_id=env["id"] if env else None,
+                                                harness=harness, model_id=base_id if base_step else None, advantage=v,
+                                                trained=1 if a.get("trained") is True else 0))
+                    transcripts.append({"rollout_id": a["id"], "messages": json.dumps(messages(a, r.prompts), ensure_ascii=False)})
+            scored = [a for a in atts if a.get("reward") is not None]
+            ap, af, mx = group_facts(groups.values())
+            n_groups = ap + af + mx
+            rate, _ = pass_rate(atts)
+            toks = [add(a.get("tokens_in"), a.get("tokens_out")) for a in atts]
+            starts = [parse_time(a.get("started_at")) for a in atts]
+            ends = [parse_time(a.get("finished_at")) for a in atts]
+            steps.append({"run_id": run_id, "step": step, "phase": "train", "started_at": min((t for t in starts if t), default=None),
+                          "ended_at": max((t for t in ends if t), default=None), "prompts": len(groups), "rollouts": len(atts),
+                          "rollouts_stored": len(atts), "reward_mean": None if not scored else round(mean([a["reward"] for a in scored]), 4),
+                          "pass_rate": None if rate is None else round(rate, 4), "tokens": sum(t for t in toks if t) or None,
+                          "groups_all_pass": ap, "groups_all_fail": af, "groups_mixed": mx,
+                          "infra_errors": len(atts) - len(scored), "truncated": sum(1 for a in atts if a.get("truncated"))})
+            derived = {"attempts/pass_rate": rate, "attempts/reward_mean": mean([a["reward"] for a in scored]),
+                       "attempts/all_pass_share": ap / n_groups if n_groups else None,
+                       "attempts/all_fail_share": af / n_groups if n_groups else None,
+                       "attempts/mixed_share": mx / n_groups if n_groups else None,
+                       "attempts/infra_error_rate": (len(atts) - len(scored)) / len(atts),
+                       "attempts/timeout_rate": sum(1 for a in atts if a.get("exception") == "AgentTimeoutError") / len(atts),
+                       "attempts/truncation_rate": sum(1 for a in atts if a.get("truncated")) / len(atts),
+                       "attempts/turns_mean": mean([a.get("turns") for a in scored]),
+                       "attempts/tokens_out_mean": mean([a.get("tokens_out") for a in scored])}
+            if env:
+                derived[f"by_env/{env['key']}/pass_rate"] = rate
+                derived[f"by_env/{env['key']}/share"] = 1.0
+                derived[f"by_env/{env['key']}/infra_error_rate"] = derived["attempts/infra_error_rate"]
+            for tag, v in derived.items():
+                if v is not None:
+                    values[(tag, step)] = v
+        # the recipe's own metrics: per optimizer step, and the producer's per-event log under its own step
+        for m in r.metrics:
+            if any(k.startswith("calibration/") for k in m):
+                continue
+            step = int(m.get("train/step", m.get("rollout/step", m.get("step", 0))))
+            for tag, v in m.items():
+                if tag != "step" and isinstance(v, (int, float)) and not isinstance(v, bool) and math.isfinite(v):
+                    values[(tag, step)] = float(v)
+        w.add_many("metrics", [{"run_id": run_id, "tag": t, "step": s, "value": v} for (t, s), v in sorted(values.items())])
+        series_tags |= {t for t, _ in values}
+        w.add_many("run_steps", steps)
+        kinds = reward_kinds(train)
+        primary = "rollout/raw_reward" if any(t == "rollout/raw_reward" for t, _ in values) else "attempts/pass_rate"
+        planned = r.meta.get("planned") or {}
+        hp = {**params, "completions_per_prompt": r.meta.get("completions_per_prompt"),
+              "prompt_groups_per_step": r.meta.get("prompt_groups_per_step"), "planned_steps": planned.get("steps"),
+              "task_draws": planned.get("task_draws"), "reward": ", ".join(kinds), "agent": harness,
+              "sandbox": r.meta.get("sandbox"), "tokenizer": r.meta.get("tokenizer")}
+        hp = {k: v for k, v in hp.items() if v not in (None, "")}
+        base_note = ""
+        baseline = r.meta.get("baseline_run")
+        if baseline in heldout_by_run and heldout_by_run[baseline][1]:
+            p, n = heldout_by_run[baseline]
+            base_note = f" Its step-0 held-out score is {baseline}'s: {p} of {n} scored attempts passed ({p / n:.1%})."
+        n_tasks = len(env["tasks"]) if env else len({a["task"] for a in train})
+        desc = (f"{r.meta.get('method')} on {n_tasks} training tasks ({env['name'] if env else plain(collection)}): {r.meta.get('prompt_groups_per_step')} tasks × "
+                f"{r.meta.get('completions_per_prompt')} attempts per step, {harness} in {r.meta.get('sandbox')} sandboxes, "
+                f"{' and '.join('partial-credit' if k == 'partial' else 'pass/fail' for k in kinds)} reward.{base_note}")
+        code = r.meta.get("code") or {}
+        w.add("runs", {"id": run_id, "project_id": pid, "name": r.name, "kind": "rl", "stage": "RL",
+                       "algorithm": params.get("algorithm"), "framework": "fireworks", "status": r.status,
+                       "status_reason": r.meta.get("note"), "base_model_id": base_id, "output_model_id": out_model,
+                       "started_at": r.started_at, "ended_at": r.ended_at if r.status != "running" else None,
+                       "updated_at": r.ended_at, "steps_planned": planned.get("steps"), "steps_done": r.trained_steps,
+                       "primary_metric": primary, "gpu": None, "gpus": None, "cost_usd": None, "cost_rate": None, "owner": None,
+                       "tags": [f"{'partial-credit' if k == 'partial' else 'pass/fail'} reward" for k in kinds],
+                       "code_ref": f"{code['repo']} @ {code['commit'][:10]}" if code.get("commit") else None,
+                       "config": json.dumps({k: plain(v) for k, v in r.meta.items() if k != "updated_at"}, indent=1, ensure_ascii=False),
+                       "config_format": "json", "hyperparams": hp, "parent_run_id": None, "group_name": None,
+                       "description": desc, "source": None, "provenance": "published"})
+        if env:
+            w.add("run_inputs", {"run_id": run_id, "kind": "environment", "ref_id": env["id"],
+                                 "weight": r.meta.get("prompt_groups_per_step")})
+        events = [{"run_id": run_id, "t": r.started_at, "step": 0, "kind": "start", "severity": "info", "title": "Run started",
+                   "body": f"{r.meta.get('method')}: {r.meta.get('prompt_groups_per_step')} tasks × {r.meta.get('completions_per_prompt')} "
+                           f"attempts per step, {planned.get('steps') or '?'} steps planned."}]
+        for step, atts in sorted(by_step.items()):
+            if step > r.trained_steps and not any(a.get("trained") for a in atts):
+                events.append({"run_id": run_id, "t": min((parse_time(a.get("started_at")) for a in atts if a.get("started_at")), default=r.started_at),
+                               "step": step, "kind": "notice", "severity": "info", "title": f"Step {step}: sampled, never trained",
+                               "body": f"The run sampled {len(atts)} attempts ({len({(a['task'], a.get('epoch'), a['group']) for a in atts})} "
+                                       "task groups) that no update used: it stopped before training on them."})
+        if r.status != "running":
+            events.append({"run_id": run_id, "t": r.ended_at, "step": r.trained_steps, "kind": "end",
+                           "severity": {"completed": "info", "failed": "error"}.get(r.status, "warning"),
+                           "title": {"completed": "Run completed", "failed": "Run failed"}.get(r.status, "Run stopped"),
+                           "body": r.meta.get("note") or f"State in the records: {r.meta.get('state')}."})
+        w.add_many("run_events", events)
+        jobs.append({"id": rid("job", run_id), "project_id": pid, "run_id": run_id, "eval_id": None,
+                     "name": f"{r.name} · trainer and sampler", "kind": "train", "status": r.status, "cluster_id": cluster_id,
+                     "gpu": None, "gpus": None, "nodes": None, "started_at": r.started_at,
+                     "ended_at": r.ended_at if r.status != "running" else None, "cost_usd": None, "exit": r.meta.get("state"),
+                     "log_tail": None})
+        # held-out attempts sampled during training: one eval per step
+        for version in sorted({a["version"] for a in r.of("eval")}):
+            eval_record(r, "eval", [a for a in r.of("eval") if a["version"] == version], run_id=run_id, step=version,
+                        key=f"{r.name}@{version}")
+
+    w.add_many("rollouts", rollouts)
+    w.add_many("transcripts", transcripts)
+    w.add_many("jobs", jobs)
+    w.add_many("metric_defs", metric_defs(pid, series_tags, envs))
+    w.close()
+    tmp.replace(out_path)
+    return w.counts
+
+
+def kinds_by_time(runs):
+    """Each run's reward kind for its training-task attempts, oldest run first."""
+    return [(reward_kinds(r.of("train")) or [None])[-1] for r in sorted(runs, key=lambda r: r.started_at)]
+
+
+def env_checks(runs, screens, pool):
+    """Checks on a task pool computed from the records: the learnability screen, and sandbox image builds."""
+    out = []
+    per_task = {t: [(s.name, [a["reward"] for a in s.of("train") if a["task"] == t and a.get("reward") is not None]) for s in screens]
+                for t in pool}
+    measured = {t: v for t, v in per_task.items() if any(x for _, x in v)}
+    if measured:
+        signal = sorted(t for t, v in measured.items() if any(len(set(x)) > 1 for _, x in v))
+        flat = {t: [x for _, xs in v for x in xs] for t, v in measured.items() if t not in signal}
+        easy = sum(1 for v in flat.values() if all(x >= 1 for x in v))
+        zero = sum(1 for v in flat.values() if all(x <= 0 for x in v))
+        same = len(flat) - easy - zero
+        out.append({"name": "Learnability screen", "status": "pass" if len(signal) >= len(measured) / 2 else "warn",
+                    "detail": f"{len(signal)} of {len(measured)} tasks give GRPO a signal: attempts by the untrained model scored "
+                              f"differently ({words(s.name for s in screens)})."
+                              + (f" Of the rest, {easy} passed every attempt, {zero} scored 0 every time and {same} got the same "
+                                 "partial score every time." if len(signal) < len(measured) else "")
+                              + (f" Tasks with a signal: {', '.join(signal)}." if len(signal) <= 12 else ""),
+                    "rounds": None, "source": None})
+    broken = defaultdict(set)
+    for r in runs:
+        for a in r.attempts:
+            if a["task"] in pool and a.get("exception") == "SandboxBuildFailedError":
+                broken[a["task"]].add(r.name)
+    if broken:
+        last_fail = {t: max(r.started_at for r in runs if r.name in names) for t, names in broken.items()}
+        fixed = sorted(t for t in broken if any(a["task"] == t and a.get("reward") is not None and r.started_at > last_fail[t]
+                                                for r in runs for a in r.attempts))
+        where = words(sorted({n for names in broken.values() for n in names}))
+        out.append({"name": "Sandbox images build", "status": "pass" if len(fixed) == len(broken) else "warn",
+                    "detail": f"{len(broken)} of {len(pool)} tasks failed to build their sandbox image in {where}; {len(fixed)} of "
+                              "them built and were scored in a later run.", "rounds": None, "source": None})
+    return out or None
+
+
+def metric_defs(pid, tags, envs):
+    rows = []
+    env_names = {e["key"]: (e["id"], e["name"]) for e in envs.values()}
+    for tag in sorted(tags):
+        ns = tag.split("/")[0]
+        signal = SIGNAL_TAGS.get(tag)
+        row = {"project_id": pid, "tag": tag, "label": tag, "description": TAG_DESCRIPTIONS.get(tag) or NAMESPACE_NOTES.get(ns, ""),
+               "unit": "", "format": "num3", "grp": ns, "better": "none", "pinned": 1 if tag in PINNED else 0, "signal": signal}
+        if signal:
+            label, unit, fmt, better, grp, _ = sig.SIGNALS[signal]
+            row.update(label=label, unit=unit, format=fmt, better=better, grp=grp)
+        elif tag.startswith("attempts/"):
+            row.update(label={"attempts/reward_mean": "Mean reward (attempts)"}.get(tag, tag), better="up" if tag == "attempts/reward_mean" else "none")
+        m = re.match(r"by_env/([^/]+)/(pass_rate|share|infra_error_rate)$", tag)
+        if m and m.group(1) in env_names:
+            env_id, name = env_names[m.group(1)]
+            kind = m.group(2)
+            row.update({"pass_rate": dict(label=f"Pass rate · {name}", signal=f"env_pass_rate@{env_id}", better="up",
+                                          description=f"Share of this step's scored attempts on {name} that passed."),
+                        "share": dict(label=f"Batch share · {name}", signal=f"env_share@{env_id}",
+                                      description=f"Share of this step's task groups drawn from {name}."),
+                        "infra_error_rate": dict(label=f"Infra errors · {name}", signal=f"env_infra@{env_id}", better="down",
+                                                 description=f"Share of this step's attempts on {name} with no reward.")}[kind],
+                       format="pct", grp="by_env")
+        elif ns == "attempts" and tag not in ("attempts/turns_mean", "attempts/tokens_out_mean", "attempts/reward_mean"):
+            row["format"] = "pct"
+        rows.append(row)
+    return rows
+
+
+SECRET_PATTERNS = [
+    # PEM private key bodies (tasks generate throwaway keys and print them); keep the header, drop the key
+    # (bodies may be indented, JSON-escaped, or shown truncated with "..." as agents often print them)
+    (re.compile(r"(-----BEGIN ([A-Z ]*)PRIVATE KEY-----)((?:\\\\n|\\n|\n|[A-Za-z0-9+/=\s]|\.\.\.|…)*?)(-----END \2PRIVATE KEY-----)"), r"\1\n[key body removed by the viewer]\n\4"),
+    (re.compile(r"(-----BEGIN ([A-Z ]*)PRIVATE KEY-----)(?:(?:\\\\n|\\n|\n)[ \t]*)+[A-Za-z0-9+/=]{40,}(?:(?:\\\\n|\\n|\n)[ \t]*[A-Za-z0-9+/=]{4,})*(?:\.\.\.|…)?"), r"\1\n[key body removed by the viewer]"),
+    (re.compile(r"\b(fw_|hf_|ghp_|gho_|github_pat_|dtn_|sk-(?:proj-)?)[A-Za-z0-9_-]{16,}"), r"\1[redacted]"),
+    (re.compile(r"\bAKIA[0-9A-Z]{16}\b"), "AKIA[redacted]"),
+]
+
+
+def redact(text):
+    if not isinstance(text, str):
+        return text
+    for pat, rep in SECRET_PATTERNS:
+        text = pat.sub(rep, text)
+    return text
+
+
+def scrub(db_path):
+    """Remove secrets and key material from every free-text column of the built database."""
+    conn = sqlite3.connect(db_path)
+    cols = {"transcripts": ["messages"], "tasks": ["instruction", "status_reason"], "runs": ["config", "description", "status_reason"],
+            "evals": ["config", "command"], "run_events": ["title", "body"], "jobs": ["log_tail"], "rollouts": ["flags", "scores"],
+            "benchmarks": ["description"], "environments": ["description"]}
+    changed = 0
+    for table, cs in cols.items():
+        have = {r[1] for r in conn.execute(f"PRAGMA table_info({table})")}
+        for col in cs:
+            if col not in have:
+                continue
+            for rowid, v in conn.execute(f"SELECT rowid, {col} FROM {table}").fetchall():
+                new = redact(v)
+                if new != v:
+                    conn.execute(f"UPDATE {table} SET {col}=? WHERE rowid=?", (new, rowid))
+                    changed += 1
+    conn.commit()
+    conn.execute("VACUUM")
+    conn.close()
+    return changed
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    ap.add_argument("--records", default=str(RECORDS), help="records root: one folder per run (default %(default)s)")
+    ap.add_argument("--out", default=str(OUT), help="database to write (default %(default)s)")
+    args = ap.parse_args()
+    t0 = time.time()
+    counts = build(args.records, args.out)
+    counts["redacted_fields"] = scrub(args.out)
+    out = Path(args.out)
+    print(out, f"{out.stat().st_size / 1e6:.1f} MB in {time.time() - t0:.1f}s", dict(sorted(counts.items())))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/viewer/build/signals.py b/viewer/build/signals.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d1a774ad483c738287286ec51bb5be0a6d92912
--- /dev/null
+++ b/viewer/build/signals.py
@@ -0,0 +1,129 @@
+"""Canonical training signals and the tag each framework logs them under.
+
+The viewer's health view asks for signals ("entropy", "infra_error_rate"); each project's
+metric_defs map its framework's own tag names onto them.
+"""
+
+SIGNALS = {
+    # id: (label, unit, format, better, group, description)
+    "reward": ("Reward", "", "num3", "up", "learning", "Mean reward of the trajectories trained on this step."),
+    "pass_rate": ("Pass rate", "", "pct", "up", "learning", "For each prompt sampled this step, the share of its attempts that passed, averaged over prompts."),
+    "loss": ("Loss", "", "num3", "down", "learning", "Training loss."),
+    "val_loss": ("Validation loss", "", "num3", "down", "learning", "Loss on a held-out split."),
+    "entropy": ("Entropy", "nats/token", "num3", "none", "stability", "Mean per-token entropy of the policy. A fast fall means the policy stopped exploring."),
+    "grad_norm": ("Gradient norm", "", "num3", "none", "stability", "Global gradient norm before clipping. Spikes precede divergence."),
+    "pg_loss": ("Policy-gradient loss", "", "num3", "none", "stability", "Clipped policy-gradient objective."),
+    "clip_frac": ("Clip fraction", "", "pct", "none", "stability", "Share of tokens whose importance ratio was clipped."),
+    "kl_ref": ("KL to reference", "", "num4", "none", "stability", "KL divergence between the policy and the reference model."),
+    "lr": ("Learning rate", "", "sci", "none", "stability", "Optimizer learning rate."),
+    "train_infer_kl": ("Trainer vs sampler KL", "", "num4", "down", "consistency", "KL between the inference engine's and the trainer's log-probs on the same tokens. Growth means the sampled data is off-policy for the trainer."),
+    "response_len": ("Response length", "tokens", "compact", "none", "length", "Tokens generated per trajectory."),
+    "context_len": ("Context length", "tokens", "compact", "none", "length", "Prompt plus response tokens per trajectory."),
+    "truncation_rate": ("Truncated", "", "pct", "down", "length", "Share of trajectories cut off at the length limit."),
+    "turns": ("Turns", "per trajectory", "num1", "none", "length", "Agent turns per trajectory."),
+    "all_fail_share": ("No-signal: all failed", "", "pct", "down", "signal", "Share of prompts where every attempt failed. Their advantages are all zero, so they teach nothing."),
+    "all_pass_share": ("No-signal: all passed", "", "pct", "down", "signal", "Share of prompts where every attempt passed. Also zero advantage."),
+    "mixed_share": ("Groups with signal", "", "pct", "up", "signal", "Share of prompts whose attempts disagree, the only ones that produce a gradient."),
+    "infra_error_rate": ("Infrastructure errors", "", "pct", "down", "infra", "Share of trajectories lost to sandbox, network or grader failures. Excluded from the reward, not scored as zero."),
+    "timeout_rate": ("Timeouts", "", "pct", "down", "infra", "Share of trajectories stopped at the time limit (scored as failures)."),
+    "staleness": ("Staleness", "policy versions", "num2", "down", "infra", "Policy versions between sampling a trajectory and training on it."),
+    "step_time": ("Step time", "s", "duration", "down", "throughput", "Wall-clock of the whole step."),
+    "gen_time": ("Rollout time", "s", "duration", "down", "throughput", "Wall-clock of rollout generation."),
+    "train_time": ("Trainer time", "s", "duration", "down", "throughput", "Wall-clock of the optimizer update."),
+    "tokens_trained": ("Tokens trained", "tokens", "compact", "none", "throughput", "Tokens trained on this step."),
+    "throughput": ("Throughput", "tokens/s", "compact", "up", "throughput", "Tokens processed per second."),
+    "active_sandboxes": ("Sandboxes in flight", "", "int", "none", "infra", "Sandbox environments running."),
+    "chosen_reward": ("Chosen reward", "", "num3", "up", "learning", "Implicit reward of the preferred responses."),
+    "rejected_reward": ("Rejected reward", "", "num3", "down", "learning", "Implicit reward of the rejected responses."),
+    "reward_margin": ("Reward margin", "", "num3", "up", "learning", "Chosen minus rejected implicit reward."),
+    "pref_accuracy": ("Preference accuracy", "", "pct", "up", "learning", "Share of pairs where the chosen response gets the higher implicit reward."),
+    "distill_kl": ("KL to teacher", "", "num3", "down", "learning", "Reverse KL between the student and the teacher on the student's own samples."),
+}
+
+FRAMEWORK_TAGS = {
+    "verl": {
+        "reward": "critic/rewards/mean", "pass_rate": "critic/score/mean", "entropy": "actor/entropy_loss",
+        "grad_norm": "actor/grad_norm", "pg_loss": "actor/pg_loss", "clip_frac": "actor/pg_clipfrac",
+        "kl_ref": "actor/kl_loss", "lr": "actor/lr", "train_infer_kl": "rollout/train_infer_kl",
+        "response_len": "response_length/mean", "truncation_rate": "response_length/clip_ratio",
+        "turns": "agent/turns/mean", "all_fail_share": "batch/solve_none", "all_pass_share": "batch/solve_all",
+        "infra_error_rate": "agent/infra_error_rate", "timeout_rate": "agent/timeout_rate",
+        "step_time": "timing_s/step", "gen_time": "timing_s/gen", "train_time": "timing_s/update_actor",
+        "tokens_trained": "perf/total_num_tokens", "throughput": "perf/throughput",
+    },
+    "nemo_rl": {
+        "reward": "train/reward", "pass_rate": "train/accuracy", "loss": "train/loss", "entropy": "train/entropy",
+        "grad_norm": "train/grad_norm", "clip_frac": "train/probs_ratio_clamped_frac", "lr": "train/lr",
+        "kl_ref": "train/kl_penalty", "train_infer_kl": "train/gen_kl_error",
+        "response_len": "train/mean_gen_tokens_per_sample", "truncation_rate": "train/truncated_frac",
+        "turns": "train/mean_turns", "all_fail_share": "train/zero_reward_group_frac",
+        "all_pass_share": "train/full_reward_group_frac", "infra_error_rate": "train/env_error_frac",
+        "step_time": "timing/train/total_step_time", "gen_time": "timing/train/generation",
+        "train_time": "timing/train/policy_training", "tokens_trained": "train/num_tokens",
+        "throughput": "performance/tokens_per_sec",
+    },
+    "prime_rl": {
+        "reward": "reward/mean", "pass_rate": "metrics/correct", "entropy": "entropy/mean",
+        "grad_norm": "optim/grad_norm", "clip_frac": "loss/is_masked", "lr": "optim/lr",
+        "train_infer_kl": "mismatch_kl/mean", "response_len": "seq_len/mean",
+        "truncation_rate": "is_truncated/mean", "turns": "num_turns/mean",
+        "all_fail_share": "batch/solve_none", "all_pass_share": "batch/solve_all",
+        "infra_error_rate": "error/mean", "staleness": "batch/off_policy_level/mean",
+        "step_time": "time/step", "gen_time": "time/generate_completions", "train_time": "time/train",
+        "throughput": "perf/throughput",
+    },
+    "open_instruct": {
+        "reward": "objective/scores", "pass_rate": "objective/verifiable_correct_rate",
+        "entropy": "policy/entropy_avg", "grad_norm": "optim/grad_norm", "pg_loss": "loss/policy_avg",
+        "clip_frac": "policy/clipfrac_avg", "kl_ref": "objective/kl_avg", "lr": "lr",
+        "train_infer_kl": "debug/vllm_vs_local_logprob_diff", "response_len": "val/sequence_lengths",
+        "truncation_rate": "val/stop_rate_inverse", "all_fail_share": "val/all_zero_reward_groups",
+        "all_pass_share": "val/all_one_reward_groups", "staleness": "val/inflight_policy_lag",
+        "step_time": "time/total", "gen_time": "time/generation", "train_time": "time/training",
+        "tokens_trained": "val/num_total_tokens", "throughput": "val/tokens_per_second",
+    },
+    "skyrl": {
+        "reward": "reward/avg_raw_reward", "pass_rate": "reward/avg_pass_at_8",
+        "entropy": "policy/policy_entropy", "grad_norm": "policy/raw_grad_norm",
+        "pg_loss": "policy/policy_loss", "clip_frac": "policy/ppo_clip_ratio",
+        "response_len": "generate/avg_num_tokens", "turns": "generate/avg_turns",
+        "all_fail_share": "reward/frac_all_zero", "all_pass_share": "reward/frac_all_one",
+        "infra_error_rate": "env/error_rate", "staleness": "async/staleness_mean",
+        "step_time": "timing/step", "gen_time": "timing/generate", "train_time": "timing/policy_train",
+    },
+    "trl_sft": {
+        "loss": "train/loss", "val_loss": "eval/loss", "grad_norm": "train/grad_norm", "lr": "train/learning_rate",
+        "throughput": "train/tokens_per_second", "tokens_trained": "train/num_tokens",
+    },
+    "trl_dpo": {
+        "loss": "train/loss", "chosen_reward": "train/rewards/chosen", "rejected_reward": "train/rewards/rejected",
+        "reward_margin": "train/rewards/margins", "pref_accuracy": "train/rewards/accuracies",
+        "grad_norm": "train/grad_norm", "lr": "train/learning_rate", "val_loss": "eval/loss",
+    },
+    # TRL GRPOTrainer's own names as W&B/trackio show them; pass_rate and train/groups/* are added by
+    # posttrain.integrations.trl from the completions TRL logs (train/loss is left to the SFT/DPO meaning).
+    "trl_grpo": {
+        "reward": "train/reward", "pass_rate": "train/pass_rate", "entropy": "train/entropy", "kl_ref": "train/kl",
+        "clip_frac": "train/clip_ratio/region_mean", "grad_norm": "train/grad_norm", "lr": "train/learning_rate",
+        "response_len": "train/completions/mean_length", "truncation_rate": "train/completions/clipped_ratio",
+        "all_fail_share": "train/groups/all_fail", "all_pass_share": "train/groups/all_pass", "mixed_share": "train/groups/mixed",
+        "step_time": "train/step_time", "tokens_trained": "train/num_tokens",
+    },
+    "megatron_sft": {
+        "loss": "lm loss", "val_loss": "validation lm loss", "grad_norm": "grad-norm", "lr": "learning-rate",
+        "throughput": "throughput/tokens_per_sec", "tokens_trained": "consumed-tokens",
+    },
+}
+
+
+def metric_defs(project_id, framework, pinned=(), overrides=None):
+    """metric_defs rows for every canonical signal a framework logs."""
+    out = []
+    for signal, tag in FRAMEWORK_TAGS[framework].items():
+        label, unit, fmt, better, grp, desc = SIGNALS[signal]
+        out.append({"project_id": project_id, "tag": tag, "label": label, "description": desc,
+                    "unit": unit, "format": fmt, "grp": grp, "better": better,
+                    "pinned": 1 if signal in pinned else 0, "signal": signal})
+    for row in (overrides or []):
+        out = [r for r in out if r["tag"] != row["tag"]] + [dict({"project_id": project_id}, **row)]
+    return out
diff --git a/viewer/build/sim.py b/viewer/build/sim.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5db9144594f84e6460e473dcdb4c455a883f44e
--- /dev/null
+++ b/viewer/build/sim.py
@@ -0,0 +1,294 @@
+"""Simulation primitives for the demo source.
+
+Everything here produces records that follow PROTOCOL.md. Rollouts are simulated one attempt at
+a time and every per-step number (pass rate, group signal, infra errors, truncations) is
+aggregated from those attempts, so the tables and the charts always agree.
+"""
+import hashlib
+import math
+import random
+from dataclasses import dataclass, field
+
+from .. import db
+
+DAY = 86400.0
+
+
+def stable_seed(*parts):
+    return int(hashlib.sha1("|".join(map(str, parts)).encode()).hexdigest()[:12], 16)
+
+
+def rid(prefix, *parts):
+    return f"{prefix}_{hashlib.sha1('|'.join(map(str, parts)).encode()).hexdigest()[:12]}"
+
+
+def rng(*parts):
+    return random.Random(stable_seed(*parts))
+
+
+def sigmoid(x):
+    if x < -40:
+        return 0.0
+    if x > 40:
+        return 1.0
+    return 1.0 / (1.0 + math.exp(-x))
+
+
+def solve_skill(difficulties, target, lo=-12.0, hi=12.0):
+    """Skill s such that the mean of sigmoid(s - d) over the tasks equals target."""
+    target = min(max(target, 1e-4), 1 - 1e-4)
+    for _ in range(60):
+        mid = (lo + hi) / 2
+        mean = sum(sigmoid(mid - d) for d in difficulties) / len(difficulties)
+        if mean < target:
+            lo = mid
+        else:
+            hi = mid
+    return (lo + hi) / 2
+
+
+def ema(values, alpha):
+    out, prev = [], None
+    for v in values:
+        prev = v if prev is None else alpha * prev + (1 - alpha) * v
+        out.append(prev)
+    return out
+
+
+def curve(n, start, end, shape=3.0, noise=0.0, seed=0, floor=None, ceil=None):
+    """A saturating curve from start to end over n points with optional noise."""
+    r = random.Random(seed)
+    out = []
+    for i in range(n):
+        x = i / max(1, n - 1)
+        v = start + (end - start) * (1 - math.exp(-shape * x)) / (1 - math.exp(-shape))
+        if noise:
+            v += r.gauss(0, noise)
+        if floor is not None:
+            v = max(floor, v)
+        if ceil is not None:
+            v = min(ceil, v)
+        out.append(v)
+    return out
+
+
+def lognormal(r, median, sigma):
+    return median * math.exp(r.gauss(0, sigma))
+
+
+@dataclass
+class Task:
+    id: str
+    name: str
+    instruction: str
+    difficulty: float
+    tags: list = field(default_factory=list)
+    status: str = "ok"
+    status_reason: str = ""
+    oracle: float = 1.0
+    noop: float = 0.0
+    reruns: int = 8
+    agree: float = 1.0
+    meta: dict = field(default_factory=dict)
+
+
+@dataclass
+class Env:
+    id: str
+    project_id: str
+    name: str
+    domain: str
+    harness: str
+    reward_kind: str
+    tasks: list
+    infra_rate: float = 0.01
+    timeout_rate: float = 0.0
+    turns: tuple = (1, 1)            # (median, max) agent turns
+    tokens_out: float = 1500.0       # median generated tokens per attempt
+    tokens_in: float = 800.0         # median prompt tokens on the first turn
+    seconds: float = 30.0            # median wall-clock per attempt
+    max_tokens: int = 32768
+    partial_steps: int = 0           # >0: reward is passed_tests / partial_steps
+    judge: bool = False              # scalar reward from a judge / reward model
+    tools: list = field(default_factory=list)
+
+
+class World:
+    """Collects records and writes them to a fresh SQLite file."""
+
+    def __init__(self, path, now):
+        self.conn = db.create(path)
+        self.now = now
+        self.counts = {}
+
+    def add(self, table, record):
+        db.insert(self.conn, table, record)
+        self.counts[table] = self.counts.get(table, 0) + 1
+
+    def add_many(self, table, records):
+        records = list(records)
+        db.insert_many(self.conn, table, records)
+        self.counts[table] = self.counts.get(table, 0) + len(records)
+
+    def meta(self, **kv):
+        for k, v in kv.items():
+            self.add("meta", {"key": k, "value": str(v)})
+
+    def close(self):
+        self.conn.commit()
+        self.conn.execute("VACUUM")
+        self.conn.close()
+
+
+# ---------------------------------------------------------------- tasks and environments
+
+def make_tasks(env_key, n, bank, difficulty=(0.0, 2.0), statuses=None, seed_extra=""):
+    """n tasks named from a bank of (name, instruction) templates.
+
+    difficulty is (mean, sd) in logit units; statuses maps a status to the share of tasks
+    that get it, e.g. {"flaky": 0.03, "too_easy": 0.1}.
+    """
+    r = rng("tasks", env_key, seed_extra)
+    tasks = []
+    for i in range(n):
+        name, instruction = bank(r, i)
+        d = r.gauss(*difficulty)
+        tasks.append(Task(id=rid("task", env_key, i, name), name=name, instruction=instruction,
+                          difficulty=d))
+    statuses = statuses or {}
+    order = list(range(n))
+    r.shuffle(order)
+    cursor = 0
+    reasons = {
+        "flaky": "Verifier disagreed with itself across 8 oracle reruns.",
+        "invalid": "Oracle solution scores below 1.",
+        "leaky": "Expected output is readable from inside the sandbox.",
+        "hackable": "A probe agent got full reward without solving the task.",
+        "excluded": "Overlaps a held-out benchmark (13-gram match).",
+    }
+    for status, share in statuses.items():
+        k = int(round(share * n))
+        for j in order[cursor:cursor + k]:
+            t = tasks[j]
+            t.status = status
+            t.status_reason = reasons.get(status, "")
+            if status == "flaky":
+                t.agree = round(r.uniform(0.5, 0.875), 3)
+            elif status == "invalid":
+                t.oracle = round(r.choice([0.0, 0.0, 0.5, 0.75]), 2)
+            elif status == "leaky":
+                t.noop = 0.0
+            elif status == "hackable":
+                t.noop = 0.0
+        cursor += k
+    return tasks
+
+
+def pass_prob(task, skill):
+    return sigmoid(skill - task.difficulty)
+
+
+def task_rows(env, base_skill, latest_skill, attempts=0):
+    for t in env.tasks:
+        yield {
+            "id": t.id, "env_id": env.id, "name": t.name, "instruction": t.instruction,
+            "difficulty": round(t.difficulty, 3), "tags": t.tags, "status": t.status,
+            "status_reason": t.status_reason, "oracle_score": t.oracle, "noop_score": t.noop,
+            "reruns": t.reruns, "rerun_agree": t.agree,
+            "base_pass": round(pass_prob(t, base_skill), 3),
+            "latest_pass": round(pass_prob(t, latest_skill), 3) if latest_skill is not None else None,
+            "attempts": attempts,
+        }
+
+
+# ---------------------------------------------------------------- rollouts
+
+OUTCOME_STOP = {
+    "passed": "submitted", "failed": "submitted", "partial": "submitted",
+    "timeout": "agent_timeout", "truncated": "max_tokens", "infra_error": "sandbox_error",
+    "max_turns": "max_turns",
+}
+
+
+def attempt(r, env, task, skill, max_tokens=None):
+    """One simulated attempt: returns the rollout fields that depend on the policy."""
+    max_tokens = max_tokens or env.max_tokens
+    if r.random() < env.infra_rate:
+        outcome, reward = "infra_error", None
+    else:
+        p = pass_prob(task, skill)
+        if env.judge:
+            reward = min(1.0, max(0.0, r.betavariate(1 + 6 * p, 1 + 6 * (1 - p))))
+            outcome = "passed" if reward >= 0.5 else "failed"
+        elif env.partial_steps:
+            k = sum(1 for _ in range(env.partial_steps) if r.random() < min(0.98, p ** 0.6))
+            reward = k / env.partial_steps
+            outcome = "passed" if k == env.partial_steps else ("partial" if k else "failed")
+        else:
+            ok = r.random() < p
+            reward = 1.0 if ok else 0.0
+            outcome = "passed" if ok else "failed"
+        if outcome != "passed" and r.random() < env.timeout_rate:
+            outcome, reward = "timeout", 0.0
+    med_turns, max_turns = env.turns
+    if max_turns > 1:
+        turns = int(min(max_turns, max(1, round(lognormal(r, med_turns, 0.55)))))
+        if outcome in ("failed", "timeout") and r.random() < 0.25:
+            turns = max_turns
+            if outcome == "failed":
+                outcome = "max_turns"
+    else:
+        turns = 1
+    out = int(lognormal(r, env.tokens_out * (1.25 if outcome in ("failed", "max_turns") else 1.0), 0.6))
+    if out > max_tokens and outcome not in ("infra_error",):
+        out = max_tokens
+        outcome, reward = "truncated", 0.0
+    first_in = int(lognormal(r, env.tokens_in, 0.35))
+    per_turn_obs = int(lognormal(r, 900, 0.7)) if turns > 1 else 0
+    tokens_in = first_in * turns + per_turn_obs * turns * (turns - 1) // 2 + out * (turns - 1) // 2
+    cached = int(tokens_in * (0.82 + 0.12 * r.random())) if turns > 1 else int(first_in * 0.5)
+    tool_calls = 0 if max_turns <= 1 else max(0, turns - 1 + (1 if r.random() < 0.3 else 0))
+    secs = lognormal(r, env.seconds * (turns / max(1, med_turns)) ** 0.7, 0.4)
+    if outcome == "timeout":
+        secs = max(secs, env.seconds * 6)
+    if outcome == "infra_error":
+        secs = r.uniform(3, 60)
+        turns = r.randint(0, max(0, min(3, turns)))
+        tool_calls = max(0, turns - 1)
+    gen = secs * r.uniform(0.45, 0.7)
+    env_t = secs - gen
+    timing = {"setup": round(r.uniform(2, 25), 1), "generation": round(gen, 1),
+              "environment": round(env_t, 1), "scoring": round(r.uniform(0.5, 12), 1)}
+    return {
+        "reward": None if reward is None else round(reward, 4), "outcome": outcome,
+        "stop_reason": OUTCOME_STOP.get(outcome, "submitted"), "turns": turns,
+        "tool_calls": tool_calls, "tokens_in": tokens_in, "tokens_out": out,
+        "tokens_cached": cached, "duration_s": round(sum(timing.values()), 1), "timing": timing,
+    }
+
+
+def group_advantages(rewards, normalize=True):
+    vals = [x for x in rewards if x is not None]
+    if not vals:
+        return [None] * len(rewards)
+    mean = sum(vals) / len(vals)
+    sd = (sum((x - mean) ** 2 for x in vals) / len(vals)) ** 0.5
+    out = []
+    for x in rewards:
+        if x is None:
+            out.append(None)
+        elif normalize:
+            out.append(round((x - mean) / (sd + 1e-6), 4) if sd > 0 else 0.0)
+        else:
+            out.append(round(x - mean, 4))
+    return out
+
+
+def weighted_choice(r, items, weights):
+    total = sum(weights)
+    x = r.random() * total
+    for item, w in zip(items, weights):
+        x -= w
+        if x <= 0:
+            return item
+    return items[-1]
diff --git a/viewer/build/training.py b/viewer/build/training.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8c2105c61981f20408add17090c54556cd8d0f6
--- /dev/null
+++ b/viewer/build/training.py
@@ -0,0 +1,479 @@
+"""Simulated training runs and evaluations that follow PROTOCOL.md."""
+import math
+import random
+
+from . import signals as sig
+from .sim import (Env, attempt, curve, group_advantages, lognormal, pass_prob, rid, rng,
+                  sigmoid, solve_skill, stable_seed, weighted_choice)
+
+
+def _interp(a, b, x, shape=3.0):
+    return a + (b - a) * (1 - math.exp(-shape * x)) / (1 - math.exp(-shape))
+
+
+def _tag(framework, signal):
+    return sig.FRAMEWORK_TAGS.get(framework, {}).get(signal)
+
+
+class Series:
+    """Collects metric values by tag for one run."""
+
+    def __init__(self, run_id):
+        self.run_id = run_id
+        self.values = {}
+
+    def put(self, tag, step, value):
+        if tag is None or value is None:
+            return
+        if isinstance(value, float) and (math.isnan(value) or math.isinf(value)):
+            return
+        self.values[(tag, step)] = float(value)
+
+    def rows(self):
+        for (tag, step), value in self.values.items():
+            yield {"run_id": self.run_id, "tag": tag, "step": step, "value": round(value, 6)}
+
+
+def env_metric_defs(project_id, envs, label_prefix="Pass rate"):
+    rows = []
+    for env in envs:
+        rows.append({"project_id": project_id, "tag": f"by_env/{env.name}/pass_rate",
+                     "label": f"{label_prefix} · {env.name}", "description": f"Pass rate of attempts on {env.name} this step.",
+                     "unit": "", "format": "pct", "grp": "by_env", "better": "up", "pinned": 0,
+                     "signal": f"env_pass_rate@{env.id}"})
+        rows.append({"project_id": project_id, "tag": f"by_env/{env.name}/share",
+                     "label": f"Batch share · {env.name}", "description": f"Share of this step's prompts drawn from {env.name}.",
+                     "unit": "", "format": "pct", "grp": "by_env", "better": "none", "pinned": 0,
+                     "signal": f"env_share@{env.id}"})
+        rows.append({"project_id": project_id, "tag": f"by_env/{env.name}/infra_error_rate",
+                     "label": f"Infra errors · {env.name}", "description": f"Share of attempts on {env.name} lost to infrastructure failures.",
+                     "unit": "", "format": "pct", "grp": "by_env", "better": "down", "pinned": 0,
+                     "signal": f"env_infra@{env.id}"})
+    return rows
+
+
+def rl_run(w, *, project_id, key, name, framework, envs, base_model_id, output_model_id=None,
+           steps, group_size=8, prompts_per_step=256, sample_groups=96, store_groups=6,
+           start, step_seconds=3600.0, pass_start=None, pass_end=None, env_targets=None,
+           shape=2.5, noise=0.012, status="completed", steps_done=None, status_reason="",
+           algorithm="GRPO", hyperparams=None, config="", config_format="yaml", gpu=None,
+           gpus=None, cost_rate=None, owner="", tags=(), code_ref="", stage="RL",
+           description="", source="", provenance="simulated", events=(), async_rl=False,
+           normalize_adv=True, dynamic_sampling=False, entropy=(0.45, 0.38), grad_norm=0.12,
+           train_infer_kl=0.0005, kl_ref=None, lr=1e-6, ckpt_every=10, group_name=None,
+           parent_run_id=None, env_pass_offsets=None, incidents=None, model_ids_by_step=None,
+           extra=None, seed=None, write_metrics=True):
+    """Simulate an RL run, write it, and return a summary with per-step facts.
+
+    envs is a list of (Env, weight). Pass rates move from pass_start to pass_end (per env via
+    env_targets={env.id: (start, end)} or env_pass_offsets) along a saturating curve; each step
+    samples `sample_groups` groups of `group_size` attempts to measure the step, and stores the
+    first `store_groups` groups as rollouts.
+    """
+    run_id = rid("run", project_id, key)
+    seed = seed if seed is not None else stable_seed(project_id, key)
+    r = random.Random(seed)
+    steps_done = steps if steps_done is None else steps_done
+    hyperparams = dict(hyperparams or {})
+    hyperparams.setdefault("group_size", group_size)
+    hyperparams.setdefault("prompts_per_step", prompts_per_step)
+    series = Series(run_id)
+    env_list = [e for e, _ in envs]
+    weights = [wt for _, wt in envs]
+    env_targets = dict(env_targets or {})
+    for env in env_list:
+        if env.id not in env_targets:
+            off = (env_pass_offsets or {}).get(env.id, 0.0)
+            env_targets[env.id] = (min(0.97, max(0.02, pass_start + off)), min(0.98, max(0.03, pass_end + off)))
+    pools = {e.id: [t for t in e.tasks if t.status not in ("excluded", "invalid")] for e in env_list}
+    solve_sets = {e.id: [t.difficulty for t in (pools[e.id] if len(pools[e.id]) <= 240 else random.Random(seed).sample(pools[e.id], 240))] for e in env_list}
+    t = start
+    step_rows, rollout_rows, facts = [], [], []
+    skills_last = {}
+    incident_steps = {i["step"]: i for i in (incidents or [])}
+    for step in range(1, steps_done + 1):
+        x = (step - 1) / max(1, steps - 1)
+        dur = step_seconds(step) if callable(step_seconds) else lognormal(r, step_seconds, 0.12)
+        skills = {}
+        for env in env_list:
+            a, b = env_targets[env.id]
+            target = _interp(a, b, x, shape) + r.gauss(0, noise)
+            skills[env.id] = solve_skill(solve_sets[env.id], min(0.99, max(0.01, target)))
+        skills_last = skills
+        stats = {"n": 0, "passed": 0.0, "scored": 0, "infra": 0, "trunc": 0, "timeout": 0,
+                 "all_pass": 0, "all_fail": 0, "mixed": 0, "tok_out": 0, "tok_in": 0, "turns": 0,
+                 "by_env": {e.id: {"groups": 0, "scored": 0, "passed": 0.0, "infra": 0, "n": 0} for e in env_list}}
+        for g in range(sample_groups):
+            env = weighted_choice(r, env_list, weights)
+            pool = pools[env.id]
+            task = pool[r.randrange(len(pool))]
+            atts = [attempt(r, env, task, skills[env.id]) for _ in range(group_size)]
+            rewards = [a_["reward"] for a_ in atts]
+            advs = group_advantages(rewards, normalize_adv)
+            scored = [x_ for x_ in rewards if x_ is not None]
+            be = stats["by_env"][env.id]
+            be["groups"] += 1
+            if scored:
+                if all(x_ >= 1.0 for x_ in scored):
+                    stats["all_pass"] += 1
+                elif all(x_ <= 0.0 for x_ in scored):
+                    stats["all_fail"] += 1
+                else:
+                    stats["mixed"] += 1
+            zero_var = len(set(scored)) <= 1
+            for i, a_ in enumerate(atts):
+                stats["n"] += 1
+                be["n"] += 1
+                if a_["reward"] is None:
+                    stats["infra"] += 1
+                    be["infra"] += 1
+                else:
+                    stats["scored"] += 1
+                    stats["passed"] += a_["reward"]
+                    be["scored"] += 1
+                    be["passed"] += a_["reward"]
+                stats["trunc"] += a_["outcome"] == "truncated"
+                stats["timeout"] += a_["outcome"] == "timeout"
+                stats["tok_out"] += a_["tokens_out"]
+                stats["tok_in"] += a_["tokens_in"]
+                stats["turns"] += a_["turns"]
+                if g < store_groups:
+                    rollout_rows.append({
+                        "id": rid("roll", run_id, step, g, i), "run_id": run_id, "eval_id": None,
+                        "step": step, "phase": "train", "group_id": rid("grp", run_id, step, g),
+                        "sample": i, "task_id": task.id, "env_id": env.id, "harness": env.harness,
+                        "model_id": (model_ids_by_step or {}).get(step, base_model_id),
+                        "reward": a_["reward"], "advantage": advs[i], "scores": None,
+                        "outcome": a_["outcome"], "stop_reason": a_["stop_reason"], "turns": a_["turns"],
+                        "tool_calls": a_["tool_calls"], "tokens_in": a_["tokens_in"],
+                        "tokens_out": a_["tokens_out"], "tokens_cached": a_["tokens_cached"],
+                        "duration_s": a_["duration_s"], "timing": a_["timing"],
+                        "staleness": (r.choice([0, 0, 1, 1, 2]) if async_rl else 0), "flags": None,
+                        "seed": stable_seed(run_id, step, g, i),
+                        "trained": 0 if (a_["reward"] is None or (dynamic_sampling and zero_var)) else 1,
+                    })
+        n_groups = max(1, stats["all_pass"] + stats["all_fail"] + stats["mixed"])
+        pass_rate = stats["passed"] / max(1, stats["scored"])
+        scale = prompts_per_step / sample_groups
+        rollouts_total = prompts_per_step * group_size
+        stored = min(store_groups, sample_groups) * group_size
+        resp_len = stats["tok_out"] / max(1, stats["n"])
+        step_rows.append({
+            "run_id": run_id, "step": step, "phase": "train", "started_at": t, "ended_at": t + dur,
+            "prompts": prompts_per_step, "rollouts": rollouts_total, "rollouts_stored": stored,
+            "reward_mean": round(pass_rate, 4), "pass_rate": round(pass_rate, 4),
+            "tokens": int((stats["tok_out"] + stats["tok_in"]) * scale),
+            "groups_all_pass": int(round(stats["all_pass"] * scale)),
+            "groups_all_fail": int(round(stats["all_fail"] * scale)),
+            "groups_mixed": int(round(stats["mixed"] * scale)),
+            "infra_errors": int(round(stats["infra"] * scale)), "truncated": int(round(stats["trunc"] * scale)),
+        })
+        # canonical signals under the framework's own tags
+        put = lambda s, v: series.put(_tag(framework, s), step, v)
+        put("reward", pass_rate)
+        put("pass_rate", pass_rate)
+        put("all_pass_share", stats["all_pass"] / n_groups)
+        put("all_fail_share", stats["all_fail"] / n_groups)
+        put("mixed_share", stats["mixed"] / n_groups)
+        put("infra_error_rate", stats["infra"] / max(1, stats["n"]))
+        put("timeout_rate", stats["timeout"] / max(1, stats["n"]))
+        put("truncation_rate", stats["trunc"] / max(1, stats["n"]))
+        put("response_len", resp_len)
+        put("context_len", (stats["tok_out"] + stats["tok_in"]) / max(1, stats["n"]))
+        put("turns", stats["turns"] / max(1, stats["n"]))
+        inc = incident_steps.get(step, {})
+        e0, e1 = entropy
+        ent = _interp(e0, e1, x, 2.0) * (1 + r.gauss(0, 0.03)) * inc.get("entropy_mult", 1.0)
+        put("entropy", ent)
+        put("grad_norm", lognormal(r, grad_norm * (1 - 0.3 * x), 0.25) * inc.get("grad_mult", 1.0))
+        put("pg_loss", r.gauss(0.0, 0.012))
+        put("clip_frac", abs(r.gauss(0.004, 0.002)))
+        if kl_ref is not None:
+            put("kl_ref", kl_ref * x * (1 + r.gauss(0, 0.1)))
+        put("lr", lr)
+        put("train_infer_kl", lognormal(r, train_infer_kl, 0.2) * inc.get("kl_mult", 1.0))
+        gen_frac = r.uniform(0.5, 0.62)
+        put("step_time", dur)
+        put("gen_time", dur * gen_frac)
+        put("train_time", dur * (1 - gen_frac) * 0.92)
+        tokens_trained = (stats["tok_out"] + stats["tok_in"]) * scale
+        put("tokens_trained", tokens_trained)
+        put("throughput", tokens_trained / dur)
+        if async_rl:
+            put("staleness", abs(r.gauss(0.9, 0.2)))
+        for env in env_list:
+            be = stats["by_env"][env.id]
+            if be["scored"]:
+                series.put(f"by_env/{env.name}/pass_rate", step, be["passed"] / be["scored"])
+            series.put(f"by_env/{env.name}/share", step, be["groups"] / sample_groups)
+            if be["n"]:
+                series.put(f"by_env/{env.name}/infra_error_rate", step, be["infra"] / be["n"])
+        if extra:
+            for tag, value in extra(step, x, r, stats).items():
+                series.put(tag, step, value)
+        facts.append({"step": step, "t": t, "pass_rate": pass_rate, "skills": dict(skills)})
+        t += dur
+    ended = t if status in ("completed", "failed", "stopped") else None
+    elapsed_h = (t - start) / 3600
+    run = {
+        "id": run_id, "project_id": project_id, "name": name, "kind": "rl", "stage": stage,
+        "algorithm": algorithm, "framework": framework, "status": status, "status_reason": status_reason,
+        "base_model_id": base_model_id, "output_model_id": output_model_id, "started_at": start,
+        "ended_at": ended, "updated_at": t, "steps_planned": steps, "steps_done": steps_done,
+        "primary_metric": _tag(framework, "pass_rate") or _tag(framework, "reward"), "gpu": gpu,
+        "gpus": gpus, "cost_usd": round(cost_rate * elapsed_h, 2) if cost_rate else None, "cost_rate": cost_rate,
+        "owner": owner, "tags": list(tags), "code_ref": code_ref, "config": config,
+        "config_format": config_format, "hyperparams": hyperparams, "parent_run_id": parent_run_id,
+        "group_name": group_name, "description": description, "source": source, "provenance": provenance,
+    }
+    w.add("runs", run)
+    for env, wt in envs:
+        w.add("run_inputs", {"run_id": run_id, "kind": "environment", "ref_id": env.id, "weight": wt})
+    w.add_many("run_steps", step_rows)
+    w.add_many("rollouts", rollout_rows)
+    if write_metrics:
+        w.add_many("metrics", series.rows())
+    ev = [{"run_id": run_id, "t": start, "step": 0, "kind": "start", "severity": "info",
+           "title": "Run started", "body": f"{algorithm} on {len(env_list)} environment(s), {prompts_per_step} prompts × {group_size} attempts per step."}]
+    for f in facts:
+        if ckpt_every and f["step"] % ckpt_every == 0:
+            ckpt_id = rid("ckpt", run_id, f["step"])
+            w.add("checkpoints", {"id": ckpt_id, "run_id": run_id, "step": f["step"],
+                                  "model_id": None, "path": f"s3://ckpt/{key}/step_{f['step']:05d}",
+                                  "size_gb": None, "created_at": f["t"], "kept": 1})
+            ev.append({"run_id": run_id, "t": f["t"], "step": f["step"], "kind": "checkpoint",
+                       "severity": "info", "title": f"Checkpoint step {f['step']}", "body": ""})
+    for e in events:
+        e = dict(e)
+        e.setdefault("severity", "info")
+        e.setdefault("body", "")
+        if "t" not in e:
+            match = [f for f in facts if f["step"] == e["step"]]
+            e["t"] = match[0]["t"] if match else start
+        ev.append(dict(e, run_id=run_id))
+    if status in ("completed", "failed", "stopped"):
+        ev.append({"run_id": run_id, "t": t, "step": steps_done, "kind": "end",
+                   "severity": "error" if status == "failed" else "info",
+                   "title": {"completed": "Run completed", "failed": "Run failed", "stopped": "Run stopped"}[status],
+                   "body": status_reason})
+    w.add_many("run_events", ev)
+    return {"run_id": run_id, "facts": facts, "end": t, "skills": skills_last, "series": series,
+            "envs": env_list}
+
+
+def sft_run(w, *, project_id, key, name, framework="trl_sft", datasets, base_model_id,
+            output_model_id=None, steps, start, step_seconds=40.0, loss=(1.1, 0.55), val_every=None,
+            lr=1e-5, warmup=0.03, schedule="cosine", global_batch=128, seq_len=32768, epochs=None,
+            status="completed", steps_done=None, status_reason="", gpu=None, gpus=None,
+            cost_rate=None, owner="", tags=(), config="", config_format="yaml", hyperparams=None,
+            stage="SFT", description="", source="", provenance="simulated", events=(),
+            log_every=None, kind="sft", algorithm="SFT", group_name=None, ckpt_every=None,
+            tokens_per_step=None, parent_run_id=None):
+    run_id = rid("run", project_id, key)
+    r = rng(project_id, key)
+    steps_done = steps if steps_done is None else steps_done
+    series = Series(run_id)
+    log_every = log_every or max(1, steps // 200)
+    val_every = val_every or max(1, steps // 20)
+    t = start
+    tokens_per_step = tokens_per_step or global_batch * seq_len * 0.55
+    step_rows = []
+    for step in range(1, steps_done + 1):
+        dur = lognormal(r, step_seconds, 0.05)
+        t += dur
+        if step % log_every and step != steps_done:
+            continue
+        x = step / steps
+        l0, l1 = loss
+        value = l1 + (l0 - l1) * math.exp(-5.0 * x) + r.gauss(0, 0.012 * l0)
+        put = lambda s, v: series.put(_tag(framework, s), step, v)
+        put("loss", value)
+        if step <= warmup * steps:
+            cur = lr * step / max(1, warmup * steps)
+        elif schedule == "cosine":
+            p = (step - warmup * steps) / max(1, steps - warmup * steps)
+            cur = lr * 0.5 * (1 + math.cos(math.pi * p))
+        elif schedule == "linear":
+            cur = lr * (1 - (step - warmup * steps) / max(1, steps - warmup * steps))
+        else:
+            cur = lr
+        put("lr", cur)
+        put("grad_norm", lognormal(r, 0.35 * (1 - 0.4 * x), 0.2))
+        put("throughput", tokens_per_step / dur)
+        put("tokens_trained", tokens_per_step * step)
+        if step % val_every == 0 or step == steps_done:
+            put("val_loss", value * 1.04 + 0.02 + r.gauss(0, 0.005))
+    for step in range(1, steps_done + 1, max(1, steps_done // 40)):
+        step_rows.append({"run_id": run_id, "step": step, "phase": "train", "started_at": start + (t - start) * (step - 1) / steps_done,
+                          "ended_at": start + (t - start) * step / steps_done, "prompts": global_batch,
+                          "rollouts": 0, "rollouts_stored": 0, "reward_mean": None, "pass_rate": None,
+                          "tokens": int(tokens_per_step), "groups_all_pass": None, "groups_all_fail": None,
+                          "groups_mixed": None, "infra_errors": None, "truncated": None})
+    hp = {"lr": lr, "schedule": schedule, "warmup_ratio": warmup, "global_batch": global_batch,
+          "max_seq_len": seq_len, "steps": steps}
+    if epochs:
+        hp["epochs"] = epochs
+    hp.update(hyperparams or {})
+    w.add("runs", {
+        "id": run_id, "project_id": project_id, "name": name, "kind": kind, "stage": stage,
+        "algorithm": algorithm, "framework": framework, "status": status, "status_reason": status_reason,
+        "base_model_id": base_model_id, "output_model_id": output_model_id, "started_at": start,
+        "ended_at": t if status in ("completed", "failed", "stopped") else None, "updated_at": t,
+        "steps_planned": steps, "steps_done": steps_done,
+        "primary_metric": _tag(framework, "loss") or _tag(framework, "reward_margin"), "gpu": gpu, "gpus": gpus,
+        "cost_usd": round(cost_rate * (t - start) / 3600, 2) if cost_rate else None, "cost_rate": cost_rate, "owner": owner,
+        "tags": list(tags), "code_ref": "", "config": config, "config_format": config_format,
+        "hyperparams": hp, "parent_run_id": parent_run_id, "group_name": group_name, "description": description,
+        "source": source, "provenance": provenance})
+    for ds_id, wt in datasets:
+        w.add("run_inputs", {"run_id": run_id, "kind": "dataset", "ref_id": ds_id, "weight": wt})
+    w.add_many("run_steps", step_rows)
+    w.add_many("metrics", series.rows())
+    ev = [{"run_id": run_id, "t": start, "step": 0, "kind": "start", "severity": "info", "title": "Run started",
+           "body": f"{algorithm} on {len(datasets)} dataset(s), batch {global_batch}, sequence length {seq_len:,}."}]
+    if ckpt_every:
+        for s in range(ckpt_every, steps_done + 1, ckpt_every):
+            tt = start + (t - start) * s / steps_done
+            w.add("checkpoints", {"id": rid("ckpt", run_id, s), "run_id": run_id, "step": s, "model_id": None,
+                                  "path": f"s3://ckpt/{key}/step_{s:06d}", "size_gb": None, "created_at": tt, "kept": 1})
+            ev.append({"run_id": run_id, "t": tt, "step": s, "kind": "checkpoint", "severity": "info",
+                       "title": f"Checkpoint step {s}", "body": ""})
+    for e in events:
+        e = dict(e)
+        e.setdefault("severity", "info")
+        e.setdefault("body", "")
+        e.setdefault("t", start + (t - start) * e.get("step", 0) / max(1, steps_done))
+        ev.append(dict(e, run_id=run_id))
+    if status in ("completed", "failed", "stopped"):
+        ev.append({"run_id": run_id, "t": t, "step": steps_done, "kind": "end",
+                   "severity": "error" if status == "failed" else "info",
+                   "title": {"completed": "Run completed", "failed": "Run failed", "stopped": "Run stopped"}[status],
+                   "body": status_reason})
+    w.add_many("run_events", ev)
+    return {"run_id": run_id, "end": t, "series": series}
+
+
+def dpo_run(w, **kw):
+    """Preference optimization: loss from ln 2 down, margins and accuracy up."""
+    framework = kw.pop("framework", "trl_dpo")
+    acc_end = kw.pop("accuracy", 0.74)
+    margin_end = kw.pop("margin", 2.1)
+    kw.setdefault("loss", (0.693, 0.48))
+    kw.setdefault("stage", "DPO")
+    out = sft_run(w, framework=framework, kind="dpo", algorithm=kw.pop("algorithm", "DPO"), **kw)
+    r = rng("dpo", out["run_id"])
+    series = Series(out["run_id"])
+    steps = kw.get("steps_done") or kw["steps"]
+    for step in range(1, steps + 1, max(1, steps // 200)):
+        x = step / kw["steps"]
+        chosen = 0.2 + 1.1 * (1 - math.exp(-3 * x)) + r.gauss(0, 0.05)
+        margin = margin_end * (1 - math.exp(-3 * x)) + r.gauss(0, 0.06)
+        series.put(_tag(framework, "chosen_reward"), step, chosen)
+        series.put(_tag(framework, "rejected_reward"), step, chosen - margin)
+        series.put(_tag(framework, "reward_margin"), step, margin)
+        series.put(_tag(framework, "pref_accuracy"), step, min(0.99, 0.5 + (acc_end - 0.5) * (1 - math.exp(-4 * x)) + r.gauss(0, 0.012)))
+    w.add_many("metrics", series.rows())
+    return out
+
+
+# ---------------------------------------------------------------- evaluations
+
+class Bench:
+    def __init__(self, id, project_id, name, tasks, k, metric, domain_env=None):
+        self.id, self.project_id, self.name, self.tasks, self.k, self.metric = id, project_id, name, tasks, k, metric
+        self.env = domain_env
+
+
+def benchmark(w, *, project_id, key, name, version="", category="", metric="avg@1", harness=None,
+              n_tasks, k=1, description="", source="", bank=None, difficulty=(0.0, 1.8), env=None,
+              store_tasks=True):
+    from .sim import make_tasks
+    bench_id = rid("bench", project_id, key)
+    w.add("benchmarks", {"id": bench_id, "project_id": project_id, "name": name, "version": version,
+                         "category": category, "metric": metric, "harness": harness, "n_tasks": n_tasks,
+                         "k": k, "description": description, "source": source})
+    tasks = make_tasks(bench_id, n_tasks, bank or (lambda r, i: (f"{key}-{i:04d}", "")), difficulty)
+    b = Bench(bench_id, project_id, name, tasks, k, metric, env)
+    b.store_tasks = store_tasks
+    return b
+
+
+def eval_run(w, bench, *, model_id, score, run_id=None, step=None, status="completed", started=None,
+             duration=3600.0, cost_usd=None, command="", config=None, source="", provenance="simulated",
+             store_rollouts=0, infra_rate=None, key=None, raw=False, stderr=None):
+    """One evaluation whose per-task results average exactly to `score` (a 0-1 value).
+
+    raw=True stores the score as given (an Elo, an index) with no per-task results."""
+    key = key or f"{model_id}|{run_id}|{step}"
+    eval_id = rid("eval", bench.id, key)
+    r = rng("eval", eval_id)
+    n, k = len(bench.tasks), bench.k
+    if raw and status == "completed" and score is not None:
+        w.add("evals", {"id": eval_id, "project_id": bench.project_id, "benchmark_id": bench.id,
+                        "model_id": model_id, "run_id": run_id, "step": step, "status": status, "score": score,
+                        "stderr": stderr, "n_tasks": n, "k": k, "n_infra": None, "started_at": started,
+                        "ended_at": (started + duration) if started else None, "cost_usd": cost_usd, "config": config,
+                        "command": command, "source": source, "provenance": provenance})
+        return eval_id
+    if status != "completed" or score is None:
+        w.add("evals", {"id": eval_id, "project_id": bench.project_id, "benchmark_id": bench.id,
+                        "model_id": model_id, "run_id": run_id, "step": step, "status": status, "score": None,
+                        "stderr": None, "n_tasks": n, "k": k, "n_infra": None, "started_at": started,
+                        "ended_at": None, "cost_usd": cost_usd, "config": config, "command": command,
+                        "source": source, "provenance": provenance})
+        return eval_id
+    skill = solve_skill([t.difficulty for t in bench.tasks], score)
+    passes = []
+    for t in bench.tasks:
+        p = pass_prob(t, skill)
+        passes.append(sum(1 for _ in range(k) if r.random() < p))
+    target = int(round(score * n * k))
+    order = sorted(range(n), key=lambda i: abs(pass_prob(bench.tasks[i], skill) - 0.5))
+    guard = 0
+    while sum(passes) != target and guard < 100000:
+        guard += 1
+        i = order[guard % n]
+        if sum(passes) < target and passes[i] < k:
+            passes[i] += 1
+        elif sum(passes) > target and passes[i] > 0:
+            passes[i] -= 1
+    means = [p / k for p in passes]
+    mean = sum(means) / n
+    sd = (sum((m - mean) ** 2 for m in means) / max(1, n - 1)) ** 0.5
+    stderr = sd / math.sqrt(n)
+    infra = sum(1 for _ in range(n * k) if r.random() < infra_rate) if infra_rate else None
+    w.add("evals", {"id": eval_id, "project_id": bench.project_id, "benchmark_id": bench.id,
+                    "model_id": model_id, "run_id": run_id, "step": step, "status": status,
+                    "score": round(mean, 5), "stderr": round(stderr, 5), "n_tasks": n, "k": k, "n_infra": infra,
+                    "started_at": started, "ended_at": (started + duration) if started else None,
+                    "cost_usd": cost_usd, "config": config, "command": command, "source": source,
+                    "provenance": provenance})
+    if getattr(bench, "store_tasks", True):
+        w.add_many("eval_tasks", [{"eval_id": eval_id, "task_id": t.id, "task_name": t.name, "attempts": k,
+                                   "passes": passes[i], "infra": 0, "score": round(passes[i] / k, 4),
+                                   "mean_turns": None, "mean_tokens": None} for i, t in enumerate(bench.tasks)])
+    if store_rollouts and bench.env is not None:
+        env = bench.env
+        rows = []
+        for i, t in enumerate(bench.tasks[:store_rollouts]):
+            flips = [1] * passes[i] + [0] * (k - passes[i])
+            r.shuffle(flips)
+            for j in range(k):
+                a_ = attempt(r, env, t, 12.0 if flips[j] else -12.0)
+                if flips[j]:
+                    a_.update(reward=1.0, outcome="passed", stop_reason="submitted")
+                else:
+                    a_["reward"] = 0.0
+                    if a_["outcome"] not in ("timeout", "truncated", "max_turns"):
+                        a_.update(outcome="failed", stop_reason="submitted")
+                rows.append({"id": rid("roll", eval_id, i, j), "run_id": run_id, "eval_id": eval_id, "step": step,
+                             "phase": "eval", "group_id": rid("grp", eval_id, i), "sample": j, "task_id": t.id,
+                             "env_id": env.id, "harness": env.harness, "model_id": model_id, "reward": a_["reward"],
+                             "advantage": None, "scores": None, "outcome": a_["outcome"],
+                             "stop_reason": a_["stop_reason"], "turns": a_["turns"], "tool_calls": a_["tool_calls"],
+                             "tokens_in": a_["tokens_in"], "tokens_out": a_["tokens_out"],
+                             "tokens_cached": a_["tokens_cached"], "duration_s": a_["duration_s"],
+                             "timing": a_["timing"], "staleness": 0, "flags": None,
+                             "seed": stable_seed(eval_id, i, j), "trained": 0})
+        w.add_many("rollouts", rows)
+    return eval_id
diff --git a/viewer/compare.py b/viewer/compare.py
new file mode 100644
index 0000000000000000000000000000000000000000..99f24f625b9a57a3360a7d95d72c0c10ba461b6c
--- /dev/null
+++ b/viewer/compare.py
@@ -0,0 +1,149 @@
+"""Comparing two evals of one benchmark: the change, its standard error, and whether it is beyond noise.
+
+PRD 4 ("beyond noise"): a change counts as improved or regressed when |Δ| > 2 × SE of the difference. The SE is
+paired over tasks when both evals have per-task results (the SE of the mean per-task difference over the tasks both
+scored); otherwise it is sqrt(SE_a² + SE_b²). Anything smaller is "within noise". Infrastructure errors are never
+scored as zero: a task whose attempts all hit infrastructure errors is left out of the pairing.
+
+Pure functions over eval rows (PROTOCOL.md `evals`) and their `eval_tasks` rows; no database access here.
+"""
+import json
+import math
+
+NOISE_SE = 2.0          # beyond noise: |delta| > 2 SE
+INFRA_LIMIT = 0.10      # an eval with more than 10% infrastructure errors is not trusted (Marin's threshold)
+SOLVED = 0.5            # a task counts as solved when its score (mean over attempts) is at least 0.5
+
+
+def task_scores(tasks):
+    """{task_name: score} for tasks with a score; tasks whose every attempt was an infrastructure error are left out."""
+    out = {}
+    for t in tasks or []:
+        name = t.get("task_name")
+        if name is None:
+            continue
+        attempts, infra = t.get("attempts") or 0, t.get("infra") or 0
+        score = t.get("score")
+        if score is None:
+            scored = attempts - infra
+            if scored <= 0 or t.get("passes") is None:
+                continue
+            score = t["passes"] / scored
+        elif attempts and infra >= attempts:
+            continue
+        out[name] = float(score)
+    return out
+
+
+def infra_share(ev, tasks=None):
+    """Infrastructure errors as a share of attempts (per-task rows when present), else n_infra / (n_tasks + n_infra)."""
+    if tasks:
+        attempts = sum(max(t.get("attempts") or 0, t.get("infra") or 0) for t in tasks)
+        infra = sum(t.get("infra") or 0 for t in tasks)
+        if attempts:
+            return infra / attempts
+    n_infra = (ev or {}).get("n_infra") or 0
+    n = (ev or {}).get("n_tasks") or 0
+    return n_infra / (n + n_infra) if (n + n_infra) else 0.0
+
+
+def verdict(delta, se):
+    if delta is None:
+        return "missing"
+    if se is None:
+        return "unknown"
+    if delta > NOISE_SE * se:
+        return "improved"
+    if delta < -NOISE_SE * se:
+        return "regressed"
+    return "within_noise"
+
+
+def compare(a, b, tasks_a=None, tasks_b=None):
+    """B against A for one benchmark. a, b: eval rows (score, stderr) or None; tasks_*: their eval_tasks rows.
+
+    Returns delta (b - a), se_diff, paired (bool), n_shared, verdict (improved | regressed | within_noise |
+    unknown when no standard error is known | missing when either side has no eval), and, when both have per-task
+    results, gained / lost / still_solved / still_unsolved counts and the gained and lost task names."""
+    out = {"delta": None, "se_diff": None, "paired": False, "n_shared": 0, "verdict": "missing"}
+    if not a or not b or a.get("score") is None or b.get("score") is None:
+        return out
+    sa, sb = task_scores(tasks_a), task_scores(tasks_b)
+    shared = sorted(set(sa) & set(sb))
+    if len(shared) >= 2:
+        d = [sb[t] - sa[t] for t in shared]
+        n = len(d)
+        mean = sum(d) / n
+        var = sum((x - mean) ** 2 for x in d) / (n - 1)
+        out.update(delta=mean, se_diff=math.sqrt(var / n), paired=True, n_shared=n)
+    else:
+        se_a, se_b = a.get("stderr"), b.get("stderr")
+        out["delta"] = b["score"] - a["score"]
+        out["se_diff"] = math.sqrt(se_a ** 2 + se_b ** 2) if se_a is not None and se_b is not None else None
+        out["n_shared"] = len(shared)
+    out["verdict"] = verdict(out["delta"], out["se_diff"])
+    if shared:
+        gained = [t for t in shared if sa[t] < SOLVED <= sb[t]]
+        lost = [t for t in shared if sb[t] < SOLVED <= sa[t]]
+        still = sum(1 for t in shared if sa[t] >= SOLVED and sb[t] >= SOLVED)
+        out.update(gained=len(gained), lost=len(lost), still_solved=still,
+                   still_unsolved=len(shared) - len(gained) - len(lost) - still,
+                   gained_tasks=gained[:2000], lost_tasks=lost[:2000],
+                   tasks_truncated=len(gained) > 2000 or len(lost) > 2000)
+    return out
+
+
+def aggregate(rows):
+    """One verdict over several benchmarks: the mean change and the SE of that mean (independent benchmarks)."""
+    rows = [r for r in rows if r.get("delta") is not None and r.get("se_diff") is not None]
+    if not rows:
+        return {"delta": None, "se_diff": None, "verdict": "missing", "n": 0}
+    n = len(rows)
+    delta = sum(r["delta"] for r in rows) / n
+    se = math.sqrt(sum(r["se_diff"] ** 2 for r in rows)) / n
+    return {"delta": delta, "se_diff": se, "verdict": verdict(delta, se), "n": n}
+
+
+# ------------------------------------------------------------------ formatting (CLI tables and one-line summaries)
+
+def is_fraction(*scores):
+    vals = [s for s in scores if s is not None]
+    return bool(vals) and all(-1e-9 <= s <= 1 + 1e-9 for s in vals)
+
+
+def fmt_score(score, se=None, pct=True):
+    if score is None:
+        return "—"
+    if pct:
+        s = f"{score * 100:.1f}"
+        return f"{s} ± {se * 100:.1f}" if se is not None else s
+    s = f"{score:.3g}"
+    return f"{s} ± {se:.2g}" if se is not None else s
+
+
+def fmt_change(delta, se=None, pct=True):
+    if delta is None:
+        return "—"
+    sign = "+" if delta >= 0 else "−"
+    if pct:
+        body = f"{sign}{abs(delta) * 100:.1f}" + (f" ± {se * 100:.1f}" if se is not None else "") + " pp"
+    else:
+        body = f"{sign}{abs(delta):.3g}" + (f" ± {se:.2g}" if se is not None else "")
+    return body
+
+
+VERDICT_WORDS = {"improved": "improved", "regressed": "regressed", "within_noise": "within noise",
+                 "unknown": "no standard error", "missing": "not evaluated"}
+
+
+def eval_config(ev):
+    """An eval's recorded config as a dict (the column is JSON text)."""
+    c = (ev or {}).get("config")
+    if isinstance(c, dict):
+        return c
+    if isinstance(c, str) and c.strip().startswith("{"):
+        try:
+            return json.loads(c)
+        except ValueError:
+            return {}
+    return {}
diff --git a/viewer/db.py b/viewer/db.py
new file mode 100644
index 0000000000000000000000000000000000000000..c806512f0344670f4885d5a5b41bba42443dab03
--- /dev/null
+++ b/viewer/db.py
@@ -0,0 +1,227 @@
+"""SQLite schema and read helpers for the viewer (see PROTOCOL.md)."""
+import json
+import os
+import sqlite3
+import threading
+from pathlib import Path
+
+DATA = Path(os.environ.get("VIEWER_DATA", Path(__file__).parent / "data"))
+SOURCES = {"workspace": "workspace.sqlite", "demo": "demo.sqlite", "live": "live.sqlite"}
+
+
+def unpack():
+    """Decompress sources shipped gzipped (e.g. live.sqlite.gz from the repo) next to themselves, when newer."""
+    import gzip
+    import shutil
+    for gz in DATA.glob("*.sqlite.gz"):
+        target = DATA / gz.name[:-3]
+        if target.exists() and target.stat().st_size > 0 and target.stat().st_mtime >= gz.stat().st_mtime:
+            continue   # an empty file (e.g. left by a connect that created it) is replaced
+        try:
+            tmp = target.with_suffix(".part")
+            with gzip.open(gz, "rb") as src, open(tmp, "wb") as dst:
+                shutil.copyfileobj(src, dst, 1 << 20)
+            tmp.replace(target)
+        except OSError:
+            pass  # read-only data folder (Vercel unpacks into /tmp itself)
+WRITABLE = {"workspace"}
+
+SCHEMA = """
+CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT);
+
+CREATE TABLE orgs (id TEXT PRIMARY KEY, slug TEXT UNIQUE, name TEXT, about TEXT, url TEXT);
+CREATE TABLE projects (
+  id TEXT PRIMARY KEY, org_id TEXT, slug TEXT, name TEXT, summary TEXT, created_at REAL,
+  sources TEXT, data_note TEXT, pins TEXT, UNIQUE(org_id, slug));
+
+CREATE TABLE models (
+  id TEXT PRIMARY KEY, project_id TEXT, name TEXT, kind TEXT, hf_repo TEXT, arch TEXT,
+  params_total REAL, params_active REAL, context_len INTEGER, parent_id TEXT, run_id TEXT,
+  step INTEGER, stage TEXT, created_at REAL, status TEXT, notes TEXT, source TEXT);
+CREATE TABLE checkpoints (
+  id TEXT PRIMARY KEY, run_id TEXT, step INTEGER, model_id TEXT, path TEXT, size_gb REAL,
+  created_at REAL, kept INTEGER);
+
+CREATE TABLE datasets (
+  id TEXT PRIMARY KEY, project_id TEXT, name TEXT, kind TEXT, version TEXT, parent_id TEXT,
+  rows INTEGER, tokens INTEGER, license TEXT, hf_repo TEXT, description TEXT, created_at REAL,
+  processing TEXT, fields TEXT, source TEXT, provenance TEXT);
+CREATE TABLE dataset_sources (
+  dataset_id TEXT, name TEXT, category TEXT, rows INTEGER, tokens INTEGER, synthetic INTEGER,
+  generator TEXT, license TEXT, url TEXT);
+CREATE TABLE dataset_rows (
+  dataset_id TEXT, idx INTEGER, source TEXT, category TEXT, data TEXT, tokens INTEGER,
+  PRIMARY KEY(dataset_id, idx));
+
+CREATE TABLE graders (
+  id TEXT PRIMARY KEY, project_id TEXT, name TEXT, kind TEXT, description TEXT, components TEXT,
+  formula TEXT);
+CREATE TABLE environments (
+  id TEXT PRIMARY KEY, project_id TEXT, name TEXT, domain TEXT, version TEXT, description TEXT,
+  harness TEXT, tools TEXT, grader_id TEXT, reward_kind TEXT, sandbox TEXT, task_count INTEGER,
+  created_at REAL, source TEXT, provenance TEXT, checks TEXT);
+CREATE TABLE tasks (
+  id TEXT PRIMARY KEY, env_id TEXT, name TEXT, instruction TEXT, difficulty REAL, tags TEXT,
+  status TEXT, status_reason TEXT, oracle_score REAL, noop_score REAL, reruns INTEGER,
+  rerun_agree REAL, base_pass REAL, latest_pass REAL, attempts INTEGER);
+
+CREATE TABLE runs (
+  id TEXT PRIMARY KEY, project_id TEXT, name TEXT, kind TEXT, stage TEXT, algorithm TEXT,
+  framework TEXT, status TEXT, status_reason TEXT, base_model_id TEXT, output_model_id TEXT,
+  started_at REAL, ended_at REAL, updated_at REAL, steps_planned INTEGER, steps_done INTEGER,
+  primary_metric TEXT, gpu TEXT, gpus INTEGER, cost_usd REAL, cost_rate REAL, owner TEXT,
+  tags TEXT, code_ref TEXT, config TEXT, config_format TEXT, hyperparams TEXT,
+  parent_run_id TEXT, group_name TEXT, description TEXT, source TEXT, provenance TEXT);
+CREATE TABLE run_inputs (run_id TEXT, kind TEXT, ref_id TEXT, weight REAL);
+CREATE TABLE metric_defs (
+  project_id TEXT, tag TEXT, label TEXT, description TEXT, unit TEXT, format TEXT, grp TEXT,
+  better TEXT, pinned INTEGER, signal TEXT, PRIMARY KEY(project_id, tag));
+CREATE TABLE metrics (run_id TEXT, tag TEXT, step INTEGER, value REAL,
+  PRIMARY KEY(run_id, tag, step)) WITHOUT ROWID;
+CREATE TABLE run_steps (
+  run_id TEXT, step INTEGER, phase TEXT, started_at REAL, ended_at REAL, prompts INTEGER,
+  rollouts INTEGER, rollouts_stored INTEGER, reward_mean REAL, pass_rate REAL, tokens INTEGER,
+  groups_all_pass INTEGER, groups_all_fail INTEGER, groups_mixed INTEGER, infra_errors INTEGER,
+  truncated INTEGER, PRIMARY KEY(run_id, step, phase));
+CREATE TABLE run_events (
+  run_id TEXT, t REAL, step INTEGER, kind TEXT, severity TEXT, title TEXT, body TEXT);
+
+CREATE TABLE rollouts (
+  id TEXT PRIMARY KEY, run_id TEXT, eval_id TEXT, step INTEGER, phase TEXT, group_id TEXT,
+  sample INTEGER, task_id TEXT, env_id TEXT, harness TEXT, model_id TEXT, reward REAL,
+  advantage REAL, scores TEXT, outcome TEXT, stop_reason TEXT, turns INTEGER,
+  tool_calls INTEGER, tokens_in INTEGER, tokens_out INTEGER, tokens_cached INTEGER,
+  duration_s REAL, timing TEXT, staleness INTEGER, flags TEXT, seed INTEGER, trained INTEGER);
+CREATE TABLE transcripts (rollout_id TEXT PRIMARY KEY, messages TEXT);
+
+CREATE TABLE benchmarks (
+  id TEXT PRIMARY KEY, project_id TEXT, name TEXT, version TEXT, category TEXT, metric TEXT,
+  harness TEXT, n_tasks INTEGER, k INTEGER, description TEXT, source TEXT);
+CREATE TABLE evals (
+  id TEXT PRIMARY KEY, project_id TEXT, benchmark_id TEXT, model_id TEXT, run_id TEXT,
+  step INTEGER, status TEXT, score REAL, stderr REAL, n_tasks INTEGER, k INTEGER,
+  n_infra INTEGER, started_at REAL, ended_at REAL, cost_usd REAL, config TEXT, command TEXT,
+  source TEXT, provenance TEXT);
+CREATE TABLE eval_tasks (
+  eval_id TEXT, task_id TEXT, task_name TEXT, attempts INTEGER, passes INTEGER, infra INTEGER,
+  score REAL, mean_turns REAL, mean_tokens REAL, PRIMARY KEY(eval_id, task_name));
+
+CREATE TABLE clusters (
+  id TEXT PRIMARY KEY, org_id TEXT, name TEXT, provider TEXT, gpu TEXT, gpus INTEGER,
+  region TEXT, price_hour REAL);
+CREATE TABLE jobs (
+  id TEXT PRIMARY KEY, project_id TEXT, run_id TEXT, eval_id TEXT, name TEXT, kind TEXT,
+  status TEXT, cluster_id TEXT, gpu TEXT, gpus INTEGER, nodes INTEGER, started_at REAL,
+  ended_at REAL, cost_usd REAL, exit TEXT, log_tail TEXT,
+  target TEXT, spec TEXT, runner_id TEXT, external_id TEXT, created_at REAL, claimed_at REAL,
+  cancel INTEGER, message TEXT);
+CREATE TABLE usage (
+  org_id TEXT, project_id TEXT, day TEXT, category TEXT, quantity REAL, unit TEXT,
+  cost_usd REAL);
+CREATE TABLE deployments (
+  id TEXT PRIMARY KEY, project_id TEXT, model_id TEXT, name TEXT, status TEXT, endpoint TEXT,
+  gpu TEXT, replicas INTEGER, created_at REAL, requests_24h INTEGER, p50_ms REAL,
+  tokens_24h INTEGER);
+CREATE TABLE reports (
+  id TEXT PRIMARY KEY, project_id TEXT, title TEXT, author TEXT, created_at REAL, run_ids TEXT,
+  summary TEXT, body TEXT, claims TEXT);
+
+CREATE INDEX rollouts_run ON rollouts(run_id, step, group_id);
+CREATE INDEX rollouts_eval ON rollouts(eval_id, task_id);
+CREATE INDEX rollouts_task ON rollouts(task_id);
+CREATE INDEX tasks_env ON tasks(env_id);
+CREATE INDEX evals_bench ON evals(benchmark_id);
+CREATE INDEX evals_model ON evals(model_id);
+CREATE INDEX evals_run ON evals(run_id);
+CREATE INDEX events_run ON run_events(run_id, t);
+CREATE INDEX jobs_project ON jobs(project_id, started_at);
+CREATE INDEX usage_project ON usage(project_id, day);
+"""
+
+JSON_COLUMNS = {"sources", "pins", "processing", "fields", "data", "components", "tools", "sandbox", "checks", "spec", "targets",
+                "tags", "hyperparams", "scores", "timing", "flags", "config_json", "run_ids", "claims",
+                # workspace tables (workspace.EXTRA): suites, settings, acknowledgements, promotions, deployments, audit
+                "benchmarks", "stages", "comparison", "steps", "handle", "serving", "smoke", "detail"}
+
+_local = threading.local()
+
+
+def path_for(source):
+    if source not in SOURCES:
+        raise KeyError(source)
+    return DATA / SOURCES[source]
+
+
+def available():
+    return {name: path_for(name).exists() for name in SOURCES}
+
+
+def connect(source):
+    """A connection per thread and source: read-only for built sources, read-write for the workspace."""
+    if source in WRITABLE:
+        from . import workspace
+        return workspace.connect()
+    cache = getattr(_local, "conns", None)
+    if cache is None:
+        cache = _local.conns = {}
+    path = path_for(source)
+    stamp = path.stat().st_mtime if path.exists() else None
+    held = cache.get(source)
+    if held and held[1] == stamp:
+        return held[0]
+    if held:
+        held[0].close()
+    if stamp is None:
+        raise FileNotFoundError(path)
+    # immutable: the file never changes while open (rebuilds replace it), and hosts like Vercel mount it read-only
+    conn = sqlite3.connect(f"file:{path}?mode=ro&immutable=1", uri=True, check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    cache[source] = (conn, stamp)
+    return conn
+
+
+def decode(row):
+    out = dict(row)
+    for key, value in out.items():
+        if key in JSON_COLUMNS and isinstance(value, str) and value[:1] in "[{":
+            try:
+                out[key] = json.loads(value)
+            except ValueError:
+                pass
+    return out
+
+
+def rows(conn, sql, args=()):
+    return [decode(r) for r in conn.execute(sql, args).fetchall()]
+
+
+def one(conn, sql, args=()):
+    r = conn.execute(sql, args).fetchone()
+    return decode(r) if r else None
+
+
+def create(path):
+    path = Path(path)
+    if path.exists():
+        path.unlink()
+    conn = sqlite3.connect(path)
+    conn.executescript(SCHEMA)
+    return conn
+
+
+def insert(conn, table, record):
+    record = {k: (json.dumps(v, separators=(",", ":")) if isinstance(v, (dict, list)) else v)
+              for k, v in record.items()}
+    cols = ",".join(record)
+    marks = ",".join("?" for _ in record)
+    conn.execute(f"INSERT INTO {table} ({cols}) VALUES ({marks})", tuple(record.values()))
+
+
+def insert_many(conn, table, records):
+    records = list(records)
+    if not records:
+        return
+    cols = list(records[0])
+    sql = f"INSERT INTO {table} ({','.join(cols)}) VALUES ({','.join('?' for _ in cols)})"
+    conn.executemany(sql, [tuple(json.dumps(r[c], separators=(",", ":")) if isinstance(r[c], (dict, list)) else r[c]
+                                 for c in cols) for r in records])
diff --git a/viewer/health.py b/viewer/health.py
new file mode 100644
index 0000000000000000000000000000000000000000..1913f2b82f3b34e9434277ff1e0b767ad1cc7478
--- /dev/null
+++ b/viewer/health.py
@@ -0,0 +1,258 @@
+"""Health rules: which signals look wrong for a run, and why.
+
+Each rule reads one canonical signal (see build/signals.py) through the run's own tag and
+returns a finding with a plain explanation. Thresholds are deliberately conservative; each
+says where it comes from.
+"""
+import statistics
+
+RULES = [
+    # signal, test(values) -> (level, message) | None
+]
+
+
+def _last(values, n=3):
+    vals = [v for _, v in values][-n:]
+    return sum(vals) / len(vals) if vals else None
+
+
+def _first(values, n=3):
+    vals = [v for _, v in values][:n]
+    return sum(vals) / len(vals) if vals else None
+
+
+SRC = {
+    "prime_errors": "https://github.com/PrimeIntellect-ai/prime-rl/blob/c28afbbae290dd71ffe04065ac43364b97f93d0e/docs/training.md",
+    "marin_eval": "https://github.com/marin-community/marin/issues/9409",
+    "marin_policy": "https://gist.github.com/penfever/ba02607c0f1324e86de98bc398fc3189#file-policy-md-L118-L126",
+    "marin_entropy": "https://github.com/marin-community/marin/issues/7785",
+    "nemo_kl": "https://github.com/NVIDIA-NeMo/RL/blob/4aaa48fabd178a4bf481e52c49e9125995e0f2a8/docs/guides/grpo.md",
+    "tinker_kl": "https://github.com/thinking-machines-lab/tinker-cookbook",
+    "verl_clip": "https://github.com/verl-project/verl/blob/6093e007cc341973c9d9a6fb3867a85976c7c458/docs/perf/best_practices.rst",
+    "areal_eos": "https://github.com/areal-project/AReaL/blob/643b20bf96315bd014daebd07196da68e9a00946/docs/en/best_practices/algo_perf.md",
+}
+
+
+def rule_infra(values):
+    v = _last(values)
+    if v is None:
+        return None
+    if v > 0.10:
+        return "bad", f"{v:.1%} of trajectories lost to infrastructure over the last steps, above the 10% at which Marin stops trusting a score. They are excluded from the reward, but the batch shrinks and some tasks go unsampled.", SRC["marin_eval"]
+    if v > 0.05:
+        return "warn", f"{v:.1%} of trajectories lost to infrastructure; prime-rl calls a sustained rate above 5% a smell.", SRC["prime_errors"]
+    return "ok", f"{v:.2%} of trajectories lost to infrastructure (below prime-rl's 5%).", SRC["prime_errors"]
+
+
+def rule_all_fail(values):
+    v = _last(values)
+    if v is None:
+        return None
+    if v > 0.6:
+        return "bad", f"{v:.0%} of prompts had every attempt fail: most of the batch gives no gradient."
+    if v > 0.35:
+        return "warn", f"{v:.0%} of prompts had every attempt fail and teach nothing. Consider filtering by pass rate."
+    return "ok", f"{v:.0%} of prompts had every attempt fail."
+
+
+def rule_mixed(values):
+    v = _last(values)
+    if v is None:
+        return None
+    if v < 1 / 8:
+        return "bad", f"Only {v:.0%} of groups have attempts that disagree, below Marin's 1/8 floor (they retire an experiment after three steps under it).", SRC["marin_policy"]
+    if v < 0.25:
+        return "warn", f"Only {v:.0%} of groups carry a learning signal.", SRC["marin_policy"]
+    return "ok", f"{v:.0%} of groups carry a learning signal.", SRC["marin_policy"]
+
+
+def rule_all_pass(values):
+    v = _last(values)
+    if v is None:
+        return None
+    if v > 0.5:
+        return "warn", f"{v:.0%} of prompts are always solved: the pool is getting too easy."
+    return "ok", f"{v:.0%} of prompts had every attempt pass."
+
+
+def rule_entropy(values):
+    a, b = _first(values), _last(values)
+    if a is None or b is None or a <= 0:
+        return None
+    ratio = b / a
+    if ratio < 0.2:
+        return "bad", f"Entropy fell to {ratio:.0%} of its starting value, below Marin's rule of keeping at least a fifth: the policy has nearly stopped exploring.", SRC["marin_policy"]
+    if ratio < 0.4:
+        return "warn", f"Entropy fell to {ratio:.0%} of its starting value (Marin's floor is a fifth).", SRC["marin_policy"]
+    if ratio >= 10:
+        return "bad", f"Entropy rose to {ratio:.0f}× its starting value; Marin's rule is to pick a checkpoint and stop at 10×.", SRC["marin_entropy"]
+    if ratio >= 3:
+        return "warn", f"Entropy rose to {ratio:.1f}× its starting value, Marin's watch level (3×).", SRC["marin_entropy"]
+    return "ok", f"Entropy is {ratio:.0%} of its starting value.", None
+
+
+def _local_spike(values, factor):
+    """The largest point, after warmup, that exceeds `factor` × the median of the points just before it
+    and every one of them; None if there is none. A smooth fall never qualifies; warmup is skipped."""
+    vals = [v for _, v in values]
+    n = len(vals)
+    w = max(5, n // 20)
+    start = max(w, n // 10)          # warmup: the first tenth of the run, and at least one window
+    best = None
+    for i in range(start, n):
+        prev = vals[i - w:i]
+        base = statistics.median(prev)
+        if base > 0 and vals[i] > factor * base and vals[i] > max(prev):
+            ratio = vals[i] / base
+            if best is None or ratio > best[2]:
+                best = (values[i][0], vals[i], ratio, base)
+    return best
+
+
+def rule_grad(values):
+    if len(values) < 10:
+        return None
+    spike = _local_spike(values, 8)
+    if spike:
+        step, peak, ratio, base = spike
+        return "warn", f"Gradient norm spiked to {ratio:.0f}× the steps just before it at step {step} ({peak:.3g} vs {base:.3g}), after warmup. No published threshold; spikes like this often come before a collapse.", None
+    return "ok", "No gradient-norm spike above 8× the preceding steps after warmup (our own margin; no published threshold).", None
+
+
+def rule_train_infer(values):
+    v = _last(values)
+    if v is None:
+        return None
+    if v > 0.01:
+        return "bad", f"Trainer and sampler disagree (KL {v:.3g}), above the 0.01 Tinker treats as the stable limit: trajectories are off-policy for the trainer. Check precision and kernels, or correct with importance sampling.", SRC["tinker_kl"]
+    if v > 0.001:
+        return "warn", f"Trainer vs sampler KL is {v:.3g}, above the 1e-3 NeMo-RL calls acceptable.", SRC["nemo_kl"]
+    return "ok", f"Trainer vs sampler KL is {v:.2g} (NeMo-RL: below 1e-3 is acceptable).", SRC["nemo_kl"]
+
+
+def rule_trunc(values):
+    v = _last(values)
+    if v is None:
+        return None
+    if v > 0.1:
+        return "bad", f"{v:.0%} of trajectories hit the length limit; verl says above 10% you are truncating too much.", SRC["verl_clip"]
+    if v > 0.05:
+        return "warn", f"{v:.0%} of trajectories hit the length limit (AReaL flags above 5%).", SRC["areal_eos"]
+    return "ok", f"{v:.1%} of trajectories truncated.", SRC["verl_clip"]
+
+
+def rule_staleness(values):
+    v = _last(values)
+    if v is None:
+        return None
+    if v > 3:
+        return "warn", f"Trajectories are {v:.1f} policy versions old on average when trained (no published limit; configs usually cap it at 1–4).", None
+    return "ok", f"Average staleness {v:.2f} policy versions.", None
+
+
+def rule_reward(values):
+    vals = [v for _, v in values]
+    if len(vals) < 6:
+        return None
+    k = max(2, len(vals) // 5)
+    a, b = sum(vals[:k]) / k, sum(vals[-k:]) / k
+    d = b - a
+    if d < -0.03:
+        return "warn", f"Reward fell from {a:.3f} to {b:.3f} between the first and last fifth of the run."
+    if abs(d) < 0.005:
+        return "warn", f"Reward is flat ({a:.3f} → {b:.3f})."
+    return "ok", f"Reward {a:.3f} → {b:.3f} from the first to the last fifth."
+
+
+def rule_loss(values):
+    vals = [v for _, v in values]
+    if len(vals) < 6:
+        return None
+    k = max(2, len(vals) // 5)
+    a, b = sum(vals[:k]) / k, sum(vals[-k:]) / k
+    if b > a * 1.02:
+        return "bad", f"Training loss rose from {a:.3f} to {b:.3f}."
+    spike = _local_spike(values, 1.6) if len(values) >= 10 else None
+    if spike:
+        step, peak, ratio, base = spike
+        return "warn", f"Loss spiked to {peak:.3f} at step {step}, {ratio:.1f}× the steps just before it ({base:.3f})."
+    return "ok", f"Loss {a:.3f} → {b:.3f}."
+
+
+def rule_val_loss(values):
+    vals = [v for _, v in values]
+    if len(vals) < 4:
+        return None
+    best_i = min(range(len(vals)), key=lambda i: vals[i])
+    if best_i < len(vals) - 1 and vals[-1] > vals[best_i] * 1.02:
+        return "warn", f"Validation loss bottomed at step {values[best_i][0]} ({vals[best_i]:.3f}) and has risen to {vals[-1]:.3f}: likely overfitting; keep the earlier checkpoint."
+    return "ok", f"Validation loss is still falling ({vals[0]:.3f} → {vals[-1]:.3f})."
+
+
+def rule_pref_acc(values):
+    v = _last(values)
+    if v is None:
+        return None
+    if v < 0.55:
+        return "warn", f"The policy prefers the chosen response on only {v:.0%} of pairs."
+    return "ok", f"Chosen response preferred on {v:.0%} of pairs."
+
+
+WINDOWED = set()
+
+CHECKS = {
+    "loss": ("Loss", rule_loss),
+    "val_loss": ("Generalization", rule_val_loss),
+    "pref_accuracy": ("Preference", rule_pref_acc),
+    "reward": ("Learning", rule_reward),
+    "pass_rate": ("Learning", rule_reward),
+    "mixed_share": ("Groups with signal", rule_mixed),
+    "all_fail_share": ("All attempts failed", rule_all_fail),
+    "all_pass_share": ("All attempts passed", rule_all_pass),
+    "entropy": ("Exploration", rule_entropy),
+    "grad_norm": ("Optimizer", rule_grad),
+    "train_infer_kl": ("Trainer vs sampler", rule_train_infer),
+    "truncation_rate": ("Length", rule_trunc),
+    "infra_error_rate": ("Infrastructure", rule_infra),
+    "staleness": ("Staleness", rule_staleness),
+}
+
+WINDOWED.update({rule_infra, rule_all_fail, rule_all_pass, rule_mixed, rule_train_infer, rule_trunc, rule_staleness, rule_pref_acc})
+
+ORDER = ["loss", "val_loss", "pref_accuracy", "reward", "pass_rate", "mixed_share", "all_fail_share", "all_pass_share", "entropy", "grad_norm",
+         "train_infer_kl", "truncation_rate", "infra_error_rate", "staleness"]
+
+
+# RL losses (policy-gradient surrogates) are not expected to fall; judging them like an SFT loss raises false alarms
+NOT_FOR_KIND = {"rl": {"loss"}}
+
+
+def check(series_by_signal, kind=None, simulated=False):
+    """series_by_signal: {signal: [(step, value), ...]} -> list of findings.
+    kind: the run's kind (sft, dpo, rl, ...); simulated: the curves are simulated, not published or measured,
+    so each finding says so and is marked `simulated`."""
+    out = []
+    skip = NOT_FOR_KIND.get(kind or "", set())
+    if "mixed_share" not in series_by_signal and "all_fail_share" in series_by_signal and "all_pass_share" in series_by_signal:
+        ap = dict(series_by_signal["all_pass_share"])
+        series_by_signal = dict(series_by_signal, mixed_share=[(st, 1 - v - ap[st]) for st, v in series_by_signal["all_fail_share"] if st in ap])
+    seen_learning = False
+    for signal in ORDER:
+        values = series_by_signal.get(signal)
+        if not values or signal in skip:
+            continue
+        area, fn = CHECKS[signal]
+        if area == "Learning":
+            if seen_learning:
+                continue
+            seen_learning = True
+        res = fn(values)
+        if res:
+            level, msg = res[0], res[1]
+            if fn in WINDOWED and len(values) >= 3:
+                msg = msg.rstrip(".") + f" (mean of steps {values[-3][0]}–{values[-1][0]})."
+            src = res[2] if len(res) > 2 else None
+            if simulated and level in ("warn", "bad"):
+                msg = msg.rstrip(".") + ". (Simulated curve, not published data.)"
+            out.append({"signal": signal, "area": area, "level": level, "message": msg, "source": src, "simulated": bool(simulated)})
+    return out
diff --git a/viewer/render.py b/viewer/render.py
new file mode 100644
index 0000000000000000000000000000000000000000..2758405efb7b44fb81ac519d3fa5c73e2215ece5
--- /dev/null
+++ b/viewer/render.py
@@ -0,0 +1,159 @@
+"""Render a transcript and a score breakdown for a rollout that has no stored transcript.
+
+The demo source stores rollout facts (reward, turns, tool calls, outcome, tokens) but not
+messages. Messages are rendered deterministically from the rollout's seed so they agree with
+the stored facts: one assistant message per turn, `tool_calls` tool calls in total, and an
+ending that matches `outcome`. Domains whose tasks are not published get no rendered text.
+"""
+import random
+
+WITHHELD = {"cyber"}
+
+SYSTEM = {
+    "code": "You are a software engineer working in a repository at /workspace. Inspect and edit files and run commands with the tools. When the change is complete and the tests pass, call submit.",
+    "terminal": "You are working in a Linux container. Complete the task with the shell tool, then call submit.",
+    "agentic": "You are an assistant with a browser, a Python sandbox and a file system. Complete the user's task end to end, then call submit with a short summary.",
+    "tool_use": "You are a support agent. Use the provided tools and follow the policy exactly; never invent data you did not look up.",
+    "search": "You are a research assistant with a web search tool. Give a short answer with sources.",
+    "math": "Solve the problem. Reason step by step, then put the final answer in \\boxed{}.",
+    "competitive_code": "Write a complete, efficient program that reads stdin and writes stdout. Explain briefly, then give the code in one block.",
+    "if": "Follow every instruction in the user's message exactly.",
+    "chat": "You are a helpful, honest assistant.",
+    "visual": "Answer the question about the image. Give the final answer on the last line.",
+    "science": "Answer the question. Show the key steps and give the final answer with units.",
+}
+SYSTEM["swe"] = SYSTEM["code"]
+SYSTEM["web"] = "You are a front-end engineer. Build the requested site in /workspace, run the build, and deliver the output in dist/. Call submit when the site builds and renders."
+SYSTEM["games"] = "You are playing a text game through the provided actions. Reach the goal in as few moves as you can."
+SYSTEM["long_context"] = "Answer the question using only the documents provided. Quote the passage you rely on."
+SYSTEM["other"] = SYSTEM["chat"]
+
+STEPS = {
+    "code": [
+        ("bash", "ls && git log --oneline -3", "pyproject.toml  src  tests  README.md\n9f1c2ab Merge pull request #2211\n41aa0d3 Bump version"),
+        ("bash", "grep -rn \"def load\" src | head -5", "src/pkg/core.py:214:def load(self, value, *, strict=False):\nsrc/pkg/compat.py:37:def load(value):"),
+        ("bash", "sed -n 205,240p src/pkg/core.py", "    def load(self, value, *, strict=False):\n        key = self._key(value)\n        return self._cache.setdefault(key, self._read(key))"),
+        ("bash", "python -m pytest tests/test_core.py -x -q 2>&1 | tail -6", "F\nE   AssertionError: stale value returned after reload\n1 failed, 41 passed in 2.31s"),
+        ("edit", "src/pkg/core.py: invalidate the cache entry when the file's mtime changes", "Edited src/pkg/core.py (+6 −2)."),
+        ("bash", "python -m pytest tests -q 2>&1 | tail -2", "212 passed, 3 skipped in 11.02s"),
+        ("bash", "git diff --stat", " src/pkg/core.py    | 8 ++++++--\n tests/test_core.py | 9 +++++++++"),
+    ],
+    "terminal": [
+        ("bash", "cat README.md | head -12", "# app\nRun `make test` to build and test."),
+        ("bash", "make test 2>&1 | tail -4", "ModuleNotFoundError: No module named 'yaml'\nmake: *** [Makefile:12: test] Error 1"),
+        ("bash", "pip install -q -r requirements.txt && make test 2>&1 | tail -3", "collected 18 items\n.................F\nFAILED tests/test_io.py::test_roundtrip"),
+        ("bash", "sed -n 1,30p src/io.py", "import yaml\n\ndef load(path):\n    with open(path) as fh:\n        return yaml.load(fh)"),
+        ("bash", "sed -i 's/yaml.load(fh)/yaml.safe_load(fh)/' src/io.py && make test 2>&1 | tail -2", "18 passed in 1.84s"),
+    ],
+    "agentic": [
+        ("browser_open", "http://localhost:8080/forms/new", "Loaded 'New application'. Fields: name, email, phone, start_date, role."),
+        ("python", "import json; print(json.load(open('applicant.json')))", "{'name': 'Ana Pereira', 'email': 'ana.p@example.com', 'start_date': '2026-11-02', 'role': 'Data analyst'}"),
+        ("browser_fill", "name, email, start_date", "Filled 3 fields."),
+        ("browser_select", "role = 'Data analyst'", "Selected 'Data analyst'."),
+        ("browser_click", "Submit", "Submitted. Confirmation #A-20931."),
+    ],
+    "tool_use": [
+        ("get_order", "{\"order_id\": \"W-48213\"}", "{\"status\": \"delivered\", \"delivered_at\": \"2026-08-14\", \"total\": 129.90}"),
+        ("get_policy", "{\"topic\": \"refunds\"}", "Refunds within 30 days of delivery; store credit up to 60 days."),
+        ("issue_store_credit", "{\"order_id\": \"W-48213\", \"amount\": 129.90}", "{\"ok\": true, \"credit_id\": \"C-7781\"}"),
+    ],
+    "web": [
+        ("bash", "npm create vite@latest site -- --template vanilla && cd site && npm install", "Scaffolding project in /workspace/site...\nadded 12 packages in 3s"),
+        ("write_file", "site/index.html", "Wrote 2,418 bytes."),
+        ("write_file", "site/src/style.css", "Wrote 3,902 bytes."),
+        ("bash", "cd site && npm run build", "vite v6 building for production...\n✓ 4 modules transformed.\ndist/index.html  2.41 kB\ndist/assets/index.css  3.90 kB\n✓ built in 412ms"),
+        ("screenshot", "dist/index.html at 1440×900", "Captured full-page screenshot (1440×2380)."),
+    ],
+    "games": [
+        ("act", "look", "You are in a dusty kitchen. Exits: north, east. There is a locked drawer."),
+        ("act", "go east", "A narrow pantry. A small brass key lies on the shelf."),
+        ("act", "take key", "Taken."),
+        ("act", "go west", "Kitchen."),
+        ("act", "unlock drawer with key", "The drawer opens, revealing a map."),
+    ],
+    "search": [
+        ("search", "tour de france 2026 winner margin", "1. Official results — General classification ...\n2. Race report ..."),
+        ("open", "result 1", "General classification: 1st ... +1'12\" ..."),
+    ],
+}
+
+ANSWERS = {
+    "math": ("Let me set up the count carefully and check small cases first.", "\\boxed{400}"),
+    "competitive_code": ("Sort by start, then sweep and merge overlaps in one pass: O(n log n).",
+                         "```python\nimport sys\ndef main():\n    data = sys.stdin.read().split()\n    n = int(data[0])\n    iv = sorted((int(data[1+2*i]), int(data[2+2*i])) for i in range(n))\n    out = [list(iv[0])]\n    for s, e in iv[1:]:\n        if s <= out[-1][1]:\n            out[-1][1] = max(out[-1][1], e)\n        else:\n            out.append([s, e])\n    print('\\n'.join(f'{s} {e}' for s, e in out))\nmain()\n```"),
+    "if": ("Check each constraint before answering.", "[\"Better sleep\", \"More energy\", \"Lower stress\"]"),
+    "chat": ("", "Short version: it depends on how long you'll stay. Buying usually pays off after about five years, once closing costs are spread out; renting keeps you flexible if a move within three years is likely."),
+    "visual": ("Reading the bars: Q3 grows from 41 to 55, the largest jump.", "Q3"),
+    "science": ("Use energy conservation: v = √(2gh), with h = 5 m × sin 30° = 2.5 m.", "v ≈ 7.0 m/s"),
+    "long_context": ("The answer is in the third document's section on renewal terms.", "The contract renews automatically for 12 months unless either party gives 60 days' notice (Doc 3, §7.2)."),
+    "other": ("Plan the form first: A (8 bars), B (8 bars), return of A.", "X:1\nT:Country Dance\nM:4/4\nL:1/8\nQ:1/4=129\nK:E\n|: E2GB e2dc | B2GE F2GA | B2e2 f2ga | b2ag f2e2 :|"),
+}
+
+ENDINGS = {
+    "timeout": "The agent was stopped at the time limit before it submitted.",
+    "truncated": "The response hit the maximum length and was cut off.",
+    "infra_error": "The sandbox failed before the attempt finished. This attempt is excluded from the reward.",
+    "max_turns": "The agent reached the turn limit without submitting.",
+}
+
+
+def transcript(r, task, env):
+    domain = (env or {}).get("domain") or "chat"
+    instruction = (task or {}).get("instruction") or (task or {}).get("name") or "Task"
+    if domain in WITHHELD:
+        return [{"role": "note", "content": "Transcripts for this data source are not published."}]
+    rnd = random.Random(r.get("seed") or 0)
+    msgs = [{"role": "system", "content": SYSTEM.get(domain, SYSTEM["chat"])},
+            {"role": "user", "content": instruction}]
+    turns = max(0, r.get("turns") or 0)
+    calls_left = max(0, r.get("tool_calls") or 0)
+    outcome = r.get("outcome") or "failed"
+    steps = STEPS.get("code" if domain == "swe" else domain)
+    if steps and turns > 0:
+        for i in range(turns):
+            last = i == turns - 1
+            if last and outcome in ("passed", "failed", "partial") and calls_left:
+                msgs.append({"role": "assistant", "content": "The change is in place and the checks pass locally." if outcome == "passed"
+                             else "I believe this addresses the task.",
+                             "tool_calls": [{"id": f"call_{i}", "name": "submit", "arguments": "{}"}]})
+                msgs.append({"role": "tool", "tool_call_id": f"call_{i}", "name": "submit", "content": "Submitted."})
+                calls_left -= 1
+                continue
+            if calls_left > 0:
+                name, args, out = steps[min(len(steps) - 1, i if i < len(steps) else rnd.randrange(len(steps)))]
+                thought = rnd.choice(["Let me look at the relevant code first.", "Checking what the tests expect.",
+                                      "Running the failing test to see the error.", "Trying the fix and re-running the checks.",
+                                      "Confirming nothing else broke.", "Reading the surrounding code before editing."])
+                msgs.append({"role": "assistant", "content": thought,
+                             "tool_calls": [{"id": f"call_{i}", "name": name, "arguments": args}]})
+                msgs.append({"role": "tool", "tool_call_id": f"call_{i}", "name": name, "content": out})
+                calls_left -= 1
+            else:
+                msgs.append({"role": "assistant", "content": "Summarizing what I found so far."})
+    else:
+        reasoning, answer = ANSWERS.get(domain, ANSWERS["chat"])
+        if outcome in ("failed",) and domain in ("math", "visual", "science"):
+            answer = {"math": "\\boxed{380}", "visual": "Q2", "science": "v ≈ 9.9 m/s"}[domain]
+        msgs.append({"role": "assistant", "reasoning": reasoning, "content": answer})
+    if outcome in ENDINGS:
+        msgs.append({"role": "note", "content": ENDINGS[outcome]})
+    return msgs
+
+
+def scores(r, env, grader):
+    """Score components with the rule that produced each value."""
+    reward = r.get("reward")
+    outcome = r.get("outcome")
+    comps = (grader or {}).get("components") or [{"name": "reward", "weight": 1.0, "rule": ""}]
+    if isinstance(comps, str):
+        import json
+        comps = json.loads(comps)
+    if reward is None:
+        return [{"name": "reward", "value": None, "explanation": "Not scored: " + ENDINGS.get(outcome, "the attempt did not finish.")}]
+    out = []
+    for comp in comps:
+        expl = comp.get("rule") or ""
+        if outcome in ("timeout", "truncated", "max_turns"):
+            expl = ENDINGS[outcome] + " Scored as a failure."
+        out.append({"name": comp["name"], "weight": comp.get("weight", 1.0), "value": reward, "explanation": expl})
+    return out
diff --git a/viewer/server.py b/viewer/server.py
new file mode 100644
index 0000000000000000000000000000000000000000..08b4f3d462fcf88f4ace6a6858e2ea1a608d2f8a
--- /dev/null
+++ b/viewer/server.py
@@ -0,0 +1,848 @@
+"""The viewer's API (/api/v3) and single-page app (/dashboard).
+
+Mount into another FastAPI app with `app.include_router(viewer.server.router)` and
+`viewer.server.mount_static(app)`, or run standalone: python -m viewer.server --port 7880
+"""
+import json
+import os
+import math
+import re
+from collections import defaultdict
+from pathlib import Path
+
+from fastapi import APIRouter, FastAPI, HTTPException, Query, Request
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+
+from . import api_ui, api_write, db, health, render, workspace
+from . import stages as S
+from .build import signals as sigdefs
+
+STATIC = Path(__file__).parent / "static"
+BASE = "/dashboard"
+router = APIRouter(prefix="/api/v3")
+
+
+def conn_for(source):
+    try:
+        return db.connect(source or "demo")
+    except (KeyError, FileNotFoundError):
+        raise HTTPException(404, f"Data source '{source}' is not available.")
+
+
+SOURCE_LABEL = {"workspace": "Your workspace", "demo": "Examples from public recipes", "live": "BenchFlow runs"}
+
+
+def readonly():
+    """POSTTRAIN_READONLY=1: a public, read-only console (e.g. on a public Space): the built sources only,
+    no workspace, no write API; the website hides everything that changes something."""
+    return os.environ.get("POSTTRAIN_READONLY") == "1"
+
+
+def available_sources():
+    out = [s for s, ok in db.available().items() if ok]
+    if readonly():
+        return [s for s in out if s != "workspace"]
+    if "workspace" not in out:
+        out.insert(0, "workspace")
+    return out
+
+
+def project_or_404(c, org, project):
+    p = db.one(c, "SELECT p.*, o.slug AS org_slug, o.name AS org_name FROM projects p JOIN orgs o ON o.id=p.org_id "
+                  "WHERE o.slug=? AND p.slug=?", (org, project))
+    if not p:
+        raise HTTPException(404, "No such project.")
+    return p
+
+
+def downsample(points, n=60):
+    if len(points) <= n:
+        return points
+    stride = len(points) / n
+    return [points[int(i * stride)] for i in range(n)] + [points[-1]]
+
+
+def series(c, run_id, tag):
+    return [(r["step"], r["value"]) for r in c.execute(
+        "SELECT step, value FROM metrics WHERE run_id=? AND tag=? ORDER BY step", (run_id, tag))]
+
+
+def signal_tags(c, project_id, run_id=None):
+    """{signal: tag} for the canonical signals this project logs (and this run has)."""
+    defs = db.rows(c, "SELECT tag, signal FROM metric_defs WHERE project_id=? AND signal IS NOT NULL", (project_id,))
+    out = {}
+    have = None
+    if run_id:
+        have = {r[0] for r in c.execute("SELECT DISTINCT tag FROM metrics WHERE run_id=?", (run_id,))}
+    for d in defs:
+        if have is not None and d["tag"] not in have:
+            continue
+        out.setdefault(d["signal"], d["tag"])
+    return out
+
+
+def model_names(c, ids):
+    ids = [i for i in ids if i]
+    if not ids:
+        return {}
+    q = ",".join("?" for _ in ids)
+    return {r["id"]: r["name"] for r in db.rows(c, f"SELECT id, name FROM models WHERE id IN ({q})", ids)}
+
+
+def run_summary(c, run, sig_tags=None):
+    sig_tags = sig_tags if sig_tags is not None else signal_tags(c, run["project_id"], run["id"])
+    primary = run.get("primary_metric")
+    pts = series(c, run["id"], primary) if primary else []
+    last = pts[-1][1] if pts else None
+    first = pts[0][1] if pts else None
+    evals = db.rows(c, "SELECT e.benchmark_id, b.name, b.metric, e.step, e.score, e.stderr FROM evals e JOIN benchmarks b ON b.id=e.benchmark_id "
+                       "WHERE e.run_id=? AND e.status='completed' ORDER BY e.step", (run["id"],))
+    by_b = defaultdict(list)
+    for e in evals:
+        by_b[e["benchmark_id"]].append(e)
+    eval_lines = []
+    for bid, es in by_b.items():
+        eval_lines.append({"benchmark_id": bid, "name": es[0]["name"], "metric": es[0]["metric"], "first": es[0]["score"], "last": es[-1]["score"],
+                           "first_step": es[0]["step"], "last_step": es[-1]["step"], "stderr": es[-1]["stderr"], "n": len(es)})
+    alerts = 0
+    findings = []
+    if True:
+        by_signal = {s: series(c, run["id"], t) for s, t in sig_tags.items() if s in health.CHECKS}
+        findings = health.check(by_signal, kind=run.get("kind"), simulated=run.get("provenance") == "simulated")
+        alerts = sum(1 for f in findings if f["level"] in ("warn", "bad") and not f.get("simulated"))
+    return {**run, "primary": {"tag": primary, "first": first, "last": last, "points": downsample(pts, 48)},
+            "evals": eval_lines, "alerts": alerts, "findings": findings}
+
+
+# ------------------------------------------------------------------ meta, search
+
+@router.get("/meta")
+def meta(source: str = "demo"):
+    """Every org and project across sources (workspace first); each project says which source holds it."""
+    sources = available_sources()
+    out = {"sources": {k: (k in sources) for k in db.SOURCES}, "source": source, "labels": SOURCE_LABEL, "orgs": [],
+           "open": os.environ.get("POSTTRAIN_OPEN") == "1" and not readonly(), "readonly": readonly()}
+    metas = {}
+    seen = set()
+    for src in sources:
+        try:
+            c = conn_for(src)
+        except HTTPException:
+            continue
+        metas[src] = {r["key"]: r["value"] for r in db.rows(c, "SELECT * FROM meta")}
+        orgs = db.rows(c, "SELECT * FROM orgs ORDER BY name")
+        projects = db.rows(c, "SELECT p.id, p.slug, p.name, p.summary, p.org_id FROM projects p ORDER BY p.name")
+        for o in orgs:
+            ps = [dict(p, source=src) for p in projects if p["org_id"] == o["id"] and (o["slug"], p["slug"]) not in seen]
+            seen.update((o["slug"], p["slug"]) for p in ps)
+            if ps:
+                out["orgs"].append(dict(o, source=src, projects=ps))
+    out["metas"] = metas
+    out["meta"] = metas.get(source) or metas.get("demo") or {}
+    return out
+
+
+@router.get("/projects")
+def projects(source: str = ""):
+    """Every project (across sources unless one is given) with what is running and when it last changed."""
+    out = []
+    for src in ([source] if source else available_sources()):
+        try:
+            out += _projects(conn_for(src), src)
+        except HTTPException:
+            continue
+    return out
+
+
+def _projects(c, src):
+    ps = db.rows(c, "SELECT p.id, p.slug, p.name, p.summary, o.slug AS org_slug, o.name AS org_name FROM projects p JOIN orgs o ON o.id=p.org_id ORDER BY o.name, p.name")
+    for p in ps:
+        pid = p["id"]
+        p["source"] = src
+        r = db.one(c, "SELECT count(*) AS n, sum(status='running') AS running, sum(status='queued') AS queued, sum(status='failed') AS failed, "
+                      "max(coalesce(updated_at, started_at)) AS last, sum(cost_usd) AS cost FROM runs WHERE project_id=?", (pid,))
+        p.update({"runs": r["n"], "running": r["running"] or 0, "queued": r["queued"] or 0, "failed": r["failed"] or 0,
+                  "last": r["last"], "cost": r["cost"]})
+        p["kinds"] = [x["kind"] for x in db.rows(c, "SELECT DISTINCT kind FROM runs WHERE project_id=?", (pid,))]
+        p["benchmarks"] = c.execute("SELECT count(*) FROM benchmarks WHERE project_id=?", (pid,)).fetchone()[0]
+        p["environments"] = c.execute("SELECT count(*) FROM environments WHERE project_id=?", (pid,)).fetchone()[0]
+        p["datasets"] = c.execute("SELECT count(*) FROM datasets WHERE project_id=?", (pid,)).fetchone()[0]
+        p["models"] = [m["name"] for m in db.rows(c, "SELECT name FROM models WHERE project_id=? AND status='released' ORDER BY created_at DESC LIMIT 3", (pid,))]
+        p["example"] = src != "workspace"
+        if src == "workspace":
+            st = S.get_settings(c, pid)
+            p.update(base_model=st["base_model"], stages=st["stages"], budget_usd=st["budget_usd"])
+    return ps
+
+
+@router.get("/search")
+def search(q: str, source: str = "demo", org: str = "", project: str = ""):
+    c = conn_for(source)
+    like = f"%{q.lower()}%"
+    out = []
+    scope = ""
+    args = []
+    if org and project:
+        p = project_or_404(c, org, project)
+        scope = " AND project_id=?"
+        args = [p["id"]]
+    for kind, sql in (
+            ("run", "SELECT id, name, project_id, kind AS sub FROM runs WHERE lower(name) LIKE ?"),
+            ("eval", "SELECT id, name, project_id, category AS sub FROM benchmarks WHERE lower(name) LIKE ?"),
+            ("environment", "SELECT id, name, project_id, domain AS sub FROM environments WHERE lower(name) LIKE ?"),
+            ("dataset", "SELECT id, name, project_id, kind AS sub FROM datasets WHERE lower(name) LIKE ?"),
+            ("model", "SELECT id, name, project_id, stage AS sub FROM models WHERE lower(name) LIKE ?")):
+        out += [dict(r, type=kind) for r in db.rows(c, sql + scope + " LIMIT 8", [like] + args)]
+    tasks = db.rows(c, "SELECT t.id, t.name, e.project_id, e.name AS sub, e.id AS env_id FROM tasks t JOIN environments e ON e.id=t.env_id "
+                       "WHERE lower(t.name) LIKE ?" + (" AND e.project_id=?" if args else "") + " LIMIT 8", [like] + args)
+    out += [dict(t, type="task") for t in tasks]
+    events = db.rows(c, "SELECT ev.rowid AS id, ev.title AS name, ev.body, ev.kind, ev.step, ev.t, ev.run_id, r.name AS sub, r.project_id "
+                        "FROM run_events ev JOIN runs r ON r.id=ev.run_id WHERE (lower(ev.title) LIKE ? OR lower(ev.body) LIKE ?)"
+                        + (" AND r.project_id=?" if args else "") + " ORDER BY ev.t DESC LIMIT 8", [like, like] + args)
+    out += [dict(e, type="event") for e in events]
+    projects = {p["id"]: p for p in db.rows(c, "SELECT p.id, p.slug, o.slug AS org_slug FROM projects p JOIN orgs o ON o.id=p.org_id")}
+    for r in out:
+        p = projects.get(r["project_id"])
+        if p:
+            r["org"], r["project"] = p["org_slug"], p["slug"]
+    return out
+
+
+# ------------------------------------------------------------------ project overview
+
+@router.get("/p/{org}/{project}/overview")
+def overview(org: str, project: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    pid = p["id"]
+    runs = db.rows(c, "SELECT * FROM runs WHERE project_id=? ORDER BY coalesce(updated_at, started_at) DESC", (pid,))
+    sig = {}
+    summaries = []
+    for r in runs:
+        summaries.append(run_summary(c, r))
+    counts = {k: c.execute(f"SELECT count(*) FROM {t} WHERE project_id=?", (pid,)).fetchone()[0] for k, t in
+              (("datasets", "datasets"), ("environments", "environments"), ("models", "models"),
+               ("benchmarks", "benchmarks"), ("evals", "evals"), ("reports", "reports"))}
+    counts["tasks"] = c.execute("SELECT count(*) FROM tasks t JOIN environments e ON e.id=t.env_id WHERE e.project_id=?", (pid,)).fetchone()[0]
+    counts["runs"] = len(runs)
+    events = db.rows(c, "SELECT ev.*, r.name AS run_name FROM run_events ev JOIN runs r ON r.id=ev.run_id WHERE r.project_id=? "
+                        "AND ev.kind NOT IN ('checkpoint') ORDER BY ev.t DESC LIMIT 14", (pid,))
+    attention = []
+    simulated_warnings = 0
+    for s in summaries:
+        for f in s["findings"]:
+            if f["level"] in ("warn", "bad"):
+                if f.get("simulated"):
+                    simulated_warnings += 1   # shown on the run page, labelled; not a finding about real data
+                    continue
+                attention.append({"run_id": s["id"], "run_name": s["name"], **f})
+    flagged = db.rows(c, "SELECT t.status, count(*) AS n, count(DISTINCT t.env_id) AS envs FROM tasks t JOIN environments e ON e.id=t.env_id "
+                         "WHERE e.project_id=? AND t.status NOT IN ('ok', 'too_easy', 'too_hard') GROUP BY t.status ORDER BY n DESC", (pid,))
+    if flagged:
+        parts = [f"{r['n']:,} {r['status'].replace('_', ' ')}" for r in flagged]
+        envs = max(r["envs"] for r in flagged)
+        attention.append({"level": "warn", "area": "Task validation", "link": "/environments",
+                          "message": f"{', '.join(parts)} task{'s' if sum(r['n'] for r in flagged) != 1 else ''} across {envs} environment{'s' if envs != 1 else ''}; runs skip them."})
+    usage = db.one(c, "SELECT sum(cost_usd) AS total FROM usage WHERE project_id=?", (pid,))
+    evals = eval_matrix(c, pid, limit_models=6)
+    lineage = model_chains(c, pid)
+    return {"project": p, "counts": counts, "runs": summaries, "events": events, "attention": attention[:12],
+            "simulated_warnings": simulated_warnings,
+            "evals": evals, "spend": usage["total"] if usage else None, "lineage": lineage, "settings": S.get_settings(c, pid)}
+
+
+def rules(fn):
+    """Answer viewer/stages.py Problems (unknown model, bad suite...) as HTTP errors."""
+    try:
+        return fn()
+    except S.Problem as e:
+        raise HTTPException(e.status, str(e))
+
+
+@router.get("/p/{org}/{project}/stages")
+def stage_table(org: str, project: str, source: str = "workspace"):
+    """The Stages table (PRD 4, 6.3): for data, environments, sft, preference, rl, eval and deploy, the status (not_started,
+    in_progress, blocked, done, skipped), the "done when" rule and the evidence for it, what exists, what blocks it, and
+    the next action as a website hint (label, kind, arg) and a CLI line (next.command). `posttrain status` prints it.
+    Served here, ahead of api_ui's older approximation of the same path."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    comp = api_ui.compute_state(org) if source == "workspace" else {"targets": [], "runners": []}
+    return rules(lambda: S.stage_table(c, org, project, p, source, comp))
+
+
+@router.get("/p/{org}/{project}/settings")
+def project_settings(org: str, project: str, source: str = "workspace"):
+    """Base model, planned stages, budget, suites and aliases of a project (defaults when never set)."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    return api_write.settings_response(c, org, project, p)
+
+
+@router.get("/p/{org}/{project}/suites")
+def suites(org: str, project: str, source: str = "workspace"):
+    """The project's suites; quick and release always exist, and release equals quick until it is defined."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    return S.suites_response(c, org, project, p["id"])
+
+
+def model_chains(c, pid, limit=4):
+    """The longest base → … → final model chains, each node with the run that produced it."""
+    ms = db.rows(c, "SELECT id, name, kind, stage, parent_id, run_id, status, params_total, params_active FROM models WHERE project_id=? AND kind != 'external'", (pid,))
+    by = {m["id"]: m for m in ms}
+    runs = {r["id"]: r for r in db.rows(c, "SELECT id, name, status, kind, stage, algorithm, output_model_id FROM runs WHERE project_id=?", (pid,))}
+    made_by = {r["output_model_id"]: r for r in runs.values() if r.get("output_model_id")}
+    kids = defaultdict(list)
+    for m in ms:
+        if m["parent_id"] in by:
+            kids[m["parent_id"]].append(m["id"])
+    chains = []
+    for m in ms:
+        if kids.get(m["id"]):
+            continue
+        chain, cur, seen = [], m, set()
+        while cur and cur["id"] not in seen:
+            seen.add(cur["id"])
+            run = runs.get(cur["run_id"]) or made_by.get(cur["id"])
+            chain.append({"model_id": cur["id"], "name": cur["name"], "kind": cur["kind"], "stage": cur["stage"] or (run or {}).get("stage"),
+                          "status": cur["status"], "run": {k: run[k] for k in ("id", "name", "status", "kind", "algorithm")} if run else None})
+            cur = by.get(cur["parent_id"])
+        chains.append(list(reversed(chain)))
+    chains = [ch for ch in chains if len(ch) >= 2]
+    chains.sort(key=lambda ch: -len(ch))
+    return chains[:limit]
+
+
+# ------------------------------------------------------------------ runs
+
+@router.get("/p/{org}/{project}/runs")
+def runs_list(org: str, project: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    runs = db.rows(c, "SELECT * FROM runs WHERE project_id=? ORDER BY coalesce(started_at, 0) DESC", (p["id"],))
+    names = model_names(c, [r["base_model_id"] for r in runs] + [r["output_model_id"] for r in runs])
+    out = []
+    for r in runs:
+        s = run_summary(c, r)
+        s["base_model"] = names.get(r["base_model_id"])
+        s["output_model"] = names.get(r["output_model_id"])
+        s.pop("config", None)
+        out.append(s)
+    return out
+
+
+@router.get("/p/{org}/{project}/runs/{run_id}")
+def run_detail(org: str, project: str, run_id: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    run = db.one(c, "SELECT * FROM runs WHERE id=? AND project_id=?", (run_id, p["id"]))
+    if not run:
+        raise HTTPException(404, "No such run.")
+    sig_tags = signal_tags(c, p["id"], run_id)
+    summary = run_summary(c, run, sig_tags)
+    names = model_names(c, [run["base_model_id"], run["output_model_id"]])
+    inputs = db.rows(c, "SELECT * FROM run_inputs WHERE run_id=?", (run_id,))
+    envs = {e["id"]: e for e in db.rows(c, "SELECT id, name, domain, reward_kind, task_count FROM environments WHERE project_id=?", (p["id"],))}
+    dss = {d["id"]: d for d in db.rows(c, "SELECT id, name, kind, rows, tokens FROM datasets WHERE project_id=?", (p["id"],))}
+    for i in inputs:
+        i["ref"] = envs.get(i["ref_id"]) if i["kind"] == "environment" else dss.get(i["ref_id"])
+    steps = db.rows(c, "SELECT * FROM run_steps WHERE run_id=? ORDER BY step", (run_id,))
+    events = db.rows(c, "SELECT rowid AS eid, * FROM run_events WHERE run_id=? ORDER BY t", (run_id,))
+    ckpts = db.rows(c, "SELECT * FROM checkpoints WHERE run_id=? ORDER BY step", (run_id,))
+    evals = db.rows(c, "SELECT e.id, e.benchmark_id, e.step, e.score, e.stderr, e.n_tasks, e.k, e.status, b.name AS benchmark, b.metric "
+                       "FROM evals e JOIN benchmarks b ON b.id=e.benchmark_id WHERE e.run_id=? ORDER BY b.name, e.step", (run_id,))
+    # health signals with their series
+    vitals = []
+    for signal in ("reward", "pass_rate", "loss", "val_loss", "reward_margin", "pref_accuracy", "entropy", "grad_norm", "train_infer_kl",
+                   "kl_ref", "clip_frac", "response_len", "truncation_rate", "turns", "all_fail_share", "all_pass_share",
+                   "mixed_share", "infra_error_rate", "timeout_rate", "staleness", "step_time", "gen_time", "throughput",
+                   "active_sandboxes", "lr"):
+        tag = sig_tags.get(signal)
+        if not tag:
+            continue
+        pts = series(c, run_id, tag)
+        if not pts:
+            continue
+        label, unit, fmt, better, grp, desc = sigdefs.SIGNALS[signal]
+        d = db.one(c, "SELECT description, format FROM metric_defs WHERE project_id=? AND tag=?", (p["id"], tag)) or {}
+        vitals.append({"signal": signal, "tag": tag, "label": label, "unit": unit, "format": fmt,
+                       "better": better, "group": grp, "description": d.get("description") or desc,
+                       "points": downsample(pts, 400)})
+    # per-environment breakdown
+    breakdown = []
+    for sgn, tag in sig_tags.items():
+        m = re.match(r"env_(pass_rate|share|infra|accepted)@(.+)", sgn)
+        if not m:
+            continue
+        kind, env_id = m.groups()
+        pts = series(c, run_id, tag)
+        row = next((b for b in breakdown if b["env_id"] == env_id), None)
+        if row is None:
+            e = envs.get(env_id) or {}
+            row = {"env_id": env_id, "name": e.get("name"), "domain": e.get("domain")}
+            breakdown.append(row)
+        row[kind] = downsample(pts, 120)
+    stored = c.execute("SELECT count(*) FROM rollouts WHERE run_id=? AND phase='train'", (run_id,)).fetchone()[0]
+    reports = [r for r in db.rows(c, "SELECT id, title, author, created_at, claims, run_ids FROM reports WHERE project_id=?", (p["id"],))
+               if run_id in (r.get("run_ids") or [])]
+    return {**summary, "project": p, "reports": reports, "base_model": names.get(run["base_model_id"]),
+            "output_model": names.get(run["output_model_id"]), "inputs": inputs, "steps": steps, "events": events,
+            "checkpoints": ckpts, "eval_points": evals, "vitals": vitals, "breakdown": breakdown,
+            "rollouts_stored": stored}
+
+
+@router.get("/p/{org}/{project}/runs/{run_id}/tags")
+def run_tags(org: str, project: str, run_id: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    tags = db.rows(c, "SELECT m.tag, count(*) AS n, d.label, d.description, d.format, d.grp, d.pinned, d.signal, d.better "
+                      "FROM metrics m LEFT JOIN metric_defs d ON d.project_id=? AND d.tag=m.tag WHERE m.run_id=? GROUP BY m.tag ORDER BY m.tag",
+                   (p["id"], run_id))
+    return tags
+
+
+@router.get("/p/{org}/{project}/metrics")
+def metrics(org: str, project: str, runs: str, tags: str, source: str = "demo", points: int = 400):
+    c = conn_for(source)
+    project_or_404(c, org, project)
+    out = {}
+    for run_id in runs.split(","):
+        out[run_id] = {t: downsample(series(c, run_id, t), points) for t in tags.split(",") if t}
+    return out
+
+
+@router.get("/p/{org}/{project}/runs/{run_id}/rollouts")
+def run_rollouts(org: str, project: str, run_id: str, source: str = "demo", step: int = None, env: str = "",
+                 outcome: str = "", q: str = "", limit: int = 400):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    where, args = ["r.run_id=?", "r.phase='train'"], [run_id]
+    if step is not None:
+        where.append("r.step=?")
+        args.append(step)
+    if env:
+        where.append("r.env_id=?")
+        args.append(env)
+    if outcome:
+        where.append("r.outcome=?")
+        args.append(outcome)
+    if q:
+        where.append("(lower(t.name) LIKE ? OR lower(t.instruction) LIKE ?)")
+        args += [f"%{q.lower()}%"] * 2
+    rows = db.rows(c, f"SELECT r.id, r.step, r.group_id, r.sample, r.task_id, r.env_id, r.harness, r.reward, r.advantage, r.outcome, "
+                      f"r.stop_reason, r.turns, r.tool_calls, r.tokens_in, r.tokens_out, r.tokens_cached, r.duration_s, r.staleness, r.trained, "
+                      f"t.name AS task, e.name AS env, e.reward_kind FROM rollouts r LEFT JOIN tasks t ON t.id=r.task_id LEFT JOIN environments e ON e.id=r.env_id "
+                      f"WHERE {' AND '.join(where)} ORDER BY r.step, r.group_id, r.sample LIMIT ?", args + [limit])
+    return rows
+
+
+@router.get("/p/{org}/{project}/runs/{run_id}/steps/{step}")
+def run_step(org: str, project: str, run_id: str, step: int, source: str = "demo"):
+    """One step's stored groups: each group with its task and every attempt."""
+    c = conn_for(source)
+    project_or_404(c, org, project)
+    rows = db.rows(c, "SELECT r.*, t.name AS task, t.instruction, e.name AS env, e.domain, e.reward_kind FROM rollouts r LEFT JOIN tasks t ON t.id=r.task_id "
+                      "LEFT JOIN environments e ON e.id=r.env_id WHERE r.run_id=? AND r.step=? AND r.phase='train' ORDER BY r.group_id, r.sample",
+                   (run_id, step))
+    groups = {}
+    for r in rows:
+        g = groups.setdefault(r["group_id"], {"group_id": r["group_id"], "task": r["task"], "task_id": r["task_id"],
+                                              "env": r["env"], "env_id": r["env_id"], "domain": r["domain"], "reward_kind": r["reward_kind"],
+                                              "attempts": []})
+        g["attempts"].append({k: r[k] for k in ("id", "sample", "reward", "advantage", "outcome", "stop_reason", "turns",
+                                                "tool_calls", "tokens_in", "tokens_out", "duration_s", "harness", "trained")})
+    return list(groups.values())
+
+
+@router.get("/rollouts/{rollout_id}")
+def rollout(rollout_id: str, source: str = "demo"):
+    c = conn_for(source)
+    r = db.one(c, "SELECT * FROM rollouts WHERE id=?", (rollout_id,))
+    if not r:
+        raise HTTPException(404, "No such rollout.")
+    task = db.one(c, "SELECT * FROM tasks WHERE id=?", (r["task_id"],)) or {}
+    env = db.one(c, "SELECT * FROM environments WHERE id=?", (r["env_id"],)) if r.get("env_id") else None
+    env = env or {}
+    grader = db.one(c, "SELECT * FROM graders WHERE id=?", (env.get("grader_id"),)) if env else None
+    siblings = db.rows(c, "SELECT id, sample, reward, advantage, outcome, turns FROM rollouts WHERE group_id=? ORDER BY sample", (r["group_id"],))
+    run = db.one(c, "SELECT id, name, project_id, framework, algorithm FROM runs WHERE id=?", (r["run_id"],)) if r["run_id"] else None
+    ev = db.one(c, "SELECT e.id, b.name AS benchmark, e.project_id FROM evals e JOIN benchmarks b ON b.id=e.benchmark_id WHERE e.id=?", (r["eval_id"],)) if r["eval_id"] else None
+    model = db.one(c, "SELECT id, name FROM models WHERE id=?", (r["model_id"],)) if r["model_id"] else None
+    stored = db.one(c, "SELECT messages FROM transcripts WHERE rollout_id=?", (rollout_id,))
+    if stored:
+        messages = json.loads(stored["messages"])
+        synthetic = False
+    else:
+        messages = render.transcript(r, task, env)
+        synthetic = True
+    scores = r.get("scores") or render.scores(r, env, grader)
+    return {"rollout": r, "task": task, "env": env, "grader": grader, "siblings": siblings, "run": run, "eval": ev,
+            "model": model, "messages": messages, "rendered": synthetic, "scores": scores}
+
+
+# ------------------------------------------------------------------ evals
+
+def eval_matrix(c, pid, limit_models=None):
+    benches = db.rows(c, "SELECT * FROM benchmarks WHERE project_id=? ORDER BY category, name", (pid,))
+    evals = db.rows(c, "SELECT e.*, m.name AS model_name, r.name AS run_name FROM evals e LEFT JOIN models m ON m.id=e.model_id "
+                       "LEFT JOIN runs r ON r.id=e.run_id WHERE e.project_id=? ORDER BY e.started_at", (pid,))
+    # columns: one per (model or run@final step); prefer latest step per run
+    cols = {}
+    for e in evals:
+        key = e["run_id"] and f"run:{e['run_id']}" or f"model:{e['model_id']}"
+        col = cols.setdefault(key, {"key": key, "label": e["run_name"] or e["model_name"], "run_id": e["run_id"],
+                                    "model_id": e["model_id"], "cells": {}, "t": 0})
+        cell = col["cells"].get(e["benchmark_id"])
+        if e["status"] == "completed" and (cell is None or (e["step"] or 0) >= (cell["step"] or 0)):
+            col["cells"][e["benchmark_id"]] = {"eval_id": e["id"], "score": e["score"], "stderr": e["stderr"], "step": e["step"],
+                                               "first": (cell or {}).get("first", e["score"]) if cell else e["score"],
+                                               "first_step": (cell or {}).get("first_step", e["step"]) if cell else e["step"]}
+        col["t"] = max(col["t"], e["started_at"] or 0)
+    columns = sorted(cols.values(), key=lambda x: -x["t"])
+    if limit_models:
+        columns = columns[:limit_models]
+    return {"benchmarks": benches, "columns": columns}
+
+
+@router.get("/p/{org}/{project}/evals")
+def evals_page(org: str, project: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    matrix = eval_matrix(c, p["id"])
+    curves = defaultdict(lambda: defaultdict(list))
+    for e in db.rows(c, "SELECT benchmark_id, run_id, step, score, stderr, id FROM evals WHERE project_id=? AND run_id IS NOT NULL "
+                        "AND status='completed' ORDER BY step", (p["id"],)):
+        curves[e["benchmark_id"]][e["run_id"]].append([e["step"], e["score"], e["stderr"], e["id"]])
+    runs = {r["id"]: r["name"] for r in db.rows(c, "SELECT id, name FROM runs WHERE project_id=?", (p["id"],))}
+    evals = db.rows(c, "SELECT e.id, e.benchmark_id, e.model_id, e.run_id, e.step, e.status, e.score, e.stderr, e.n_tasks, e.k, e.n_infra, "
+                       "e.started_at, e.ended_at, e.cost_usd, e.provenance, b.name AS benchmark, b.metric, m.name AS model_name, r.name AS run_name "
+                       "FROM evals e JOIN benchmarks b ON b.id=e.benchmark_id LEFT JOIN models m ON m.id=e.model_id LEFT JOIN runs r ON r.id=e.run_id "
+                       "WHERE e.project_id=? ORDER BY e.started_at DESC", (p["id"],))
+    return {**matrix, "curves": {b: dict(v) for b, v in curves.items()}, "run_names": runs, "evals": evals}
+
+
+@router.get("/p/{org}/{project}/evals/compare")
+def evals_compare(org: str, project: str, a: str = "", b: str = "", models: str = "", suite: str = "", bench: str = "",
+                  source: str = "workspace"):
+    """B against A, benchmark by benchmark (PRD 4.6): `?a=EVAL&b=EVAL`, or `?models=A,B&suite=NAME` (or `&bench=B1,B2`).
+    Each benchmark has a.score/stderr, b.score/stderr, delta, se_diff (paired over tasks when both have per-task
+    results), verdict (improved | regressed | within_noise | unknown | missing), gained/lost/still_solved/
+    still_unsolved with the task names, and the acknowledgement of a regression."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    return rules(lambda: S.comparison(c, p["id"], org, project, a=a or None, b=b or None, models=models or None,
+                                      suite=suite or None, bench=bench or None))
+
+
+@router.get("/p/{org}/{project}/acks")
+def acks(org: str, project: str, model: str = "", suite: str = "", source: str = "workspace"):
+    """Acknowledged regressions, newest first (optionally for one model or suite)."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    return rules(lambda: S.list_acks(c, p["id"], org, project, model or None, suite or None))
+
+
+@router.get("/p/{org}/{project}/evals/{eval_id}")
+def eval_detail(org: str, project: str, eval_id: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    e = db.one(c, "SELECT e.*, m.name AS model_name, r.name AS run_name FROM evals e LEFT JOIN models m ON m.id=e.model_id "
+                  "LEFT JOIN runs r ON r.id=e.run_id WHERE e.id=? AND e.project_id=?", (eval_id, p["id"]))
+    if not e:
+        raise HTTPException(404, "No such eval.")
+    b = db.one(c, "SELECT * FROM benchmarks WHERE id=?", (e["benchmark_id"],))
+    tasks = db.rows(c, "SELECT * FROM eval_tasks WHERE eval_id=? ORDER BY task_name", (eval_id,))
+    siblings = db.rows(c, "SELECT e.id, e.step, e.score, e.stderr, e.run_id, e.model_id, m.name AS model_name, r.name AS run_name "
+                          "FROM evals e LEFT JOIN models m ON m.id=e.model_id LEFT JOIN runs r ON r.id=e.run_id "
+                          "WHERE e.benchmark_id=? AND e.status='completed' ORDER BY e.started_at", (e["benchmark_id"],))
+    rollouts = db.rows(c, "SELECT r.id, r.task_id, r.sample, r.reward, r.outcome, r.turns, r.tokens_out, r.duration_s, t.name AS task "
+                          "FROM rollouts r LEFT JOIN tasks t ON t.id=r.task_id WHERE r.eval_id=? ORDER BY t.name, r.sample", (eval_id,))
+    hist = [0] * (b["k"] + 1) if b and b["k"] else []
+    for t in tasks:
+        if hist:
+            hist[t["passes"]] += 1
+    return {"eval": e, "benchmark": b, "tasks": tasks, "siblings": siblings, "rollouts": rollouts, "histogram": hist}
+
+
+@router.get("/p/{org}/{project}/compare")
+def compare(org: str, project: str, a: str, b: str, source: str = "demo"):
+    c = conn_for(source)
+    project_or_404(c, org, project)
+    ea = eval_detail(org, project, a, source)
+    eb = eval_detail(org, project, b, source)
+    ta = {t["task_name"]: t for t in ea["tasks"]}
+    tb = {t["task_name"]: t for t in eb["tasks"]}
+    rows = []
+    for name in sorted(set(ta) | set(tb)):
+        x, y = ta.get(name), tb.get(name)
+        sa = x["score"] if x else None
+        sb = y["score"] if y else None
+        rows.append({"task": name, "a": sa, "b": sb, "delta": None if sa is None or sb is None else round(sb - sa, 4)})
+    stats = S.compare(ea["eval"], eb["eval"], ea["tasks"], eb["tasks"])
+    return {"a": ea["eval"], "b": eb["eval"], "benchmark": ea["benchmark"], "rows": rows, **stats}
+
+
+# ------------------------------------------------------------------ environments & tasks
+
+@router.get("/p/{org}/{project}/environments")
+def environments(org: str, project: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    envs = db.rows(c, "SELECT e.*, g.name AS grader_name, g.kind AS grader_kind FROM environments e LEFT JOIN graders g ON g.id=e.grader_id "
+                      "WHERE e.project_id=? ORDER BY e.domain, e.name", (p["id"],))
+    stats = {r["env_id"]: r for r in db.rows(c, "SELECT env_id, count(*) AS n, avg(base_pass) AS base, avg(latest_pass) AS latest, "
+                                                "sum(status!='ok') AS flagged, sum(base_pass<0.02) AS hard, sum(base_pass>0.98) AS easy, "
+                                                "sum(latest_pass<0.02) AS hard_now, sum(latest_pass>0.98) AS easy_now "
+                                                "FROM tasks WHERE env_id IN (SELECT id FROM environments WHERE project_id=?) GROUP BY env_id", (p["id"],))}
+    used = defaultdict(list)
+    for r in db.rows(c, "SELECT ri.ref_id, r.id, r.name, r.status FROM run_inputs ri JOIN runs r ON r.id=ri.run_id WHERE ri.kind='environment' AND r.project_id=?", (p["id"],)):
+        used[r["ref_id"]].append({"id": r["id"], "name": r["name"], "status": r["status"]})
+    infra = {r["env_id"]: r for r in db.rows(c, "SELECT env_id, count(*) AS n, sum(outcome='infra_error') AS infra, avg(duration_s) AS secs, avg(turns) AS turns "
+                                                "FROM rollouts WHERE env_id IN (SELECT id FROM environments WHERE project_id=?) GROUP BY env_id", (p["id"],))}
+    for e in envs:
+        e["stats"] = stats.get(e["id"], {})
+        e["runs"] = used.get(e["id"], [])
+        e["rollouts"] = infra.get(e["id"], {})
+    return envs
+
+
+@router.get("/p/{org}/{project}/harnesses")
+def harnesses(org: str, project: str, source: str = "demo"):
+    """Agent loops the rollouts ran in, with outcomes per harness."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    rows = db.rows(c, "SELECT r.harness, count(*) AS n, sum(r.outcome='passed') AS passed, sum(r.reward IS NOT NULL) AS scored, "
+                      "sum(r.outcome='infra_error') AS infra, sum(r.outcome IN ('timeout','max_turns','truncated')) AS limits, "
+                      "avg(r.turns) AS turns, avg(r.tokens_out) AS tokens_out, avg(r.duration_s) AS secs, count(DISTINCT r.env_id) AS envs, "
+                      "count(DISTINCT r.run_id) AS runs FROM rollouts r JOIN environments e ON e.id=r.env_id WHERE e.project_id=? "
+                      "AND r.harness IS NOT NULL AND r.harness != '' GROUP BY r.harness ORDER BY n DESC", (p["id"],))
+    return rows
+
+
+@router.get("/p/{org}/{project}/environments/{env_id}")
+def environment(org: str, project: str, env_id: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    e = db.one(c, "SELECT * FROM environments WHERE id=? AND project_id=?", (env_id, p["id"]))
+    if not e:
+        raise HTTPException(404, "No such environment.")
+    grader = db.one(c, "SELECT * FROM graders WHERE id=?", (e["grader_id"],))
+    tasks = db.rows(c, "SELECT * FROM tasks WHERE env_id=? ORDER BY name", (env_id,))
+    status_counts = defaultdict(int)
+    for t in tasks:
+        status_counts[t["status"]] += 1
+
+    def hist(key):
+        h = [0] * 10
+        for t in tasks:
+            v = t.get(key)
+            if v is not None:
+                h[min(9, int(v * 10))] += 1
+        return h
+    runs = db.rows(c, "SELECT r.id, r.name, r.status, r.kind, ri.weight FROM run_inputs ri JOIN runs r ON r.id=ri.run_id WHERE ri.ref_id=?", (env_id,))
+    for r in runs:
+        tag = next((d["tag"] for d in db.rows(c, "SELECT tag FROM metric_defs WHERE project_id=? AND signal=?", (p["id"], f"env_pass_rate@{env_id}"))), None)
+        r["pass_rate"] = downsample(series(c, r["id"], tag), 120) if tag else []
+    sample = db.rows(c, "SELECT r.id, r.run_id, r.eval_id, r.step, r.reward, r.outcome, r.turns, r.duration_s, t.name AS task FROM rollouts r "
+                        "LEFT JOIN tasks t ON t.id=r.task_id WHERE r.env_id=? ORDER BY r.step DESC LIMIT 40", (env_id,))
+    outcomes = db.rows(c, "SELECT outcome, count(*) AS n FROM rollouts WHERE env_id=? GROUP BY outcome ORDER BY n DESC", (env_id,))
+    return {"environment": e, "grader": grader, "tasks": tasks, "status_counts": status_counts,
+            "hist_base": hist("base_pass"), "hist_latest": hist("latest_pass"), "runs": runs, "rollouts": sample,
+            "outcomes": outcomes}
+
+
+@router.get("/p/{org}/{project}/tasks/{task_id}")
+def task_detail(org: str, project: str, task_id: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    t = db.one(c, "SELECT * FROM tasks WHERE id=?", (task_id,))
+    if not t:
+        raise HTTPException(404, "No such task.")
+    env = db.one(c, "SELECT * FROM environments WHERE id=? AND project_id=?", (t["env_id"], p["id"]))
+    if not env:
+        raise HTTPException(404, "No such task in this project.")
+    grader = db.one(c, "SELECT * FROM graders WHERE id=?", (env["grader_id"],))
+    rolls = db.rows(c, "SELECT r.id, r.run_id, r.eval_id, r.step, r.phase, r.group_id, r.sample, r.reward, r.advantage, r.outcome, r.turns, "
+                       "r.tokens_out, r.duration_s, r.model_id, ru.name AS run_name FROM rollouts r LEFT JOIN runs ru ON ru.id=r.run_id "
+                       "WHERE r.task_id=? ORDER BY r.run_id, r.step, r.sample", (task_id,))
+    groups = {}
+    for r in rolls:
+        g = groups.setdefault(r["group_id"], {"group_id": r["group_id"], "run_id": r["run_id"], "run_name": r["run_name"],
+                                              "eval_id": r["eval_id"], "step": r["step"], "phase": r["phase"], "attempts": []})
+        g["attempts"].append(r)
+    return {"task": t, "environment": env, "grader": grader, "groups": list(groups.values())}
+
+
+# ------------------------------------------------------------------ datasets, models, ops
+
+@router.get("/p/{org}/{project}/datasets")
+def datasets(org: str, project: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    ds = db.rows(c, "SELECT * FROM datasets WHERE project_id=? ORDER BY kind, name", (p["id"],))
+    srcs = defaultdict(list)
+    for s in db.rows(c, "SELECT * FROM dataset_sources WHERE dataset_id IN (SELECT id FROM datasets WHERE project_id=?)", (p["id"],)):
+        srcs[s["dataset_id"]].append(s)
+    used = defaultdict(list)
+    for r in db.rows(c, "SELECT ri.ref_id, r.id, r.name FROM run_inputs ri JOIN runs r ON r.id=ri.run_id WHERE ri.kind='dataset' AND r.project_id=?", (p["id"],)):
+        used[r["ref_id"]].append({"id": r["id"], "name": r["name"]})
+    for d in ds:
+        d["sources"] = srcs.get(d["id"], [])
+        d["runs"] = used.get(d["id"], [])
+    return ds
+
+
+@router.get("/p/{org}/{project}/datasets/{ds_id}")
+def dataset(org: str, project: str, ds_id: str, source: str = "demo", offset: int = 0, limit: int = 50):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    d = db.one(c, "SELECT * FROM datasets WHERE id=? AND project_id=?", (ds_id, p["id"]))
+    if not d:
+        raise HTTPException(404, "No such dataset.")
+    d["sources"] = db.rows(c, "SELECT * FROM dataset_sources WHERE dataset_id=? ORDER BY rows DESC", (ds_id,))
+    rows = db.rows(c, "SELECT * FROM dataset_rows WHERE dataset_id=? ORDER BY idx LIMIT ? OFFSET ?", (ds_id, limit, offset))
+    runs = db.rows(c, "SELECT r.id, r.name, r.kind, r.status, ri.weight FROM run_inputs ri JOIN runs r ON r.id=ri.run_id WHERE ri.ref_id=?", (ds_id,))
+    versions = db.rows(c, "SELECT id, name, version, rows, tokens, created_at FROM datasets WHERE project_id=? AND (id=? OR parent_id=? OR id=?)",
+                       (p["id"], d["parent_id"], ds_id, ds_id))
+    return {"dataset": d, "rows": rows, "runs": runs, "versions": versions,
+            "row_count": c.execute("SELECT count(*) FROM dataset_rows WHERE dataset_id=?", (ds_id,)).fetchone()[0]}
+
+
+@router.get("/p/{org}/{project}/models")
+def models(org: str, project: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    ms = db.rows(c, "SELECT * FROM models WHERE project_id=? ORDER BY created_at", (p["id"],))
+    runs = {r["id"]: r for r in db.rows(c, "SELECT id, name, kind, stage, algorithm, status, base_model_id, output_model_id FROM runs WHERE project_id=?", (p["id"],))}
+    best = defaultdict(list)
+    for e in db.rows(c, "SELECT e.model_id, e.benchmark_id, b.name, b.metric, e.score, e.stderr, e.id, e.step FROM evals e JOIN benchmarks b ON b.id=e.benchmark_id "
+                        "WHERE e.project_id=? AND e.status='completed' AND e.model_id IS NOT NULL ORDER BY coalesce(e.step, 1e9)", (p["id"],)):
+        lst = best[e["model_id"]]
+        lst[:] = [x for x in lst if x["benchmark_id"] != e["benchmark_id"]] + [e]   # one per benchmark: the latest step
+    deps = db.rows(c, "SELECT * FROM deployments WHERE project_id=?", (p["id"],))
+    ckpts = db.rows(c, "SELECT k.*, r.name AS run_name FROM checkpoints k JOIN runs r ON r.id=k.run_id WHERE r.project_id=? ORDER BY k.created_at DESC LIMIT 200", (p["id"],))
+    promos = {r["model_id"]: r for r in db.rows(c, "SELECT * FROM promotions WHERE project_id=?", (p["id"],))} if S.has_table(c, "promotions") else {}
+    al = S.aliases(c, p["id"])
+    for m in ms:
+        m["evals"] = best.get(m["id"], [])
+        m["run"] = runs.get(m["run_id"])
+        pr = promos.get(m["id"])
+        m["promoted"] = bool(pr) and not pr.get("replaced_by")
+        m["weights"] = (pr.get("pushed_to") or pr.get("weights")) if pr else (f"hf://{m['hf_repo']}" if m.get("hf_repo") else None)
+        m["aliases"] = [a for a, v in al.items() if v["model_id"] == m["id"]]
+    return {"models": ms, "runs": list(runs.values()), "deployments": deps, "checkpoints": ckpts, "aliases": al}
+
+
+@router.get("/p/{org}/{project}/deployments")
+def deployments(org: str, project: str, source: str = "workspace"):
+    """Deployments (vLLM endpoints and Hub pushes), newest first, and where `production` points."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    return {"schema": "posttrain.v1.deployment_list", "id": p["id"], "url": f"/dashboard/{org}/{project}/models",
+            "deployments": S.list_deployments(c, p["id"], org, project), "production": S.aliases(c, p["id"]).get("production")}
+
+
+@router.get("/p/{org}/{project}/deploy-checks")
+def deploy_checks(org: str, project: str, model: str, target: str = "", target_kind: str = "", max_model_len: str = "",
+                  tool_parser: str = "", reasoning_parser: str = "", chat_template_hash: str = "", source: str = "workspace"):
+    """The five blocking deploy checks (PRD 4.7) for `model` on `target` (model.promoted, eval.release_complete,
+    eval.regressions_acked, serving.matches_eval, model.reachable), the serving settings the release evals used (the
+    deploy's defaults; the other query parameters are the deploy's own overrides), where the weights are, and 20
+    smoke-test prompts from the release suite."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    kind = target_kind or ("local" if target == "local" else "")
+    if target and not kind:
+        t = db.one(c, "SELECT kind FROM compute_targets WHERE org_id=? AND name=?", (p["org_id"], target)) if S.has_table(c, "compute_targets") else None
+        kind = t["kind"] if t else ""
+    over = {"max_model_len": int(max_model_len) if str(max_model_len).isdigit() else (max_model_len or None),
+            "tool_parser": tool_parser or None, "reasoning_parser": reasoning_parser or None, "chat_template_hash": chat_template_hash or None}
+    res = rules(lambda: S.deploy_checks(c, p["id"], model, target or None, kind or None, over))
+    prompts, prompt_source = S.smoke_prompts(c, p["id"])
+    return {"schema": "posttrain.v1.deploy_checks", "id": res["model"]["id"] or model, "url": f"/dashboard/{org}/{project}/models",
+            "target": target or None, "target_kind": kind or None, **res, "smoke_prompts": prompts, "smoke_source": prompt_source}
+
+
+@router.get("/p/{org}/{project}/models/{ref:path}")
+def model_show(org: str, project: str, ref: str, source: str = "workspace"):
+    """One model (`posttrain models show`): lineage (parent, run, step), weights location, promotion, aliases, evals
+    and deployments. `ref` is a model name, a Hugging Face id, a run (its output) or RUN:STEP."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    return rules(lambda: S.model_detail(c, p["id"], org, project, ref))
+
+
+@router.get("/p/{org}/{project}/audit")
+def audit_log(org: str, project: str, limit: int = 200, source: str = "workspace"):
+    """Who did what to the project, newest first: settings, suites, skips, promotions, acknowledgements, deployments."""
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    if not S.has_table(c, "audit"):
+        return []
+    return db.rows(c, "SELECT t, user, action, object, detail FROM audit WHERE project_id=? ORDER BY t DESC LIMIT ?", (p["id"], limit))
+
+
+@router.get("/p/{org}/{project}/jobs")
+def jobs(org: str, project: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    return db.rows(c, "SELECT j.*, r.name AS run_name, cl.name AS cluster FROM jobs j LEFT JOIN runs r ON r.id=j.run_id "
+                      "LEFT JOIN clusters cl ON cl.id=j.cluster_id WHERE j.project_id=? ORDER BY j.started_at DESC", (p["id"],))
+
+
+@router.get("/p/{org}/{project}/usage")
+def usage(org: str, project: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    days = db.rows(c, "SELECT day, category, sum(cost_usd) AS cost FROM usage WHERE project_id=? GROUP BY day, category ORDER BY day", (p["id"],))
+    runs = db.rows(c, "SELECT id, name, kind, status, cost_usd, gpus, gpu, started_at, ended_at FROM runs WHERE project_id=? ORDER BY cost_usd DESC", (p["id"],))
+    clusters = db.rows(c, "SELECT * FROM clusters WHERE org_id=?", (p["org_id"],))
+    evals = db.one(c, "SELECT sum(cost_usd) AS cost, count(*) AS n FROM evals WHERE project_id=?", (p["id"],))
+    return {"days": days, "runs": runs, "clusters": clusters, "evals": evals}
+
+
+@router.get("/p/{org}/{project}/reports")
+def reports(org: str, project: str, source: str = "demo"):
+    c = conn_for(source)
+    p = project_or_404(c, org, project)
+    return db.rows(c, "SELECT * FROM reports WHERE project_id=? ORDER BY created_at DESC", (p["id"],))
+
+
+# ------------------------------------------------------------------ static app
+
+def mount_static(app):
+    app.mount(f"{BASE}/static", StaticFiles(directory=STATIC), name="viewer-static")
+
+    @app.get(BASE, include_in_schema=False)
+    @app.get(BASE + "/{path:path}", include_in_schema=False)
+    def spa(path: str = ""):
+        return FileResponse(STATIC / "index.html", headers={"Cache-Control": "no-cache"})
+
+
+def create_app():
+    db.unpack()
+    app = FastAPI(title="PostTrain", docs_url="/api/docs", redoc_url=None)
+    if not readonly():
+        if os.environ.get("POSTTRAIN_SWEEP", "1") == "1":
+            workspace.start_sweeper()
+        app.include_router(api_write.router)
+    app.include_router(router)
+    app.include_router(api_ui.router)
+    mount_static(app)
+
+    @app.get("/", include_in_schema=False)
+    def root():
+        return RedirectResponse(BASE)
+    return app
+
+
+if __name__ == "__main__":
+    import argparse
+    import uvicorn
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--port", type=int, default=7880)
+    ap.add_argument("--host", default="127.0.0.1")
+    a = ap.parse_args()
+    uvicorn.run(create_app(), host=a.host, port=a.port, log_level="warning")
diff --git a/viewer/stages.py b/viewer/stages.py
new file mode 100644
index 0000000000000000000000000000000000000000..c91a6326405570a0de077c6cd16ca0e5d8e3504a
--- /dev/null
+++ b/viewer/stages.py
@@ -0,0 +1,1505 @@
+"""Where a project stands, stage by stage (PRD 4 and 6.3), and the checks that gate promotion, the Eval stage and deploys.
+
+Everything here reads one SQLite connection (PROTOCOL.md tables plus the workspace's own: `project_settings`,
+`suites`, `stage_state`, `acks`, `promotions`, `model_aliases`, `deployments` columns; see workspace.EXTRA) and
+returns plain dictionaries. The read API (server.py) and the write API (api_write.py) call it, so the website and
+the CLI (`posttrain status`, `evals compare`, `models promote`, `models deploy`) use the same rules and words.
+Example sources have none of the workspace tables; they read as empty, and there a run's output model stands in for
+a promoted one (`approx`).
+"""
+import json
+import re
+import shlex
+import time
+from urllib.parse import parse_qsl
+
+from . import db
+from .compare import INFRA_LIMIT, aggregate, compare, eval_config, infra_share, task_scores  # noqa: F401
+
+STAGES = ["data", "environments", "sft", "preference", "rl", "eval", "deploy"]
+LABEL = {"data": "Data", "environments": "Environments", "sft": "SFT", "preference": "Preference", "rl": "RL",
+         "eval": "Eval", "deploy": "Deploy"}
+DONE_WHEN = {
+    "data": "Every dataset a planned stage needs is ready, and the quick and release suites exist.",
+    "environments": "Every environment planned for RL is ready.",
+    "sft": "A model promoted from an SFT run has a quick eval.",
+    "preference": "A model promoted from a preference run has a quick eval.",
+    "rl": "A model promoted from an RL run has a quick eval.",
+    "eval": "A promoted model has a complete release eval, compared with the baseline and the production model, "
+            "and every regression beyond noise is acknowledged.",
+    "deploy": "The model is served and passes its smoke test (or is pushed to the Hub), and production points at it.",
+}
+STATUS_LABEL = {"not_started": "not started", "in_progress": "in progress", "blocked": "blocked", "done": "done",
+                "skipped": "skipped"}
+PLANNABLE = ("sft", "preference", "rl")
+RUN_KIND = {"sft": "sft", "preference": "dpo", "rl": "rl"}
+CLI_STAGE = {"sft": "sft", "preference": "dpo", "rl": "rl"}
+STAGE_ALIASES = {"sft": "sft", "dpo": "preference", "pref": "preference", "preference": "preference", "orpo": "preference",
+                 "rl": "rl", "grpo": "rl", "ppo": "rl"}
+ACTIVE_RUN = {"queued", "starting", "running", "stopping", "stalled"}
+LIVE_DEPLOYMENT = {"healthy", "pushed", "serving"}
+DEFAULT_QUICK = ["ifeval?limit=500", "gsm8k?limit=500", "mmlu_pro?limit=500"]     # PRD 6.2
+SUITE_NAME = re.compile(r"[a-z0-9][a-z0-9_-]{0,39}")
+MODEL_NAME = re.compile(r"[A-Za-z0-9][\w.\-]{0,99}")
+BENCH_NAME = re.compile(r"[A-Za-z0-9_][\w.\-/]*")
+SERVING_KEYS = ("chat_template_hash", "tool_parser", "reasoning_parser", "max_model_len")
+MAX_GATES = 20          # promoted models the Stages table checks against the Eval stage (the newest)
+
+
+class Problem(ValueError):
+    """A request the API answers with an error: `status` is the HTTP code (404 unknown, 409 conflict, 422 invalid)."""
+
+    def __init__(self, status, message):
+        super().__init__(message)
+        self.status = status
+
+
+def now():
+    return time.time()
+
+
+def has_table(conn, name):
+    return bool(conn.execute("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", (name,)).fetchone())
+
+
+def columns(conn, table):
+    return {r[1] for r in conn.execute(f"PRAGMA table_info({table})")}
+
+
+def q(v):
+    """Shell-quote a value for a CLI line; <placeholders> stay as they are."""
+    s = str(v)
+    return s if s.startswith("<") and s.endswith(">") else shlex.quote(s)
+
+
+def slug(name):
+    return re.sub(r"[^a-z0-9]+", "-", str(name or "").lower()).strip("-")[:60] or "model"
+
+
+def project_url(org, project, tail=""):
+    return f"/dashboard/{org}/{project}{tail}"
+
+
+# ------------------------------------------------------------------ settings
+
+def normalize_stages(value):
+    """Planned training stages from ['sft', 'dpo', 'rl'] or 'sft,dpo,rl' ('none' plans none), in PRD order."""
+    if value is None:
+        return None
+    items = value if isinstance(value, (list, tuple)) else re.split(r"[,\s]+", str(value))
+    items = [str(x).strip().lower() for x in items if str(x).strip()]
+    if items in (["none"], ["-"]):
+        return []
+    out = set()
+    for x in items:
+        if x not in STAGE_ALIASES:
+            raise Problem(422, f"unknown stage {x!r}: planned stages are sft, dpo (preference) and rl, or none")
+        out.add(STAGE_ALIASES[x])
+    return [s for s in PLANNABLE if s in out]
+
+
+def base_model_row(conn, pid):
+    return db.one(conn, "SELECT * FROM models WHERE project_id=? AND kind='base' ORDER BY created_at LIMIT 1", (pid,))
+
+
+def get_settings(conn, pid):
+    """The project's settings: base model, planned stages (all three unless set), monthly budget (None: no budget)."""
+    row = db.one(conn, "SELECT * FROM project_settings WHERE project_id=?", (pid,)) if has_table(conn, "project_settings") else None
+    row = row or {}
+    base = row.get("base_model")
+    if not base:
+        m = base_model_row(conn, pid)
+        base = (m.get("hf_repo") or m.get("name")) if m else None
+    stages = row.get("stages")
+    return {"base_model": base, "stages": list(PLANNABLE) if stages is None else list(stages),
+            "stages_set": stages is not None, "budget_usd": row.get("budget_usd"),
+            "updated_at": row.get("updated_at"), "updated_by": row.get("updated_by")}
+
+
+def put_settings(conn, pid, payload, user):
+    """Store the settings present in payload (base_model, stages, budget_usd); returns the keys it changed."""
+    cur = db.one(conn, "SELECT * FROM project_settings WHERE project_id=?", (pid,)) or {}
+    row = {"project_id": pid, "base_model": cur.get("base_model"), "stages": cur.get("stages"),
+           "budget_usd": cur.get("budget_usd"), "updated_at": now(), "updated_by": user}
+    changed = []
+    if payload.get("base_model"):
+        row["base_model"] = str(payload["base_model"]).strip()
+        changed.append("base_model")
+    if payload.get("stages") is not None:
+        row["stages"] = json.dumps(normalize_stages(payload["stages"]))
+        changed.append("stages")
+    elif isinstance(cur.get("stages"), list):
+        row["stages"] = json.dumps(cur["stages"])
+    budget = payload.get("budget_usd", payload.get("budget"))
+    if budget is not None and budget != "":
+        try:
+            row["budget_usd"] = float(budget)
+        except (TypeError, ValueError):
+            raise Problem(422, f"budget must be a number of US dollars, not {budget!r}")
+        if row["budget_usd"] < 0:
+            raise Problem(422, "budget must be 0 or more")
+        changed.append("budget_usd")
+    if changed:
+        conn.execute("INSERT OR REPLACE INTO project_settings (project_id, base_model, stages, budget_usd, updated_at, updated_by) "
+                     "VALUES (?,?,?,?,?,?)", (row["project_id"], row["base_model"], row["stages"], row["budget_usd"],
+                                              row["updated_at"], row["updated_by"]))
+    return changed
+
+
+# ------------------------------------------------------------------ suites
+
+def parse_bench(spec):
+    """One benchmark of a suite: LM_EVAL_TASK[?limit=N] or env:HELDOUT_ENV[?k=K&limit=N] (PRD 4.1)."""
+    s = str(spec or "").strip()
+    if not s:
+        raise Problem(422, "empty benchmark in the suite")
+    base, _, query = s.partition("?")
+    env = None
+    if base.startswith("env:"):
+        env = base[4:].strip()
+        name, kind = env, "env"
+    else:
+        name, kind = base.strip(), "lm-eval"
+    if not name or not BENCH_NAME.fullmatch(name):
+        raise Problem(422, f"benchmark {s!r}: use LM_EVAL_TASK[?limit=N] or env:HELDOUT_ENV[?k=K&limit=N]")
+    opts = {}
+    for key, val in parse_qsl(query, keep_blank_values=True):
+        if key not in ("limit", "k"):
+            raise Problem(422, f"benchmark {s!r}: unknown option {key!r} (limit, k)")
+        try:
+            opts[key] = int(val)
+        except ValueError:
+            raise Problem(422, f"benchmark {s!r}: {key} must be a whole number, not {val!r}")
+        if opts[key] < 1:
+            raise Problem(422, f"benchmark {s!r}: {key} must be 1 or more")
+    canon = ("env:" if env else "") + name + ("?" + "&".join(f"{k}={opts[k]}" for k in ("k", "limit") if k in opts) if opts else "")
+    return {"spec": canon, "name": name, "kind": kind, "env": env, "limit": opts.get("limit"), "k": opts.get("k")}
+
+
+def parse_benches(value):
+    items = value if isinstance(value, (list, tuple)) else str(value or "").split(",")
+    out, seen = [], set()
+    for x in items:
+        if isinstance(x, dict):
+            x = x.get("spec") or x.get("name")
+        for part in str(x).split(","):
+            if part.strip():
+                b = parse_bench(part)
+                if b["name"] in seen:
+                    raise Problem(422, f"benchmark {b['name']} appears twice in the suite")
+                seen.add(b["name"])
+                out.append(b)
+    return out
+
+
+def get_suites(conn, pid):
+    """{name: suite}; `quick` and `release` always exist, and `release` equals `quick` until it is defined."""
+    rows = db.rows(conn, "SELECT * FROM suites WHERE project_id=? ORDER BY name", (pid,)) if has_table(conn, "suites") else []
+    stored = {r["name"]: r for r in rows}
+    out = {}
+    for name in ["quick", "release"] + [n for n in stored if n not in ("quick", "release")]:
+        r = stored.get(name)
+        benches = r["benchmarks"] if r and isinstance(r["benchmarks"], list) else []
+        out[name] = {"name": name, "benchmarks": benches, "defined": bool(r), "inherits": None,
+                     "updated_at": r and r["updated_at"], "updated_by": r and r["updated_by"]}
+    if not out["release"]["defined"]:
+        out["release"].update(benchmarks=list(out["quick"]["benchmarks"]), inherits="quick")
+    return out
+
+
+def suite_names(suite):
+    return [b["name"] for b in (suite or {}).get("benchmarks") or []]
+
+
+def set_suite(conn, pid, name, benches, user):
+    name = str(name or "").strip().lower()
+    if not SUITE_NAME.fullmatch(name):
+        raise Problem(422, f"suite name {name!r}: lowercase letters, digits, - and _ (quick, release, ...)")
+    parsed = parse_benches(benches)
+    if not parsed:
+        raise Problem(422, f"suite {name} needs at least one benchmark: LM_EVAL_TASK[?limit=N] or env:HELDOUT_ENV[?k=K&limit=N]")
+    conn.execute("INSERT OR REPLACE INTO suites (project_id, name, benchmarks, updated_at, updated_by) VALUES (?,?,?,?,?)",
+                 (pid, name, json.dumps(parsed), now(), user))
+    envs = {r["name"] for r in db.rows(conn, "SELECT name FROM environments WHERE project_id=?", (pid,))}
+    warnings = [f"env:{b['env']} is not an environment in this project yet (add it with `posttrain env add PATH`)"
+                for b in parsed if b["env"] and b["env"] not in envs]
+    return parsed, warnings
+
+
+def suite_object(org, project, pid, s):
+    return {"schema": "posttrain.v1.suite", "id": f"{pid}:{s['name']}", "url": project_url(org, project, f"/evals?suite={s['name']}"), **s}
+
+
+def suites_response(conn, org, project, pid):
+    su = get_suites(conn, pid)
+    return {"schema": "posttrain.v1.suite_list", "id": pid, "url": project_url(org, project, "/evals"),
+            "project": f"{org}/{project}", "suites": [suite_object(org, project, pid, s) for s in su.values()]}
+
+
+# ------------------------------------------------------------------ small readers
+
+def skips(conn, pid):
+    if not has_table(conn, "stage_state"):
+        return {}
+    return {r["stage"]: r for r in db.rows(conn, "SELECT * FROM stage_state WHERE project_id=? AND skipped=1", (pid,))}
+
+
+def aliases(conn, pid):
+    if not has_table(conn, "model_aliases"):
+        return {}
+    rows = db.rows(conn, "SELECT a.*, m.name AS model_name FROM model_aliases a LEFT JOIN models m ON m.id=a.model_id "
+                         "WHERE a.project_id=?", (pid,))
+    return {r["alias"]: {"alias": r["alias"], "model_id": r["model_id"], "model": r["model_name"], "set_by": r["set_by"],
+                         "set_at": r["set_at"]} for r in rows}
+
+
+def dataset_status(d):
+    f = d.get("fields") if isinstance(d.get("fields"), dict) else {}
+    return f.get("status") or "ready"
+
+
+def dataset_label(d):
+    return f"{d['name']}@{d['version']}" if d.get("version") else d["name"]
+
+
+def find_run(conn, pid, ref):
+    return db.one(conn, "SELECT * FROM runs WHERE project_id=? AND (id=? OR name=?) ORDER BY coalesce(started_at, 0) DESC LIMIT 1",
+                  (pid, ref, ref))
+
+
+def run_target(conn, run):
+    """(target name, target kind) the run ran on: its latest job's target, else the run's recorded target."""
+    j = db.one(conn, "SELECT target FROM jobs WHERE run_id=? AND target IS NOT NULL ORDER BY coalesce(created_at, started_at, 0) DESC LIMIT 1",
+               (run["id"],)) if run else None
+    name = (j or {}).get("target") or (run or {}).get("source") or None
+    kind = None
+    if name:
+        if name == "local":
+            kind = "local"
+        elif has_table(conn, "compute_targets"):
+            t = db.one(conn, "SELECT c.kind FROM compute_targets c JOIN projects p ON p.org_id=c.org_id WHERE p.id=? AND c.name=?",
+                       (run["project_id"], name))
+            kind = t["kind"] if t else None
+    return name, kind
+
+
+def weights_uri(path, target=None, kind=None):
+    """Where weights live, as a URI: hf://..., s3://... as given; file:///path on the local target; KIND://TARGET/path."""
+    p = str(path or "").strip()
+    if not p:
+        return None
+    if re.match(r"^[a-z][a-z0-9+.-]*://", p):
+        return p
+    if not target or target == "local" or kind == "local":
+        return "file://" + p if p.startswith("/") else "file://" + p
+    return f"{kind or 'target'}://{target}{p if p.startswith('/') else '/' + p}"
+
+
+def parse_weights(uri):
+    """{"scheme", "target", "path"} for a weights URI (see weights_uri)."""
+    m = re.match(r"^([a-z][a-z0-9+.-]*)://(.*)$", str(uri or ""))
+    if not m:
+        return {"scheme": "file", "target": "local", "path": uri}
+    scheme, rest = m.groups()
+    if scheme == "file":
+        return {"scheme": "file", "target": "local", "path": rest}
+    if scheme in ("hf", "s3", "gs", "http", "https"):
+        return {"scheme": scheme, "target": None, "path": rest}
+    target, _, path = rest.partition("/")
+    return {"scheme": scheme, "target": target, "path": "/" + path}
+
+
+# ------------------------------------------------------------------ models and their evals (read-only resolution)
+
+def _selector(model=None, ids=(), run=None, step=None, ref=None):
+    name = (model or {}).get("name") or (f"{run['name']}:{step}" if run and step is not None else (run or {}).get("name")) or ref
+    key = (model or {}).get("id") or (f"run:{run['id']}:{step}" if run else f"ref:{ref}")
+    return {"ref": ref, "name": name, "model": model, "model_ids": set(ids) | ({model["id"]} if model else set()), "run": run,
+            "step": step, "key": key}
+
+
+def _add_equivalents(conn, pid, sel):
+    """A checkpoint is one model however it is named: the promoted model, checkpoint models made for RUN:STEP, and
+    the run's output model at that step share their evals."""
+    run, step = sel["run"], sel["step"]
+    if run and step is not None:
+        for r in db.rows(conn, "SELECT id FROM models WHERE project_id=? AND run_id=? AND step=?", (pid, run["id"], step)):
+            sel["model_ids"].add(r["id"])
+        for r in db.rows(conn, "SELECT model_id FROM checkpoints WHERE run_id=? AND step=? AND model_id IS NOT NULL", (run["id"], step)):
+            sel["model_ids"].add(r["model_id"])
+    return sel
+
+
+def resolve_ref(conn, pid, ref):
+    """A model reference without creating anything: a project model (id, name or HF id), RUN:STEP, or a run (its
+    output model, else its last checkpoint). None when nothing in the project matches."""
+    ref = str(ref or "").strip()
+    if not ref:
+        return None
+    ms = db.rows(conn, "SELECT * FROM models WHERE project_id=? AND (id=? OR name=? OR hf_repo=?) ORDER BY created_at", (pid, ref, ref, ref))
+    if ms:
+        prim = next((m for m in reversed(ms) if m.get("status") in ("promoted", "released")), ms[-1])
+        same = {m["id"] for m in ms if m["name"] == prim["name"] or (prim.get("hf_repo") and m.get("hf_repo") == prim["hf_repo"])}
+        run = db.one(conn, "SELECT * FROM runs WHERE id=?", (prim["run_id"],)) if prim.get("run_id") else None
+        if not run:
+            made = db.one(conn, "SELECT * FROM runs WHERE output_model_id=?", (prim["id"],))
+            run = made
+        return _add_equivalents(conn, pid, _selector(prim, same, run, prim.get("step") if prim.get("run_id") else None, ref))
+    m = re.fullmatch(r"(.+):(\d+)", ref)
+    if m:
+        run = find_run(conn, pid, m.group(1))
+        if not run:
+            return None
+        step = int(m.group(2))
+        sel = _add_equivalents(conn, pid, _selector(None, (), run, step, ref))
+        ck = db.one(conn, "SELECT id FROM checkpoints WHERE run_id=? AND step=?", (run["id"], step))
+        has_eval = conn.execute("SELECT 1 FROM evals WHERE run_id=? AND step=? LIMIT 1", (run["id"], step)).fetchone()
+        if not (ck or sel["model_ids"] or has_eval):
+            return None
+        promoted = [x for x in (db.one(conn, "SELECT * FROM models WHERE id=?", (i,)) for i in sel["model_ids"]) if x]
+        prim = next((x for x in promoted if x.get("status") in ("promoted", "released")), None)
+        if prim:
+            sel.update(model=prim, name=prim["name"], key=prim["id"])
+        return sel
+    run = find_run(conn, pid, ref)
+    if run:
+        if run.get("output_model_id"):
+            out = db.one(conn, "SELECT * FROM models WHERE id=?", (run["output_model_id"],))
+            if out:
+                return _add_equivalents(conn, pid, _selector(out, (), run, out.get("step"), ref))
+        ck = db.one(conn, "SELECT step FROM checkpoints WHERE run_id=? ORDER BY step DESC LIMIT 1", (run["id"],))
+        return _add_equivalents(conn, pid, _selector(None, (), run, ck["step"] if ck else None, ref))
+    return None
+
+
+def model_selector(conn, pid, model):
+    """The selector for a model row (a promoted model, a base model...)."""
+    run = db.one(conn, "SELECT * FROM runs WHERE id=?", (model["run_id"],)) if model.get("run_id") else None
+    return _add_equivalents(conn, pid, _selector(model, (), run, model.get("step") if run else None, model["name"]))
+
+
+def evals_of(conn, pid, sel, completed=True):
+    """Eval rows of a selector (newest last), with benchmark name and metric."""
+    if not sel:
+        return []
+    ids = sorted(sel["model_ids"])
+    where, args = [], [pid]
+    if ids:
+        where.append(f"e.model_id IN ({','.join('?' for _ in ids)})")
+        args += ids
+    if sel["run"] and sel["step"] is not None:
+        where.append("(e.run_id=? AND e.step=?)")
+        args += [sel["run"]["id"], sel["step"]]
+    if not where:
+        return []
+    rows = db.rows(conn, "SELECT e.*, b.name AS benchmark, b.metric, b.harness, b.version AS benchmark_version FROM evals e "
+                         f"JOIN benchmarks b ON b.id=e.benchmark_id WHERE e.project_id=? AND ({' OR '.join(where)}) "
+                         "ORDER BY coalesce(e.ended_at, e.started_at, 0)", args)
+    return [r for r in rows if r["status"] == "completed"] if completed else rows
+
+
+def latest_by_benchmark(evals, names=None):
+    by = {}
+    for e in evals:
+        by[e["benchmark"]] = e
+    if names is not None:
+        return {n: by[n] for n in names if n in by}
+    return by
+
+
+def eval_tasks(conn, eval_id, cache=None):
+    if cache is not None and eval_id in cache:
+        return cache[eval_id]
+    rows = db.rows(conn, "SELECT * FROM eval_tasks WHERE eval_id=?", (eval_id,))
+    if cache is not None:
+        cache[eval_id] = rows
+    return rows
+
+
+def eval_brief(e, tasks=None):
+    if not e:
+        return None
+    return {"eval_id": e["id"], "score": e["score"], "stderr": e["stderr"], "n_tasks": e["n_tasks"], "k": e["k"],
+            "n_infra": e["n_infra"], "metric": e.get("metric"), "step": e.get("step"),
+            "infra_share": infra_share(e, tasks), "ended_at": e.get("ended_at")}
+
+
+def compare_row(conn, name, ea, eb, cache=None):
+    ta = eval_tasks(conn, ea["id"], cache) if ea else []
+    tb = eval_tasks(conn, eb["id"], cache) if eb else []
+    c = compare(ea, eb, ta, tb)
+    return {"benchmark": name, "metric": (eb or ea or {}).get("metric"), "a": eval_brief(ea, ta), "b": eval_brief(eb, tb), **c}
+
+
+# ------------------------------------------------------------------ acknowledgements
+
+def ack_keys(sel):
+    keys = {sel["key"]} | set(sel["model_ids"])
+    if sel["run"] and sel["step"] is not None:
+        keys.add(f"run:{sel['run']['id']}:{sel['step']}")
+    return keys
+
+
+def acks_for(conn, pid, sel, suite=None):
+    """{benchmark: ack} for a model (any of its equivalent keys), newest first wins."""
+    if not has_table(conn, "acks") or not sel:
+        return {}
+    keys = sorted(ack_keys(sel))
+    rows = db.rows(conn, f"SELECT * FROM acks WHERE project_id=? AND model_key IN ({','.join('?' for _ in keys)})"
+                         + (" AND suite=?" if suite else "") + " ORDER BY at", [pid, *keys] + ([suite] if suite else []))
+    out = {}
+    for r in rows:
+        out[r["benchmark"]] = {"id": r["id"], "by": r["by"], "at": r["at"], "note": r["note"], "suite": r["suite"]}
+    return out
+
+
+# ------------------------------------------------------------------ promoted models
+
+def promoted_models(conn, pid):
+    """Promoted models, newest first, each with its run's kind; in example sources, run outputs stand in."""
+    if has_table(conn, "promotions"):
+        return db.rows(conn, "SELECT m.*, p.weights, p.weights_target, p.pushed_to, p.by AS promoted_by, p.at AS promoted_at, "
+                             "p.rule AS promotion_rule, r.kind AS run_kind, r.name AS run_name FROM promotions p "
+                             "JOIN models m ON m.id=p.model_id LEFT JOIN runs r ON r.id=p.run_id "
+                             "WHERE p.project_id=? AND p.replaced_by IS NULL ORDER BY p.at DESC", (pid,))
+    return db.rows(conn, "SELECT m.*, NULL AS weights, NULL AS weights_target, NULL AS pushed_to, NULL AS promoted_by, "
+                         "coalesce(m.created_at, r.ended_at) AS promoted_at, NULL AS promotion_rule, r.kind AS run_kind, r.name AS run_name "
+                         "FROM runs r JOIN models m ON m.id=r.output_model_id WHERE r.project_id=? AND r.status='completed' "
+                         "ORDER BY coalesce(r.ended_at, r.started_at) DESC", (pid,))
+
+
+def quick_state(conn, pid, sel, suites):
+    """(complete, evaluated names, missing names) of a model's quick evals; an empty quick suite takes any eval."""
+    names = suite_names(suites["quick"])
+    have = latest_by_benchmark(evals_of(conn, pid, sel))
+    if not names:
+        return bool(have), sorted(have), []
+    got = [n for n in names if n in have]
+    return len(got) == len(names), got, [n for n in names if n not in have]
+
+
+def baseline_selector(conn, pid, settings):
+    base = settings.get("base_model")
+    return resolve_ref(conn, pid, base) if base else None
+
+
+def release_gate(conn, pid, sel, suites, baseline=None, production=None, cache=None):
+    """The Eval stage for one model (PRD 4.6): its release eval complete with infrastructure errors ≤ 10% on each
+    benchmark, compared with the baseline and the production model, every regression beyond noise acknowledged."""
+    names = suite_names(suites["release"])
+    evs = latest_by_benchmark(evals_of(conn, pid, sel), names)
+    missing = [n for n in names if n not in evs]
+    infra = {n: infra_share(e, eval_tasks(conn, e["id"], cache)) for n, e in evs.items()}
+    too_many = {n: s for n, s in infra.items() if s > INFRA_LIMIT}
+    acks = acks_for(conn, pid, sel)
+    comparisons, regressions, unacked, uncompared = [], [], [], []
+    for role, ref in (("baseline", baseline), ("production", production)):
+        if not ref or ref["key"] == sel["key"] or (ref["model_ids"] & sel["model_ids"]):
+            continue
+        ref_evs = latest_by_benchmark(evals_of(conn, pid, ref), names)
+        for n in names:
+            if n not in evs:
+                continue
+            if n not in ref_evs:
+                uncompared.append({"role": role, "model": ref["name"], "benchmark": n})
+                continue
+            row = compare_row(conn, n, ref_evs[n], evs[n], cache)
+            row.update(role=role, against=ref["name"])
+            comparisons.append(row)
+            if row["verdict"] == "regressed":
+                row["acknowledged"] = acks.get(n)
+                regressions.append(row)
+                if not acks.get(n):
+                    unacked.append(row)
+    return {"benchmarks": names, "evals": {n: eval_brief(e, eval_tasks(conn, e["id"], cache)) for n, e in evs.items()},
+            "missing": missing, "infra": infra, "infra_over": too_many, "complete": bool(names) and not missing and not too_many,
+            "comparisons": comparisons, "regressions": regressions, "unacknowledged": unacked, "uncompared": uncompared,
+            "compared": not uncompared, "acknowledged": not unacked,
+            "done": bool(names) and not missing and not too_many and not uncompared and not unacked}
+
+
+# ------------------------------------------------------------------ promotion
+
+def checkpoints_of(conn, run):
+    """The run's checkpoints, one per step (the latest record wins), oldest step first."""
+    by = {}
+    for c in db.rows(conn, "SELECT * FROM checkpoints WHERE run_id=? ORDER BY created_at", (run["id"],)):
+        if c["step"] is not None:
+            by[int(c["step"])] = c
+    return [by[s] for s in sorted(by)]
+
+
+def promotion_plan(conn, pid, ref, name=None, suites=None, step=None):
+    """What `models promote RUN[:STEP]` would promote: the checkpoint, the table of quick scores it used, and why.
+
+    Without a step: the last checkpoint, unless an earlier one scores better on the quick suite by more than two
+    standard errors (the mean change over the benchmarks both have, against the SE of that mean)."""
+    ref = str(ref or "").strip()
+    m = re.fullmatch(r"(.+):(\d+)", ref)
+    run = find_run(conn, pid, ref)
+    if not run and m:
+        run, step = find_run(conn, pid, m.group(1)), int(m.group(2))
+    if not run:
+        raise Problem(404, f"No run {ref!r} in this project (posttrain runs ls).")
+    suites = suites or get_suites(conn, pid)
+    ckpts = checkpoints_of(conn, run)
+    out_model = db.one(conn, "SELECT * FROM models WHERE id=?", (run["output_model_id"],)) if run.get("output_model_id") else None
+    points = [{"step": c["step"], "path": c["path"], "checkpoint_id": c["id"], "size_gb": c.get("size_gb")} for c in ckpts]
+    if not points and out_model:
+        points = [{"step": out_model.get("step") if out_model.get("step") is not None else run.get("steps_done"),
+                   "path": (f"hf://{out_model['hf_repo']}" if out_model.get("hf_repo") else out_model.get("notes")) or None,
+                   "checkpoint_id": None, "output_model_id": out_model["id"]}]
+    if not points:
+        raise Problem(404, f"Run {run['name']} has no checkpoint to promote (it saved none, and reported no output model).")
+    steps = [p["step"] for p in points]
+    names = suite_names(suites["quick"])
+    cache = {}
+    table = []
+    for p in points:
+        sel = _add_equivalents(conn, pid, _selector(None, (), run, p["step"], f"{run['name']}:{p['step']}"))
+        evs = latest_by_benchmark(evals_of(conn, pid, sel), names if names else None)
+        p["evals"] = evs
+        table.append({"step": p["step"], "scores": {n: {"score": e["score"], "stderr": e["stderr"], "eval_id": e["id"],
+                                                        "metric": e.get("metric")} for n, e in evs.items()}})
+    benches = names or sorted({n for p in points for n in p["evals"]})
+    last = points[-1]
+    chosen, rule, better = last, "", []
+    if step is not None:
+        chosen = next((p for p in points if p["step"] == step), None)
+        if chosen is None:
+            raise Problem(404, f"Run {run['name']} has no checkpoint at step {step} (steps: {', '.join(str(s) for s in steps)}).")
+        rule = f"step {step}, as asked"
+    elif not any(p["evals"] for p in points):
+        rule = (f"no quick evals for {run['name']}'s checkpoints; using the last checkpoint (step {last['step']})")
+    elif not last["evals"]:
+        rule = f"the last checkpoint (step {last['step']}) has no quick eval to compare with; using it"
+    else:
+        for p in points[:-1]:
+            rows = [compare_row(conn, n, last["evals"][n], p["evals"][n], cache) for n in benches if n in p["evals"] and n in last["evals"]]
+            agg = aggregate(rows)
+            if agg["verdict"] == "improved":
+                better.append((agg["delta"], p, agg))
+        if better:
+            delta, chosen, agg = max(better, key=lambda x: x[0])
+            rule = (f"step {chosen['step']} is better than the last checkpoint (step {last['step']}) on quick by "
+                    f"{agg['delta'] * 100:+.1f} ± {agg['se_diff'] * 100:.1f} pp, more than 2 SE")
+        else:
+            rule = "last checkpoint; no earlier step is better by more than 2 SE"
+    target, kind = run_target(conn, run)
+    parent = db.one(conn, "SELECT id, name, hf_repo, kind FROM models WHERE id=?", (run["base_model_id"],)) if run.get("base_model_id") else None
+    return {"run": {"id": run["id"], "name": run["name"], "kind": run["kind"], "stage": run.get("stage"), "status": run["status"]},
+            "step": chosen["step"], "last_step": last["step"], "steps": steps, "benchmarks": benches, "table": table, "rule": rule,
+            "checkpoint_id": chosen.get("checkpoint_id"), "path": chosen.get("path"),
+            "weights": weights_uri(chosen.get("path"), target, kind), "weights_target": target, "target_kind": kind,
+            "parent": parent, "name": name, "running": run["status"] in ACTIVE_RUN}
+
+
+# ------------------------------------------------------------------ deploy checks
+
+def eval_serving(ev):
+    """The serving settings an eval recorded in its config (`serving`: chat_template_hash, tool_parser,
+    reasoning_parser, max_model_len, sampling), with top-level keys as a fallback."""
+    cfg = eval_config(ev)
+    s = cfg.get("serving") if isinstance(cfg.get("serving"), dict) else {}
+    out = {}
+    for k in SERVING_KEYS:
+        v = s.get(k, cfg.get(k))
+        if k == "tool_parser" and v is None:
+            v = s.get("tool_call_parser", cfg.get("tool_call_parser"))
+        if v not in (None, ""):
+            out[k] = v
+    samp = s.get("sampling") if isinstance(s.get("sampling"), dict) else None
+    if samp is None and s:
+        samp = {k: s[k] for k in ("temperature", "top_p", "max_tokens") if s.get(k) is not None} or None
+    if samp:
+        out["sampling"] = {k: v for k, v in samp.items() if v is not None}
+    return out
+
+
+def serving_consensus(evals):
+    """(serving, conflicts, recorded): the settings every release eval that recorded them agrees on."""
+    values, conflicts, recorded = {}, [], False
+    per = {n: eval_serving(e) for n, e in evals.items()}
+    for n, s in per.items():
+        if s:
+            recorded = True
+    serving = {}
+    for k in SERVING_KEYS:
+        seen = {n: s[k] for n, s in per.items() if k in s}
+        vals = {json.dumps(v, sort_keys=True) for v in seen.values()}
+        if len(vals) > 1:
+            conflicts.append({"key": k, "values": seen})
+        elif vals:
+            serving[k] = next(iter(seen.values()))
+    samp = {n: s["sampling"] for n, s in per.items() if s.get("sampling")}
+    if samp and len({json.dumps(v, sort_keys=True) for v in samp.values()}) == 1:
+        serving["sampling"] = next(iter(samp.values()))
+    elif samp:
+        values["sampling_differs"] = samp
+    return serving, conflicts, recorded, values
+
+
+def fmt_serving(s):
+    parts = []
+    if s.get("chat_template_hash"):
+        parts.append(f"template {str(s['chat_template_hash'])[:6]}")
+    parts.append(f"tool parser {s['tool_parser']}" if s.get("tool_parser") else "no tool parser")
+    if s.get("reasoning_parser"):
+        parts.append(f"reasoning parser {s['reasoning_parser']}")
+    if s.get("max_model_len"):
+        parts.append(f"max_model_len {int(s['max_model_len']):,}")
+    if s.get("sampling"):
+        parts.append("sampling " + ", ".join(f"{k} {v}" for k, v in sorted(s["sampling"].items())))
+    return ", ".join(parts)
+
+
+def reachable(weights, weights_target, target, target_kind):
+    """(ok, detail, fix) for whether `target` can read the weights."""
+    loc = parse_weights(weights) if weights else None
+    if not loc:
+        return False, "the model has no recorded weights location", None
+    if loc["scheme"] == "hf":
+        return True, f"{weights} readable from {target or 'anywhere'} (the Hub)", None
+    if loc["scheme"] in ("s3", "gs", "http", "https"):
+        return True, f"{weights} readable from {target} (object storage; the target needs its credentials)", None
+    where = weights_target or loc.get("target") or "local"
+    if target_kind == "hub":
+        if where == "local" or loc["scheme"] in ("file", "ssh", "slurm", "target"):
+            return True, f"{weights} can be uploaded from {where}", None
+    if where == target or (where == "local" and target == "local"):
+        return True, f"{weights} is on {target}", None
+    return False, f"the weights are on {where}, which {target} can't read", "posttrain models push {name} --to hf://ORG/REPO"
+
+
+def model_row_for(conn, pid, ref):
+    sel = resolve_ref(conn, pid, ref)
+    if not sel:
+        raise Problem(404, f"No model {ref!r} in this project (posttrain models ls).")
+    return sel
+
+
+def promotion_of(conn, model_id):
+    if not model_id or not has_table(conn, "promotions"):
+        return None
+    return db.one(conn, "SELECT * FROM promotions WHERE model_id=?", (model_id,))
+
+
+def deploy_checks(conn, pid, ref, target=None, target_kind=None, overrides=None, cache=None):
+    """The five blocking deploy checks (PRD 4.7) for model `ref` on `target`, the serving settings a deploy uses,
+    and where the weights are. `overrides`: serving settings the deploy sets itself (compared with the evals')."""
+    sel = model_row_for(conn, pid, ref)
+    model = sel["model"] or {}
+    settings, suites = get_settings(conn, pid), get_suites(conn, pid)
+    promo = promotion_of(conn, model.get("id"))
+    checks = []
+
+    def check(cid, ok, detail, fix=None, skip=False):
+        checks.append({"id": cid, "status": "skip" if skip else ("ok" if ok else "fail"), "detail": detail,
+                       **({"fix": fix} if fix and not ok and not skip else {})})
+
+    name = sel["name"]
+    check("model.promoted", bool(promo), f"{name} is promoted (from {sel['run']['name']} step {sel['step']})" if promo and sel["run"]
+          else f"{name} is promoted" if promo else f"{name} is not a promoted model",
+          f"posttrain models promote RUN[:STEP] --as {slug(name)}")
+    base = baseline_selector(conn, pid, settings)
+    prod_alias = aliases(conn, pid).get("production")
+    prod_model = db.one(conn, "SELECT * FROM models WHERE id=?", (prod_alias["model_id"],)) if prod_alias else None
+    production = model_selector(conn, pid, prod_model) if prod_model else None
+    gate = release_gate(conn, pid, sel, suites, base, production, cache)
+    names = gate["benchmarks"]
+    if not names:
+        check("eval.release_complete", False, "the release suite is empty", "posttrain suites set release --bench BENCH,...")
+    elif gate["missing"]:
+        check("eval.release_complete", False, f"{name} has no release eval on {', '.join(gate['missing'])}",
+              f"posttrain eval {q(name)} --suite release")
+    elif gate["infra_over"]:
+        worst = ", ".join(f"{n} {s:.0%}" for n, s in gate["infra_over"].items())
+        check("eval.release_complete", False, f"infrastructure errors above 10% on {worst}", f"posttrain eval {q(name)} --suite release")
+    else:
+        top = max(gate["infra"].values()) if gate["infra"] else 0.0
+        check("eval.release_complete", True, f"release eval complete ({len(names)} benchmark{'s' if len(names) != 1 else ''}, "
+                                             f"infrastructure errors ≤ {top:.1%})")
+    if not gate["evals"]:
+        check("eval.regressions_acked", False, "waits for the release eval", skip=True)
+    elif gate["uncompared"]:
+        u = gate["uncompared"][0]
+        miss = sorted({x["benchmark"] for x in gate["uncompared"] if x["model"] == u["model"]})
+        check("eval.regressions_acked", False, f"can't compare with the {u['role']} {u['model']}: it has no release eval on {', '.join(miss)}",
+              f"posttrain eval {q(u['model'])} --suite release")
+    elif gate["unacknowledged"]:
+        r = gate["unacknowledged"][0]
+        n = len(gate["unacknowledged"])
+        check("eval.regressions_acked", False,
+              f"{n} regression{'s' if n != 1 else ''} beyond noise not acknowledged ("
+              + ", ".join(f"{x['benchmark']} {x['delta'] * 100:+.1f} pp vs {x['against']}" for x in gate["unacknowledged"]) + ")",
+              f"posttrain evals ack {q(name)} --suite release --bench {q(r['benchmark'])} --note \"…\"")
+    elif gate["regressions"]:
+        acked = gate["regressions"]
+        a0 = acked[0]["acknowledged"]
+        check("eval.regressions_acked", True, f"{len(acked)} regression{'s' if len(acked) != 1 else ''} acknowledged ("
+                                              + ", ".join(x["benchmark"] for x in acked) + f", by {a0['by']}: \"{a0['note']}\")")
+    else:
+        against = [x for x in (base, production) if x and x["key"] != sel["key"]]
+        check("eval.regressions_acked", True, "no regression beyond noise" + (
+            f" against {' and '.join(x['name'] for x in against)}" if against else " (no baseline or production model to compare with)"))
+    release_evals = latest_by_benchmark(evals_of(conn, pid, sel), names)
+    serving, conflicts, recorded, notes = serving_consensus(release_evals)
+    over = {k: v for k, v in (overrides or {}).items() if v not in (None, "")}
+    diffs = []
+    for k in SERVING_KEYS:
+        if k in over and k in serving and str(over[k]) != str(serving[k]):
+            diffs.append(f"{k} {over[k]} differs from the {serving[k]} the release evals used")
+    if target_kind == "hub":
+        check("serving.matches_eval", True, "not applicable to a Hub push", skip=True)
+    elif not release_evals:
+        check("serving.matches_eval", False, "waits for the release eval", skip=True)
+    elif conflicts:
+        c0 = conflicts[0]
+        check("serving.matches_eval", False, f"the release evals disagree on {c0['key']} (" +
+              ", ".join(f"{n}: {v}" for n, v in c0["values"].items()) + ")", f"posttrain eval {q(name)} --suite release")
+    elif diffs:
+        check("serving.matches_eval", False, "; ".join(diffs), "drop the override, or evaluate with the same setting")
+    elif not recorded:
+        check("serving.matches_eval", False, "the release evals recorded no serving settings (chat template, max_model_len)",
+              f"posttrain eval {q(name)} --suite release")
+    else:
+        check("serving.matches_eval", True, "serving config equals eval config (" + fmt_serving({**serving, **over}) + ")")
+    weights = (promo or {}).get("pushed_to") or (promo or {}).get("weights")
+    weights_target = (promo or {}).get("weights_target")
+    if not weights and model.get("hf_repo"):
+        weights = f"hf://{model['hf_repo']}"
+    if not weights and model.get("kind") == "base" and model.get("name"):
+        weights = f"hf://{model['name']}"
+    if target:
+        ok, detail, fix = reachable(weights, weights_target, target, target_kind)
+        check("model.reachable", ok, detail, fix and fix.format(name=q(name)))
+    else:
+        check("model.reachable", False, "no deploy target given", "posttrain models deploy NAME --on TARGET")
+    return {"model": {"id": model.get("id"), "name": name, "run_id": (sel["run"] or {}).get("id"), "step": sel["step"]},
+            "checks": checks, "ok": all(c["status"] != "fail" for c in checks), "serving": {**serving, **over},
+            "serving_notes": notes, "weights": weights, "weights_target": weights_target, "release": gate}
+
+
+def smoke_prompts(conn, pid, n=20):
+    """Up to n prompts from the release suite: its held-out environments' tasks, then eval datasets; else built-ins."""
+    su = get_suites(conn, pid)
+    prompts = []
+    for b in su["release"]["benchmarks"]:
+        if b["env"] and len(prompts) < n:
+            env = db.one(conn, "SELECT id FROM environments WHERE project_id=? AND name=? ORDER BY created_at DESC LIMIT 1", (pid, b["env"]))
+            if env:
+                prompts += [t["instruction"] for t in db.rows(conn, "SELECT instruction FROM tasks WHERE env_id=? AND instruction != '' "
+                                                                  "ORDER BY name LIMIT ?", (env["id"], n)) if t["instruction"]]
+    if len(prompts) < n:
+        for r in db.rows(conn, "SELECT r.data FROM dataset_rows r JOIN datasets d ON d.id=r.dataset_id WHERE d.project_id=? AND d.kind='eval' "
+                               "ORDER BY r.idx LIMIT ?", (pid, n)):
+            d = r["data"] if isinstance(r["data"], dict) else {}
+            p = d.get("prompt") or d.get("question") or d.get("problem")
+            if isinstance(p, str) and p.strip():
+                prompts.append(p)
+    source = "release suite" if prompts else "built-in"
+    if not prompts:
+        prompts = BUILTIN_PROMPTS
+    while len(prompts) < n:
+        prompts = prompts + prompts
+    return prompts[:n], source
+
+
+BUILTIN_PROMPTS = [
+    "What is 17 + 25? Answer with the number only.", "Name the capital of France in one word.",
+    "Write one sentence about the ocean.", "What is 9 times 7?", "Spell the word 'model' backwards.",
+    "Give a synonym for 'quick'.", "What is the square root of 144?", "List three primary colors.",
+    "Translate 'thank you' into Spanish.", "What day comes after Monday?", "Is 29 a prime number? Answer yes or no.",
+    "Complete the sequence: 2, 4, 8, 16, ...", "What is 100 divided by 4?", "Name a mammal that lives in the sea.",
+    "Summarize in five words: the cat sat on the mat.", "What is the boiling point of water in Celsius?",
+    "Write a haiku about autumn.", "Convert 3 kilometers to meters.", "What is the opposite of 'cold'?",
+    "Reply with the word OK.",
+]
+
+
+# ------------------------------------------------------------------ the stage table
+
+def _act(label, cli, kind, arg=None, action=None, needs=None):
+    """A next action: a button (label; kind/arg say where the website goes) and the CLI line that does the same."""
+    return {"label": label, "cli": cli, "command": cli, "kind": kind, "arg": arg, "action": action, "needs": needs}
+
+
+def _needs(needs, cli, action=None, kind="page", arg=None, label=None):
+    return {"label": label, "cli": cli, "command": cli, "kind": kind, "arg": arg, "action": action, "needs": needs}
+
+
+def stage_table(conn, org, project, p, source="workspace", compute=None):
+    """The seven-row Stages table (PRD 6.3) for a project row `p`."""
+    pid = p["id"]
+    workspace = has_table(conn, "promotions")
+    settings, suites = get_settings(conn, pid), get_suites(conn, pid)
+    planned = set(settings["stages"])
+    skip = skips(conn, pid)
+    al = aliases(conn, pid)
+    cache = {}
+    compute = compute or {"targets": [], "runners": []}
+    served = [t["name"] for t in compute["targets"] if t.get("runners")]
+    target = served[0] if served else next((t["name"] for t in compute["targets"] if not t.get("builtin")), "local")
+    base = settings["base_model"] or "<model>"
+    datasets = db.rows(conn, "SELECT id, name, kind, version, rows, tokens, fields, created_at FROM datasets WHERE project_id=? "
+                             "ORDER BY created_at DESC", (pid,))
+    for d in datasets:
+        d["status"] = dataset_status(d)
+    envs = db.rows(conn, "SELECT id, name, domain, version, task_count, created_at FROM environments WHERE project_id=? ORDER BY created_at DESC", (pid,))
+    from .api_ui import env_readiness          # one definition of "ready" (PRD 4.2) for the stages table and the launch form
+    ready = env_readiness(conn, [e["id"] for e in envs])
+    heldout = {b["env"] for s in suites.values() for b in s["benchmarks"] if b.get("env")}
+    runs = db.rows(conn, "SELECT r.id, r.name, r.kind, r.status, r.status_reason, r.framework, r.algorithm, r.steps_done, r.steps_planned, "
+                         "r.started_at, r.updated_at, r.ended_at, r.base_model_id, r.output_model_id, m.name AS output_model, b.name AS base_model "
+                         "FROM runs r LEFT JOIN models m ON m.id=r.output_model_id LEFT JOIN models b ON b.id=r.base_model_id "
+                         "WHERE r.project_id=? ORDER BY coalesce(r.updated_at, r.started_at) DESC", (pid,))
+    evals = db.rows(conn, "SELECT e.id, e.status, e.score, e.stderr, e.step, e.n_tasks, e.k, e.n_infra, e.started_at, e.model_id, e.run_id, "
+                          "e.benchmark_id, b.name AS benchmark, b.metric, m.name AS model_name, r.name AS run_name FROM evals e "
+                          "JOIN benchmarks b ON b.id=e.benchmark_id LEFT JOIN models m ON m.id=e.model_id LEFT JOIN runs r ON r.id=e.run_id "
+                          "WHERE e.project_id=? ORDER BY e.started_at DESC", (pid,))
+    dep_cols = columns(conn, "deployments")
+    deps = db.rows(conn, "SELECT d.*, m.name AS model_name FROM deployments d LEFT JOIN models m ON m.id=d.model_id "
+                         "WHERE d.project_id=? ORDER BY d.created_at DESC", (pid,))
+    models = db.rows(conn, "SELECT id, name, kind, hf_repo, status, created_at FROM models WHERE project_id=? ORDER BY created_at DESC", (pid,))
+    promoted = promoted_models(conn, pid)
+    ckpt_runs = {r["run_id"] for r in db.rows(conn, "SELECT DISTINCT c.run_id FROM checkpoints c JOIN runs r ON r.id=c.run_id "
+                                                    "WHERE r.project_id=?", (pid,))}
+    rows = {}
+
+    quick_of = {}                                  # promoted model id -> (complete, evaluated, missing)
+
+    def run_obj(r):
+        """A run as the website's Stages table shows it; a run with a promoted model shows that model ("X, from RUN")."""
+        mine = [m for m in promoted if m.get("run_id") == r["id"]]
+        out = {"type": "run", "id": r["id"], "name": r["name"], "status": r["status"], "reason": r["status_reason"],
+               "framework": r["framework"], "algorithm": r["algorithm"], "steps_done": r["steps_done"], "steps_planned": r["steps_planned"],
+               "output_model": r["output_model"], "evaluated": any(e["model_id"] == r["output_model_id"] and e["status"] == "completed"
+                                                                   for e in evals) if r["output_model_id"] else False,
+               "promoted": [m["name"] for m in mine]}
+        if mine:
+            q0 = quick_of.get(mine[0]["id"])
+            out.update(output_model=mine[0]["name"], evaluated=bool(q0 and q0[0]))
+        return out
+
+    def model_obj(m, quick=None):
+        return {"type": "model", "id": m["id"], "name": m["name"], "run": m.get("run_name"), "run_id": m.get("run_id"), "step": m.get("step"),
+                "promoted_by": m.get("promoted_by"), "promoted_at": m.get("promoted_at"), "quick": quick}
+
+    # ---- data
+    need_kinds = [k for k in ("sft", "preference") if k in planned and k not in skip]
+    ev, blocked_by, fix = [], None, None
+    for kind in need_kinds:
+        ds = [d for d in datasets if d["kind"] == kind]
+        good = [d for d in ds if d["status"] == "ready"]
+        if good:
+            d = good[0]
+            ev.append({"check": f"{kind} dataset", "ok": True, "detail": f"{dataset_label(d)} ready · {d['rows'] or 0:,} rows"})
+        elif ds:
+            d = ds[0]
+            ev.append({"check": f"{kind} dataset", "ok": False, "detail": f"{dataset_label(d)} is blocked"})
+            blocked_by = blocked_by or f"{dataset_label(d)} is blocked; runs refuse blocked versions"
+            fix = fix or _act("Fix dataset", f"posttrain data add <file> --kind {kind} --name {q(d['name'])} --fix", "page",
+                              f"/datasets/{d['id']}", "fix_dataset", needs=blocked_by)
+        else:
+            ev.append({"check": f"{kind} dataset", "ok": False, "detail": f"no {kind} dataset yet"})
+    quick_b, release_b = suites["quick"]["benchmarks"], suites["release"]["benchmarks"]
+    suites_ok = bool(quick_b) and bool(release_b)
+    ev.append({"check": "suites", "ok": suites_ok,
+               "detail": (f"quick ({len(quick_b)}) and release ({len(release_b)}" + (", equals quick" if suites["release"]["inherits"] else "") + ")")
+               if suites_ok else "no quick suite yet"})
+    if "data" in skip:
+        status = "skipped"
+    elif all(e["ok"] for e in ev):
+        status = "done"
+    elif blocked_by:
+        status = "blocked"
+    elif not datasets:
+        status = "not_started"          # suites are settings; the stage starts with the first dataset
+    else:
+        status = "in_progress"
+    nxt = None
+    if status != "done":
+        for kind in need_kinds:
+            e = next(x for x in ev if x["check"] == f"{kind} dataset")
+            if not e["ok"]:
+                if "blocked" in e["detail"]:
+                    nxt = fix
+                else:
+                    f = "pairs.jsonl" if kind == "preference" else "train.jsonl"
+                    nxt = _act("Add dataset", f"posttrain data add ./{f} --kind {kind}", "add", "dataset", "add_dataset")
+                break
+        if nxt is None and not suites_ok:
+            nxt = _act("Set suites", f"posttrain suites set quick --bench {q(','.join(DEFAULT_QUICK))}", "page", "/evals", "set_suites")
+    now_parts = [f"{dataset_label(d)} · {d['rows'] or 0:,} rows" + ("" if d["status"] == "ready" else f" ({d['status']})") for d in datasets[:3]]
+    if suites_ok:
+        now_parts.append("suites quick and release")
+    rows["data"] = {"status": status, "evidence": ev, "blocked_by": blocked_by, "now": "; ".join(now_parts),
+                    "objects": [{"type": "dataset", "id": d["id"], "name": d["name"], "kind": d["kind"], "rows": d["rows"],
+                                 "version": d["version"], "status": d["status"]} for d in datasets], "next": nxt}
+
+    # ---- environments
+    rl_needed = "rl" in planned and "rl" not in skip
+    planned_envs = [e for e in envs if e["name"] not in heldout]
+    env_objs = [{"type": "environment", "id": e["id"], "name": e["name"], "domain": e["domain"], "version": e["version"],
+                 "heldout": e["name"] in heldout, **ready[e["id"]]} for e in envs]
+    unready = [e for e in env_objs if not e["heldout"] and not e["ready"]]
+    failing = [e for e in unready if e["reason"] and ("usable" in e["reason"] or "learnable" in e["reason"])]
+    blocked_by, nxt, implicit = None, None, None
+    if "environments" in skip:
+        status = "skipped"
+    elif not rl_needed:
+        status, implicit = "skipped", ("RL isn't planned" if "rl" not in planned else "RL is skipped")
+    elif not planned_envs:
+        status = "not_started"
+        nxt = _act("Add environment", "posttrain env add ./my-env", "add", "environment", "add_environment")
+    elif not unready:
+        status = "done"
+    else:
+        e0 = (failing or unready)[0]
+        status = "blocked" if failing else "in_progress"
+        if failing:
+            blocked_by = f"{e0['name']}: {e0['reason']}"
+        nxt = _act("Validate", f"posttrain env validate {q(e0['name'])} --on {q(target)}", "env", e0["id"], "validate",
+                   needs=blocked_by)
+    rows["environments"] = {"status": status, "objects": env_objs, "blocked_by": blocked_by, "implicit": implicit,
+                            "evidence": [{"check": e["name"], "ok": e["ready"], "detail": "ready" if e["ready"] else e["reason"]}
+                                         for e in env_objs if not e["heldout"]],
+                            "now": "; ".join(f"{e['name']} " + ("ready" if e["ready"] else e["reason"] or "") for e in env_objs[:3]
+                                             if not e["heldout"]), "next": nxt}
+
+    # ---- training stages
+    def start_from(st):
+        order = {"sft": [], "preference": ["sft"], "rl": ["dpo", "sft"]}[st]
+        for k in order:
+            m = next((m for m in promoted if m.get("run_kind") == k), None)
+            if m:
+                return m["name"]
+            r = next((r for r in runs if r["kind"] == k and r["status"] == "completed" and r["output_model"]), None)
+            if r:
+                return r["output_model"]
+        return base
+
+    by_kind = {}
+    for d in datasets:
+        by_kind.setdefault(d["kind"], []).append(d)
+    for st, kind in RUN_KIND.items():
+        rs = [r for r in runs if r["kind"] == kind]
+        active = [r for r in rs if r["status"] in ACTIVE_RUN]
+        mine = [m for m in promoted if m.get("run_kind") == kind]
+        done_models, unevaluated = [], []
+        for m in mine:
+            ok, got, missing = quick_of[m["id"]] = quick_state(conn, pid, model_selector(conn, pid, m), suites)
+            (done_models if ok else unevaluated).append((m, got, missing))
+        ended = [r for r in rs if r["status"] in ("completed", "stopped", "failed") and (r["id"] in ckpt_runs or r["output_model_id"])
+                 and not any(m.get("run_id") == r["id"] for m in mine)]
+        missing_input = blocked_input = input_action = None
+        if st == "rl":
+            ready_envs = [e for e in planned_envs if ready[e["id"]]["ready"]]
+            env_names = [e["name"] for e in (ready_envs or planned_envs)][:3]
+            inputs = f"--env {q(','.join(env_names))}" if env_names else (f"--data {q(by_kind['rl'][0]['name'])} --set reward=exact_match"
+                                                                           if by_kind.get("rl") else "--env <environment>")
+            if not ready_envs and not by_kind.get("rl"):
+                if not planned_envs:
+                    missing_input = "needs an environment or an RL dataset"
+                    input_action = _act("Add environment", "posttrain env add ./my-env", "add", "environment", "add_environment")
+                else:
+                    e0 = next((e for e in env_objs if e["name"] == ((failing or unready)[0])["name"]), None) if (failing or unready) else None
+                    why = f"{e0['name']}: {e0['reason']}" if e0 else "no environment is ready"
+                    if failing:
+                        blocked_input = why
+                    else:
+                        missing_input = f"needs a ready environment ({why})"
+                    input_action = _act("Validate", f"posttrain env validate {q(e0['name'] if e0 else '<environment>')} --on {q(target)}",
+                                        "env", e0["id"] if e0 else None, "validate")
+        else:
+            ds = by_kind.get(st, [])
+            good = [d for d in ds if d["status"] == "ready"]
+            inputs = f"--data {q(good[0]['name'] if good else ds[0]['name'])}" if ds else f"--data <{'pairs' if st == 'preference' else 'dataset'}>"
+            if not ds:
+                missing_input = f"needs {'a preference' if st == 'preference' else 'an SFT'} dataset"
+                f = "pairs.jsonl" if st == "preference" else "train.jsonl"
+                input_action = _act("Add dataset", f"posttrain data add ./{f} --kind {st}", "add", "dataset", "add_dataset")
+            elif not good:
+                blocked_input = f"{dataset_label(ds[0])} is blocked"
+                input_action = _act("Fix dataset", f"posttrain data add <file> --kind {st} --name {q(ds[0]['name'])} --fix", "page",
+                                    f"/datasets/{ds[0]['id']}", "fix_dataset")
+        launch_cli = f"posttrain train {CLI_STAGE[st]} --base {q(start_from(st))} {inputs} --on {q(target)}"
+        launch = _act(f"Launch {LABEL[st] if st != 'preference' else 'preference'}", launch_cli, "launch", CLI_STAGE[st], "launch")
+        objects = [run_obj(r) for r in rs]
+        blocked_by, implicit = None, None
+        if st not in planned:
+            status, nxt, implicit = "skipped", launch, "not planned"
+        elif st in skip:
+            status, nxt = "skipped", None
+        elif done_models:
+            status, nxt = "done", None
+        elif active:
+            status, nxt = "in_progress", _act("Watch", f"posttrain runs watch {q(active[0]['name'])}", "run", active[0]["id"], "watch")
+        elif unevaluated:
+            m, got, missing = unevaluated[0]
+            status = "in_progress"
+            nxt = _act("Run quick eval", f"posttrain eval {q(m['name'])} --suite quick --on {q(target)}", "eval", m["name"], "eval",
+                       needs=f"{m['name']} has no quick eval" + (f" on {', '.join(missing)}" if missing and got else ""))
+        elif ended:
+            r = ended[0]
+            status = "in_progress"
+            nxt = _act("Promote", f"posttrain models promote {q(r['name'])} --as {q(slug(r['name']) + '-v1')}", "run", r["id"], "promote",
+                       needs="promote a checkpoint to make it a model")
+        elif missing_input:
+            status, nxt = "not_started", {**input_action, "needs": missing_input}
+        elif blocked_input:
+            status, blocked_by = "blocked", blocked_input
+            nxt = {**input_action, "needs": blocked_input}
+        else:
+            status, nxt = "not_started", launch
+        rows[st] = {"status": status, "objects": objects, "next": nxt, "launch": launch, "blocked_by": blocked_by, "implicit": implicit,
+                    "models": [model_obj(m, {"complete": True, "evaluated": got, "missing": missing}) for m, got, missing in done_models] +
+                              [model_obj(m, {"complete": False, "evaluated": got, "missing": missing}) for m, got, missing in unevaluated],
+                    "evidence": [{"check": m["name"], "ok": True, "detail": f"promoted from {m.get('run_name')}; quick eval on {', '.join(got) or 'any benchmark'}"}
+                                 for m, got, _ in done_models] +
+                                [{"check": m["name"], "ok": False, "detail": "no quick eval" + (f" on {', '.join(missing)}" if missing else "")}
+                                 for m, _, missing in unevaluated],
+                    "now": "; ".join([f"{m['name']}, from {m.get('run_name')}" for m, _, _ in done_models + unevaluated][:2] +
+                                     [f"{r['name']} {r['status']}" + (f", step {r['steps_done']} of {r['steps_planned']}" if r["status"] == "running"
+                                                                      and r["steps_planned"] else "")
+                                      for r in [r for r in rs if not any(m.get("run_id") == r["id"] for m in mine)][:2]])}
+
+    # ---- eval
+    base_sel = baseline_selector(conn, pid, settings)
+    prod = al.get("production")
+    prod_model = db.one(conn, "SELECT * FROM models WHERE id=?", (prod["model_id"],)) if prod else None
+    prod_sel = model_selector(conn, pid, prod_model) if prod_model else None
+    release_names = suite_names(suites["release"])
+    gates = []
+    for m in promoted[:MAX_GATES]:                 # newest first; the Overview polls this, so older promotions aren't re-checked
+        g = release_gate(conn, pid, model_selector(conn, pid, m), suites, base_sel, prod_sel, cache)
+        gates.append((m, g))
+    passing = [(m, g) for m, g in gates if g["done"]]
+    eval_runs = [r for r in runs if r["kind"] == "eval"]
+    running_evals = [r for r in eval_runs if r["status"] in ACTIVE_RUN] + [e for e in evals if e["status"] == "running"]
+    base_gate = None
+    if base_sel and release_names:
+        base_evs = latest_by_benchmark(evals_of(conn, pid, base_sel), release_names)
+        base_gate = {"model": base_sel["name"], "missing": [n for n in release_names if n not in base_evs]}
+    ev_objs = [run_obj(r) for r in eval_runs if r["status"] in ACTIVE_RUN or r["status"] == "failed"] + [
+        {"type": "eval", "id": e["id"], "name": e["benchmark"], "status": e["status"], "score": e["score"], "stderr": e["stderr"],
+         "metric": e["metric"], "model": e["run_name"] or e["model_name"], "step": e["step"], "n_tasks": e["n_tasks"], "k": e["k"],
+         "n_infra": e["n_infra"]} for e in evals]
+    blocked_by, nxt = None, None
+    newest = gates[0] if gates else None
+    if "eval" in skip:
+        status = "skipped"
+    elif passing:
+        status = "done"
+    elif not release_names:
+        status = "not_started"
+        nxt = _needs("needs a release suite", f"posttrain suites set release --bench {q(','.join(DEFAULT_QUICK))}", "set_suites",
+                     "page", "/evals", "Set suites")
+    elif newest:
+        m, g = newest
+        if not g["missing"] and g["infra_over"]:
+            status = "blocked"
+            blocked_by = "infrastructure errors above 10% on " + ", ".join(f"{n} ({s:.0%})" for n, s in g["infra_over"].items())
+            nxt = _act("Run release eval", f"posttrain eval {q(m['name'])} --suite release --on {q(target)}", "eval", m["name"], "eval", needs=blocked_by)
+        elif g["missing"]:
+            status = "in_progress"
+            nxt = _act("Run release eval", f"posttrain eval {q(m['name'])} --suite release --on {q(target)}", "eval", m["name"], "eval",
+                       needs=f"{m['name']} has no release eval on {', '.join(g['missing'])}")
+        elif g["uncompared"]:
+            u = g["uncompared"][0]
+            status = "in_progress"
+            nxt = _act(f"Run {u['role']} eval", f"posttrain eval {q(u['model'])} --suite release --on {q(target)}", "eval", u["model"], "eval",
+                       needs=f"the {u['role']} {u['model']} has no release eval on {', '.join(sorted({x['benchmark'] for x in g['uncompared']}))}")
+        else:
+            r = g["unacknowledged"][0]
+            status = "blocked"
+            blocked_by = (f"{len(g['unacknowledged'])} regression{'s' if len(g['unacknowledged']) != 1 else ''} beyond noise not acknowledged ("
+                          + ", ".join(x["benchmark"] for x in g["unacknowledged"]) + ")")
+            nxt = _act("Acknowledge", f"posttrain evals ack {q(m['name'])} --suite release --bench {q(r['benchmark'])} --note \"…\"",
+                       "page", f"/evals/compare?a={r['a']['eval_id']}&b={r['b']['eval_id']}", "ack", needs=blocked_by)
+    else:
+        status = "in_progress" if running_evals else "not_started"
+        if base_gate and base_gate["missing"]:
+            nxt = _act("Run baseline eval", f"posttrain eval {q(base_gate['model'])} --suite release --on {q(target)}", "eval",
+                       base_gate["model"], "baseline", needs="needs a promoted model")
+        else:
+            cand = next((r for r in runs if r["kind"] in ("sft", "dpo", "rl") and r["status"] in ("completed", "stopped")), None)
+            nxt = _needs("needs a promoted model", f"posttrain models promote {q(cand['name']) if cand else '<run>'} --as "
+                                                    f"{q(slug(cand['name']) + '-v1') if cand else '<name>'}", "promote",
+                         "run" if cand else "page", cand["id"] if cand else "/runs")
+    now_parts = []
+    if newest:
+        m, g = newest
+        now_parts.append(f"{m['name']}: release {len(g['evals'])} of {len(g['benchmarks'])}")
+        if g["regressions"]:
+            now_parts.append(f"{len(g['regressions'])} regression{'s' if len(g['regressions']) != 1 else ''}, "
+                             f"{len(g['regressions']) - len(g['unacknowledged'])} acknowledged")
+    if base_gate:
+        now_parts.append(f"baseline done for {base_gate['model']}" if not base_gate["missing"] else "no release eval of the baseline yet")
+    rows["eval"] = {"status": status, "objects": ev_objs, "next": nxt, "blocked_by": blocked_by, "now": "; ".join(now_parts),
+                    "evidence": [{"check": m["name"], "ok": g["done"],
+                                  "detail": "done" if g["done"] else ("missing " + ", ".join(g["missing"]) if g["missing"] else
+                                                                     "infrastructure errors" if g["infra_over"] else
+                                                                     "not compared with " + g["uncompared"][0]["model"] if g["uncompared"] else
+                                                                     f"{len(g['unacknowledged'])} regression(s) not acknowledged")}
+                                 for m, g in gates[:4]],
+                    "gate": {"model": newest[0]["name"], **{k: newest[1][k] for k in ("missing", "infra_over", "uncompared", "unacknowledged",
+                                                                                     "regressions", "done")}} if newest else None}
+
+    # ---- deploy
+    live = [d for d in deps if (d.get("status") or "") in LIVE_DEPLOYMENT]
+    prod_live = [d for d in live if prod and d["model_id"] == prod["model_id"]]
+    starting = [d for d in deps if d.get("status") == "starting"]
+    latest = deps[0] if deps else None
+    cand_name = passing[0][0]["name"] if passing else (newest[0]["name"] if newest else "<model>")
+    deploy_cli = f"posttrain models deploy {q(cand_name)} --on {q(target)}"
+    blocked_by, nxt = None, None
+    if "deploy" in skip:
+        status = "skipped"
+    elif prod_live:
+        status = "done"
+    elif starting:
+        status = "in_progress"
+        nxt = _act("Watch", "posttrain deployments ls", "page", "/models", "watch_deployment")
+    elif latest and latest.get("status") == "failed" and status_of(rows["eval"]) == "done":
+        status, blocked_by = "blocked", f"deployment {latest['name']} failed: {(latest.get('message') or '').splitlines()[0] if latest.get('message') else 'see posttrain deployments ls'}"
+        nxt = _act("Deploy", deploy_cli, "page", "/models", "deploy", needs=blocked_by)
+    elif status_of(rows["eval"]) == "done":
+        status = "in_progress" if prod else "not_started"
+        nxt = _act("Deploy", deploy_cli, "page", "/models", "deploy",
+                   needs=f"production → {prod['model']}, not served" if prod else None)
+    else:
+        status = "not_started"
+        nxt = _needs("needs the Eval stage", deploy_cli, "deploy", "page", "/models")
+    rows["deploy"] = {"status": status, "blocked_by": blocked_by, "next": nxt,
+                      "objects": [{"type": "deployment", "id": d["id"], "name": d["name"], "status": d["status"], "model": d["model_name"],
+                                   "endpoint": d["endpoint"], "kind": d.get("kind") if "kind" in dep_cols else None} for d in deps],
+                      "evidence": [{"check": "production", "ok": bool(prod), "detail": f"production → {prod['model']}" if prod else "no production model"},
+                                   {"check": "served", "ok": bool(prod_live), "detail": ", ".join(f"{d['name']} {d['status']}" for d in prod_live) or "not served"}],
+                      "now": "; ".join([f"{d['name']} {d['status']}" + (f" at {d['endpoint']}" if d.get("endpoint") else "") for d in deps[:2]] +
+                                       ([f"production → {prod['model']}"] if prod else []))}
+
+    # a stage nobody did while a later one went ahead is skipped (RL straight from a base model skips SFT and preference)
+    progressed = {s for s in STAGES if rows[s]["status"] in ("done", "in_progress", "blocked")}
+    for s, later in (("sft", ("preference", "rl")), ("preference", ("rl",)), ("environments", ("rl",))):
+        if rows[s]["status"] == "not_started" and progressed & set(later):
+            rows[s]["status"] = "skipped"
+            rows[s]["implicit"] = "a later stage went ahead without it"
+            if rows[s].get("launch"):
+                rows[s]["next"] = rows[s]["launch"]
+    for s in STAGES:
+        if s in skip:
+            k = skip[s]
+            rows[s]["skipped"] = {"by": k["by"], "at": k["at"], "note": k["note"], "implicit": False}
+            rows[s]["next"] = _act("Unskip", f"posttrain status --unskip {s}", "page", "/settings", "unskip", needs=
+                                   f"skipped by {k['by']}" + (f": \"{k['note']}\"" if k.get("note") else ""))
+        elif rows[s]["status"] == "skipped":
+            rows[s]["skipped"] = {"by": None, "at": None, "note": rows[s].get("implicit"), "implicit": True}
+        else:
+            rows[s]["skipped"] = None
+    out = []
+    for s in STAGES:
+        r = rows[s]
+        out.append({"key": s, "stage": s, "label": LABEL[s], "status": r["status"], "status_label": STATUS_LABEL[r["status"]],
+                    "done_when": DONE_WHEN[s], "now": r.get("now") or "", "blocked_by": r.get("blocked_by"),
+                    "skipped": r.get("skipped"), "planned": s not in PLANNABLE or s in planned, "evidence": r.get("evidence") or [],
+                    "objects": r["objects"][:6], "total": len(r["objects"]), "next": r["next"],
+                    **({"models": r["models"]} if "models" in r else {}), **({"gate": r["gate"]} if "gate" in r else {})})
+    nxt = next((s["key"] for s in out if s["status"] in ("not_started", "in_progress", "blocked") and s["next"] and s["next"].get("label")), None)
+    online = {t["name"]: t.get("runners") or [] for t in compute["targets"]}
+    waiting = []
+    if source == "workspace":
+        for j in db.rows(conn, "SELECT j.id, j.run_id, j.target, j.created_at, r.name AS run_name FROM jobs j JOIN runs r ON r.id=j.run_id "
+                               "WHERE j.project_id=? AND j.status='queued' ORDER BY j.created_at", (pid,)):
+            if not online.get(j["target"]):
+                waiting.append(j)
+    counts = {"datasets": len(datasets), "environments": len(envs), "runs": len(runs), "evals": len(evals), "models": len(models),
+              "deployments": len(deps), "promoted": len(promoted)}
+    return {"schema": "posttrain.v1.stages", "id": pid, "url": project_url(org, project), "ref": f"{org}/{project}",
+            "project": p, "settings": settings, "suites": {k: {"benchmarks": [b["spec"] for b in v["benchmarks"]], "defined": v["defined"],
+                                                               "inherits": v["inherits"]} for k, v in suites.items()},
+            "production": prod, "stages": out, "next": nxt,
+            "empty": not any(v for k, v in counts.items() if k not in ("models", "promoted")), "counts": counts, "waiting": waiting,
+            "active": any(s["status"] == "in_progress" for s in out) or bool(waiting),
+            "approx": {} if workspace else {"promoted": "a completed run's output model (example projects record no promotions)"},
+            "compute": [{"name": t["name"], "kind": t["kind"], "runners": t.get("runners") or [], "builtin": bool(t.get("builtin"))}
+                        for t in compute["targets"]]}
+
+
+def status_of(row):
+    return row["status"]
+
+
+def audit(conn, pid, user, action, obj, detail=None):
+    conn.execute("INSERT INTO audit (project_id, t, user, action, object, detail) VALUES (?,?,?,?,?,?)",
+                 (pid, now(), user, action, obj, json.dumps(detail or {}, default=str)))
+
+
+# ------------------------------------------------------------------ comparisons (evals compare)
+
+def eval_row(conn, pid, eval_id):
+    e = db.one(conn, "SELECT e.*, b.name AS benchmark, b.metric, m.name AS model_name, r.name AS run_name FROM evals e "
+                     "JOIN benchmarks b ON b.id=e.benchmark_id LEFT JOIN models m ON m.id=e.model_id LEFT JOIN runs r ON r.id=e.run_id "
+                     "WHERE e.project_id=? AND e.id=?", (pid, eval_id))
+    if not e:
+        raise Problem(404, f"No eval {eval_id!r} in this project (posttrain evals ls).")
+    return e
+
+
+def _eval_label(e):
+    if e.get("run_name") and e.get("step") is not None and not e.get("model_name"):
+        return f"{e['run_name']}:{e['step']}"
+    return e.get("model_name") or e.get("run_name") or e["id"]
+
+
+def comparison(conn, pid, org, project, a=None, b=None, models=None, suite=None, bench=None):
+    """`posttrain evals compare`: B against A on every benchmark, with the change, its SE and a verdict (PRD 4.6).
+
+    Either two eval ids (a, b: one benchmark), or two model references (`models` "A,B") on a suite's benchmarks,
+    on `bench` ("B1,B2"), or on every benchmark either model has an eval of."""
+    from urllib.parse import quote
+    cache = {}
+    suites = get_suites(conn, pid)
+    if a and b:
+        ea, eb = eval_row(conn, pid, a), eval_row(conn, pid, b)
+        if ea["benchmark_id"] != eb["benchmark_id"]:
+            raise Problem(422, f"{a} is an eval of {ea['benchmark']} and {b} of {eb['benchmark']}: compare evals of one benchmark")
+        rows = [compare_row(conn, ea["benchmark"], ea, eb, cache)]
+        side = [{"ref": a, "name": _eval_label(ea), "model_id": ea["model_id"], "eval_id": a},
+                {"ref": b, "name": _eval_label(eb), "model_id": eb["model_id"], "eval_id": b}]
+        mb = db.one(conn, "SELECT * FROM models WHERE id=?", (eb["model_id"],)) if eb.get("model_id") else None
+        sel_b = model_selector(conn, pid, mb) if mb else None
+        url = project_url(org, project, f"/evals/compare?a={a}&b={b}")
+        ident = f"{a}..{b}"
+    else:
+        refs = [x.strip() for x in str(models or "").split(",") if x.strip()]
+        if len(refs) != 2:
+            raise Problem(422, "compare two evals (EVAL_A EVAL_B) or two models (--models A,B)")
+        sels = []
+        for r in refs:
+            s = resolve_ref(conn, pid, r)
+            if not s:
+                raise Problem(404, f"No model {r!r} in this project: use a model name, a Hugging Face id it evaluated, a run, or RUN:STEP.")
+            sels.append(s)
+        sa, sel_b = sels
+        all_a, all_b = latest_by_benchmark(evals_of(conn, pid, sa)), latest_by_benchmark(evals_of(conn, pid, sel_b))
+        if suite:
+            if suite not in suites:
+                raise Problem(404, f"No suite {suite!r} (suites: {', '.join(suites)}).")
+            names = suite_names(suites[suite])
+            if not names:
+                raise Problem(422, f"suite {suite} is empty (posttrain suites set {suite} --bench BENCH,...)")
+        elif bench:
+            names = [x.strip() for x in str(bench).split(",") if x.strip()]
+        else:
+            names = sorted(set(all_a) | set(all_b))
+        rows = [compare_row(conn, n, all_a.get(n), all_b.get(n), cache) for n in names]
+        side = [{"ref": refs[0], "name": sa["name"], "model_id": (sa["model"] or {}).get("id")},
+                {"ref": refs[1], "name": sel_b["name"], "model_id": (sel_b["model"] or {}).get("id")}]
+        url = project_url(org, project, f"/evals/compare?models={quote(','.join(refs), safe='')}"
+                                        + (f"&suite={quote(suite)}" if suite else f"&bench={quote(bench)}" if bench else ""))
+        ident = f"{sa['key']}..{sel_b['key']}" + (f":{suite}" if suite else "")
+    acks = acks_for(conn, pid, sel_b, suite) if sel_b else {}
+    for r in rows:
+        r["acknowledged"] = acks.get(r["benchmark"]) if r["verdict"] == "regressed" else None
+        if r["a"] and r["b"]:
+            r["url"] = project_url(org, project, f"/evals/compare?a={r['a']['eval_id']}&b={r['b']['eval_id']}")
+    counts = {v: sum(1 for r in rows if r["verdict"] == v) for v in ("improved", "regressed", "within_noise", "unknown", "missing")}
+    unacked = [r["benchmark"] for r in rows if r["verdict"] == "regressed" and not r["acknowledged"]]
+    ack_suite = suite or next((s for s in ("release", "quick") if set(unacked) <= set(suite_names(suites[s]))), "release")
+    return {"schema": "posttrain.v1.eval_comparison", "id": ident, "url": url, "a": side[0], "b": side[1], "suite": suite,
+            "benchmarks": rows, "counts": counts, "regressions": counts["regressed"], "unacknowledged": unacked,
+            "next": [f"posttrain evals ack {q(side[1]['ref'])} --suite {q(ack_suite)} --bench {q(n)} --note \"…\"" for n in unacked]}
+
+
+# ------------------------------------------------------------------ models show
+
+def model_detail(conn, pid, org, project, ref):
+    sel = resolve_ref(conn, pid, ref)
+    if not sel:
+        raise Problem(404, f"No model {ref!r} in this project (posttrain models ls).")
+    m = sel["model"]
+    suites = get_suites(conn, pid)
+    promo = promotion_of(conn, (m or {}).get("id"))
+    run = sel["run"]
+    parent = None
+    pid_ = (m or {}).get("parent_id") or (run or {}).get("base_model_id")
+    if pid_:
+        pm = db.one(conn, "SELECT id, name, kind, hf_repo FROM models WHERE id=?", (pid_,))
+        parent = pm and {"id": pm["id"], "name": pm["name"], "kind": pm["kind"], "hf_repo": pm["hf_repo"]}
+    target, kind = run_target(conn, run) if run else (None, None)
+    weights = (promo or {}).get("pushed_to") or (promo or {}).get("weights")
+    if not weights and m and m.get("hf_repo"):
+        weights = f"hf://{m['hf_repo']}"
+    if not weights and run and sel["step"] is not None:
+        ck = db.one(conn, "SELECT path FROM checkpoints WHERE run_id=? AND step=? ORDER BY created_at DESC LIMIT 1", (run["id"], sel["step"]))
+        weights = weights_uri(ck["path"], target, kind) if ck else None
+    in_suite = {}
+    for sname, s in suites.items():
+        for n in suite_names(s):
+            in_suite.setdefault(n, []).append(sname)
+    evals = [{"id": e["id"], "benchmark": e["benchmark"], "metric": e.get("metric"), "status": e["status"], "score": e["score"],
+              "stderr": e["stderr"], "n_tasks": e["n_tasks"], "k": e["k"], "n_infra": e["n_infra"], "step": e.get("step"),
+              "run_id": e.get("run_id"), "suites": in_suite.get(e["benchmark"], []), "ended_at": e.get("ended_at")}
+             for e in reversed(evals_of(conn, pid, sel, completed=False))]
+    al = [a for a, v in aliases(conn, pid).items() if v["model_id"] in sel["model_ids"]]
+    deps = []
+    if sel["model_ids"]:
+        ids = sorted(sel["model_ids"])
+        deps = db.rows(conn, f"SELECT * FROM deployments WHERE project_id=? AND model_id IN ({','.join('?' for _ in ids)}) ORDER BY created_at DESC",
+                       [pid, *ids])
+    children = []
+    if m:
+        children = [{"id": c["id"], "name": c["name"]} for c in db.rows(conn, "SELECT id, name FROM models WHERE project_id=? AND parent_id=? "
+                                                                               "AND coalesce(status,'') != 'replaced'", (pid, m["id"]))]
+    name = sel["name"]
+    return {"schema": "posttrain.v1.model", "id": (m or {}).get("id") or sel["key"], "url": project_url(org, project, f"/models/{name}"),
+            "name": name, "kind": (m or {}).get("kind") or "checkpoint", "status": (m or {}).get("status"), "stage": (m or {}).get("stage") or (run or {}).get("stage"),
+            "hf_repo": (m or {}).get("hf_repo"), "parent": parent,
+            "run": {"id": run["id"], "name": run["name"], "kind": run["kind"], "status": run["status"]} if run else None,
+            "step": sel["step"], "weights": weights,
+            "weights_target": "hub" if str(weights or "").startswith("hf://") else (promo or {}).get("weights_target") or target,
+            "promoted": bool(promo), "promotion": {"by": promo["by"], "at": promo["at"], "rule": promo["rule"], "notes": promo["notes"],
+                                                   "steps": promo["steps"], "pushed_to": promo["pushed_to"]} if promo else None,
+            "aliases": al, "evals": evals, "deployments": [deployment_object(org, project, d) for d in deps], "children": children,
+            "notes": (m or {}).get("notes")}
+
+
+# ------------------------------------------------------------------ writes (called inside workspace.write)
+
+def promote(conn, pid, org, project, ref, name, user, notes=None, replace=False, dry_run=False):
+    """Promote a run's checkpoint to a named model (PRD 4.7); returns the model with the table the choice used."""
+    name = str(name or "").strip()
+    if not MODEL_NAME.fullmatch(name):
+        raise Problem(422, f"model name {name!r}: letters, digits, '.', '-' and '_' (no '/', which Hugging Face ids use)")
+    plan = promotion_plan(conn, pid, ref, name)
+    taken = db.rows(conn, "SELECT m.*, p.run_id AS p_run, p.step AS p_step FROM models m LEFT JOIN promotions p ON p.model_id=m.id "
+                          "WHERE m.project_id=? AND (m.name=? OR m.hf_repo=?) AND coalesce(m.status,'') != 'replaced'", (pid, name, name))
+    if taken and not replace:
+        t = taken[0]
+        what = (f"promoted from {find_run(conn, pid, t['p_run'])['name'] if t['p_run'] and find_run(conn, pid, t['p_run']) else 'a run'} "
+                f"step {t['p_step']}" if t.get("p_run") else f"a {t['kind']} model")
+        raise Problem(409, f"{name} already exists ({what}); pass --replace to point the name at this checkpoint")
+    result = {"schema": "posttrain.v1.model", "id": f"{plan['run']['id']}:{plan['step']}", "url": project_url(org, project, f"/models/{name}"), "name": name,
+              "dry_run": bool(dry_run), "run": plan["run"], "step": plan["step"], "last_step": plan["last_step"], "steps": plan["steps"],
+              "benchmarks": plan["benchmarks"], "table": plan["table"], "rule": plan["rule"], "weights": plan["weights"],
+              "weights_target": plan["weights_target"], "parent": plan["parent"], "notes": notes or "", "replaced": [],
+              "running": plan["running"]}
+    if dry_run:
+        return result
+    t = now()
+    for old in taken:
+        new_name = f"{old['name']} (replaced {time.strftime('%Y-%m-%d %H:%M', time.localtime(t))})"
+        conn.execute("UPDATE models SET name=?, status='replaced' WHERE id=?", (new_name, old["id"]))
+        result["replaced"].append({"id": old["id"], "name": new_name})
+    mid = "model_" + __import__("secrets").token_hex(6)
+    loc = parse_weights(plan["weights"]) if plan["weights"] else {}
+    run = find_run(conn, pid, plan["run"]["id"])
+    db.insert(conn, "models", {"id": mid, "project_id": pid, "name": name, "kind": "checkpoint",
+                               "hf_repo": loc.get("path") if loc.get("scheme") == "hf" else None,
+                               "parent_id": run.get("base_model_id"), "run_id": run["id"], "step": plan["step"], "stage": run.get("stage"),
+                               "created_at": t, "status": "promoted", "notes": notes or "", "source": ""})
+    for old in taken:
+        conn.execute("UPDATE promotions SET replaced_by=? WHERE model_id=?", (mid, old["id"]))
+    conn.execute("INSERT OR REPLACE INTO promotions (model_id, project_id, run_id, step, checkpoint_id, weights, weights_target, pushed_to, "
+                 "rule, steps, notes, by, at, replaced_by) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                 (mid, pid, run["id"], plan["step"], plan["checkpoint_id"], plan["weights"], plan["weights_target"], None, plan["rule"],
+                  json.dumps(plan["table"]), notes or "", user, t, None))
+    if plan["checkpoint_id"]:
+        conn.execute("UPDATE checkpoints SET model_id=? WHERE id=? AND model_id IS NULL", (mid, plan["checkpoint_id"]))
+    conn.execute("INSERT INTO run_events (run_id, t, step, kind, severity, title, body) VALUES (?,?,?,?,?,?,?)",
+                 (run["id"], t, plan["step"], "notice", "info", f"Promoted as {name}", f"step {plan['step']} by {user}: {plan['rule']}"))
+    audit(conn, pid, user, "promote", mid, {"name": name, "run": run["id"], "step": plan["step"], "rule": plan["rule"]})
+    result.update(id=mid, promoted_by=user, promoted_at=t)
+    return result
+
+
+def acknowledge(conn, pid, org, project, model, suite, bench, note, user):
+    note = str(note or "").strip()
+    if not note:
+        raise Problem(422, "an acknowledgement needs a note: why this regression is acceptable (--note TEXT)")
+    suites = get_suites(conn, pid)
+    if suite not in suites:
+        raise Problem(404, f"No suite {suite!r} (suites: {', '.join(suites)}).")
+    sel = resolve_ref(conn, pid, model)
+    if not sel:
+        raise Problem(404, f"No model {model!r} in this project (posttrain models ls).")
+    names = suite_names(suites[suite])
+    if bench not in names:
+        raise Problem(404, f"No benchmark {bench!r} in suite {suite} ({', '.join(names) or 'empty'}).")
+    settings = get_settings(conn, pid)
+    base = baseline_selector(conn, pid, settings)
+    al = aliases(conn, pid).get("production")
+    pm = db.one(conn, "SELECT * FROM models WHERE id=?", (al["model_id"],)) if al else None
+    against = []
+    mine = latest_by_benchmark(evals_of(conn, pid, sel), [bench]).get(bench)
+    for role, ref in (("baseline", base), ("production", model_selector(conn, pid, pm) if pm else None)):
+        if ref and ref["key"] != sel["key"] and not (ref["model_ids"] & sel["model_ids"]):
+            theirs = latest_by_benchmark(evals_of(conn, pid, ref), [bench]).get(bench)
+            if mine and theirs:
+                row = compare_row(conn, bench, theirs, mine)
+                against.append({"role": role, "model": ref["name"], "delta": row["delta"], "se_diff": row["se_diff"], "verdict": row["verdict"]})
+    aid = "ack_" + __import__("secrets").token_hex(6)
+    t = now()
+    conn.execute("DELETE FROM acks WHERE project_id=? AND model_key=? AND suite=? AND benchmark=?", (pid, sel["key"], suite, bench))
+    conn.execute("INSERT INTO acks (id, project_id, model_key, model_id, model_name, suite, benchmark, note, by, at, comparison) "
+                 "VALUES (?,?,?,?,?,?,?,?,?,?,?)", (aid, pid, sel["key"], (sel["model"] or {}).get("id"), sel["name"], suite, bench, note,
+                                                    user, t, json.dumps(against)))
+    audit(conn, pid, user, "ack", aid, {"model": sel["name"], "suite": suite, "benchmark": bench, "note": note})
+    return {"schema": "posttrain.v1.acknowledgement", "id": aid, "url": project_url(org, project, f"/evals?suite={suite}"),
+            "model": sel["name"], "model_id": (sel["model"] or {}).get("id"), "suite": suite, "benchmark": bench, "note": note,
+            "by": user, "at": t, "comparisons": against,
+            "regressed": any(x["verdict"] == "regressed" for x in against)}
+
+
+def list_acks(conn, pid, org, project, model=None, suite=None):
+    if not has_table(conn, "acks"):
+        return []
+    rows = db.rows(conn, "SELECT * FROM acks WHERE project_id=? ORDER BY at DESC", (pid,))
+    if model:
+        sel = resolve_ref(conn, pid, model)
+        keys = ack_keys(sel) if sel else {model}
+        rows = [r for r in rows if r["model_key"] in keys]
+    if suite:
+        rows = [r for r in rows if r["suite"] == suite]
+    return [{"schema": "posttrain.v1.acknowledgement", "id": r["id"], "url": project_url(org, project, f"/evals?suite={r['suite']}"),
+             "model": r["model_name"], "model_id": r["model_id"], "suite": r["suite"], "benchmark": r["benchmark"], "note": r["note"],
+             "by": r["by"], "at": r["at"], "comparisons": r["comparison"] if isinstance(r["comparison"], list) else []} for r in rows]
+
+
+def deployment_object(org, project, d):
+    return {"schema": "posttrain.v1.deployment", "id": d["id"], "url": project_url(org, project, f"/models?deployment={d['name']}"),
+            "name": d["name"], "kind": d.get("kind") or "vllm", "status": d.get("status"), "model_id": d.get("model_id"),
+            "model": d.get("model_name"), "target": d.get("target"), "endpoint": d.get("endpoint"), "gpu": d.get("gpu"),
+            "replicas": d.get("replicas"), "serving": d.get("serving"), "smoke": d.get("smoke"), "message": d.get("message"),
+            "command": d.get("command"), "checks": d.get("checks"), "handle": d.get("handle"), "created_at": d.get("created_at"),
+            "created_by": d.get("created_by"), "updated_at": d.get("updated_at"), "stopped_at": d.get("stopped_at"),
+            "stopped_by": d.get("stopped_by")}
+
+
+def list_deployments(conn, pid, org, project):
+    rows = db.rows(conn, "SELECT d.*, m.name AS model_name FROM deployments d LEFT JOIN models m ON m.id=d.model_id WHERE d.project_id=? "
+                         "ORDER BY d.created_at DESC", (pid,))
+    return [deployment_object(org, project, d) for d in rows]
+
+
+def model_gate(conn, pid, sel):
+    """The model-level deploy checks (promoted, release eval complete, regressions acknowledged): what `production` needs."""
+    promo = promotion_of(conn, (sel["model"] or {}).get("id"))
+    settings, suites = get_settings(conn, pid), get_suites(conn, pid)
+    al = aliases(conn, pid).get("production")
+    pm = db.one(conn, "SELECT * FROM models WHERE id=?", (al["model_id"],)) if al else None
+    g = release_gate(conn, pid, sel, suites, baseline_selector(conn, pid, settings), model_selector(conn, pid, pm) if pm else None)
+    why = None if promo else f"{sel['name']} is not promoted"
+    why = why or ("its release eval is incomplete" if not g["complete"] else "it isn't compared with the baseline" if g["uncompared"]
+                  else "a regression is not acknowledged" if g["unacknowledged"] else None)
+    return why is None, why
+
+
+def set_alias(conn, pid, alias, model_id, user):
+    conn.execute("INSERT OR REPLACE INTO model_aliases (project_id, alias, model_id, set_by, set_at) VALUES (?,?,?,?,?)",
+                 (pid, alias, model_id, user, now()))
+    if alias == "production":
+        conn.execute("UPDATE models SET status='promoted' WHERE project_id=? AND status='released' AND id != ?", (pid, model_id))
+        conn.execute("UPDATE models SET status='released' WHERE id=? AND coalesce(status,'') IN ('promoted', 'released', 'available', '')", (model_id,))
+    audit(conn, pid, user, "alias", alias, {"model_id": model_id})
diff --git a/viewer/static/app.js b/viewer/static/app.js
new file mode 100644
index 0000000000000000000000000000000000000000..c545e8e5d25dc51f0e6e39ba6d36a63c8a995237
--- /dev/null
+++ b/viewer/static/app.js
@@ -0,0 +1,224 @@
+import { html, render, useState, useEffect, useRef, useLocation, navigate, Link, BASE, useApi, api, getSource, setProjectSource, server,
+  setQuery, useKey, projectBase, invalidate } from "./lib.js";
+import { Icon, Loading, Err } from "./ui/common.js";
+import * as f from "./ui/fmt.js";
+import { RolloutDrawer } from "./ui/drawer.js";
+import { Overview } from "./pages/overview.js";
+import { Runs, Run, CompareRuns } from "./pages/runs.js";
+import { NewRun } from "./pages/launch.js";
+import { Evals, EvalDetail, Compare } from "./pages/evals.js";
+import { Environments, Environment } from "./pages/environments.js";
+import { Datasets, Dataset } from "./pages/datasets.js";
+import { Models } from "./pages/models.js";
+import { Task } from "./pages/task.js";
+import { Home, SOURCES } from "./pages/home.js";
+import { Jobs, Usage, Reports } from "./pages/ops.js";
+import { Compute } from "./pages/compute.js";
+import { Settings } from "./pages/settings.js";
+import { NewProjectDialog } from "./pages/newproject.js";
+
+// [slug, label, icon, only in writable projects]
+const NAV = [
+  { group: null, items: [["", "Overview", "overview"]] },
+  { group: "Train", items: [["runs", "Runs", "runs"], ["evals", "Evals", "evals"]] },
+  { group: "Inputs", items: [["environments", "Environments", "environments"], ["datasets", "Datasets", "datasets"], ["models", "Models", "models"]] },
+  { group: "Operate", items: [["jobs", "Jobs", "jobs"], ["compute", "Compute", "compute", true], ["usage", "Usage", "usage"], ["reports", "Reports", "reports"]] },
+];
+const PILL = { workspace: "Your workspace", demo: "Example project", live: "BenchFlow runs" };
+
+/** The org entry and project for a URL; the same org slug can appear in more than one source. */
+export function findProject(meta, org, project) {
+  const o = (meta.orgs || []).find((x) => x.slug === org && x.projects.some((p) => p.slug === project));
+  return o ? { org: o, project: o.projects.find((p) => p.slug === project), source: o.source } : null;
+}
+
+function Switcher({ meta, org, project }) {
+  const [open, setOpen] = useState(false);
+  const ref = useRef(null);
+  useEffect(() => {
+    const close = (e) => { if (ref.current && !ref.current.contains(e.target)) setOpen(false); };
+    const esc = (e) => { if (e.key === "Escape") setOpen(false); };
+    document.addEventListener("mousedown", close);
+    document.addEventListener("keydown", esc);
+    return () => { document.removeEventListener("mousedown", close); document.removeEventListener("keydown", esc); };
+  }, []);
+  const here = findProject(meta, org, project);
+  return html`<div class="crumbs">
+    <div class="switcher" ref=${ref}>
+      <button onClick=${() => setOpen(!open)} aria-haspopup="menu" aria-expanded=${open}>
+        ${here ? html`<span>${here.org.name}</span><span class="sep">/</span><span>${here.project.name}</span>` : html`<span>All projects</span>`}<span class="caret">▼</span>
+      </button>
+      ${open ? html`<div class="menu" role="menu">
+        <${Link} href=${BASE} onClick=${() => setOpen(false)}><span>All projects</span></${Link}>
+        ${SOURCES.map((s) => {
+          const orgs = (meta.orgs || []).filter((o) => o.source === s.key);
+          if (!orgs.length && s.key !== "workspace") return null;
+          return html`<div class="group-label">${s.title}</div>
+            ${orgs.flatMap((og) => og.projects.map((pj) => html`<${Link} href=${projectBase(og.slug, pj.slug)}
+                class=${og.slug === org && pj.slug === project ? "active" : ""} onClick=${() => setOpen(false)}>
+              <span>${pj.name}</span><span class="item-sub">${og.name}${pj.summary ? ` · ${pj.summary}` : ""}</span></${Link}>`))}
+            ${!orgs.length ? html`<div class="menu-empty">None yet</div>` : null}`;
+        })}
+        <div class="menu-sep"></div>
+        <button class="item" role="menuitem" onClick=${() => { setOpen(false); setQuery({ new: "project" }, { replace: false }); }}>
+          <span class="row" style="gap:7px"><${Icon} name="plus" size=${14} />New project</span></button>
+      </div>` : null}
+    </div>
+  </div>`;
+}
+
+function Palette({ ctx, onClose }) {
+  const [q, setQ] = useState("");
+  const [res, setRes] = useState([]);
+  const [i, setI] = useState(0);
+  useEffect(() => {
+    if (!q.trim()) { setRes([]); return; }
+    let live = true;
+    api("/search", { q, org: ctx.org, project: ctx.project }).then((r) => live && (setRes(r), setI(0)));
+    return () => { live = false; };
+  }, [q]);
+  const go = (r) => {
+    const base = projectBase(r.org, r.project);
+    const to = { run: `/runs/${r.id}`, eval: `/evals?benchmark=${r.id}`, environment: `/environments/${r.id}`, dataset: `/datasets/${r.id}`,
+      model: `/models`, task: `/tasks/${r.id}`, event: `/runs/${r.run_id}?tab=events&event=${r.id}` }[r.type];
+    onClose();
+    navigate(base + to);
+  };
+  return html`<div class="palette-overlay" onMouseDown=${(e) => e.target === e.currentTarget && onClose()}>
+    <div class="palette">
+      <input autofocus placeholder="Jump to a run, benchmark, environment, dataset, task, model or run event" value=${q}
+        onInput=${(e) => setQ(e.target.value)}
+        onKeyDown=${(e) => {
+          if (e.key === "Escape") onClose();
+          if (e.key === "ArrowDown") { e.preventDefault(); setI(Math.min(res.length - 1, i + 1)); }
+          if (e.key === "ArrowUp") { e.preventDefault(); setI(Math.max(0, i - 1)); }
+          if (e.key === "Enter" && res[i]) go(res[i]);
+        }} />
+      <div class="results">
+        ${!q ? html`<div class="empty">Search this project by name.</div>` : null}
+        ${q && !res.length ? html`<div class="empty">No matches.</div>` : null}
+        ${res.map((r, j) => html`<div class=${`res ${j === i ? "on" : ""}`} onMouseEnter=${() => setI(j)} onClick=${() => go(r)}>
+          <span class="type">${r.type}</span>
+          <span class="grow ellipsis" title=${r.type === "event" && r.body ? `${r.name}: ${r.body}` : r.name}>${r.name}${r.type === "event" && r.body ? html`<span class="muted"> · ${r.body}</span>` : null}</span>
+          <span class="muted small nowrap">${r.sub || ""}${r.type === "event" && r.step !== null && r.step !== undefined ? ` · step ${r.step}` : ""}</span></div>`)}
+      </div>
+    </div></div>`;
+}
+
+function Sidebar({ ctx, section }) {
+  const m = ctx.metaInfo || {};
+  const foot = ctx.source === "demo" && m.now ? `Example data, read-only. Clock frozen at ${f.date(+m.now)}.`
+    : ctx.source === "live" && m.now ? `Read-only snapshot of BenchFlow's runs, ${f.date(+m.now)}.` : null;
+  return html`<aside class="sidebar" onClick=${(e) => { if (e.target.closest("a")) document.body.classList.remove("nav-open"); }}><nav class="nav">
+    ${NAV.map((g) => html`<div class="nav-group">
+      ${g.group ? html`<div class="nav-label">${g.group}</div>` : null}
+      ${g.items.filter((it) => !it[3] || ctx.writable).map(([slug, label, icon]) => html`<${Link} href=${ctx.base + (slug ? `/${slug}` : "")} class=${section === slug ? "on" : ""}>
+        <${Icon} name=${icon} />${label}</${Link}>`)}
+    </div>`)}
+    <div class="nav-group"><${Link} href=${ctx.base + "/settings"} class=${section === "settings" ? "on" : ""}><${Icon} name="settings" />Settings</${Link}></div>
+  </nav>
+  <div class="foot">${foot}</div>
+  </aside>`;
+}
+
+function Brand() {
+  return html`<${Link} href=${BASE} class="brand" title="All projects"><img class="brand-mark" src="/dashboard/static/benchflow-mark.svg" alt="" /><span class="brand-name">PostTrain</span></${Link}>`;
+}
+
+// A project URL that /meta doesn't list: ask once more (the CLI may have just created it), then say so.
+const rechecked = new Set();
+
+function Shell() {
+  const { parts, query } = useLocation();
+  const metaState = useApi("/meta", { source: "" });
+  const [palette, setPalette] = useState(false);
+  useKey((e) => {
+    if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === "k") { e.preventDefault(); setPalette(true); }
+    if (e.key === "/" ) { e.preventDefault(); setPalette(true); }
+  }, []);
+  useEffect(() => {
+    const f2 = (e) => { if ((e.metaKey || e.ctrlKey) && e.key.toLowerCase() === "k") { e.preventDefault(); setPalette(true); } };
+    window.addEventListener("keydown", f2, true);
+    return () => window.removeEventListener("keydown", f2, true);
+  }, []);
+  const meta = metaState.data;
+  if (metaState.error && !meta) return html`<div class="main" style="margin-left:0"><${Err} error=${metaState.error} /></div>`;
+  if (!meta) return html`<${Loading} />`;
+  server.open = !!meta.open;
+  document.body.classList.toggle("readonly", !!meta.readonly);   // a public read-only console: hide everything that changes something
+  const [org, project, section = "", id] = parts;
+  const here = org && project ? findProject(meta, org, project) : null;
+  setProjectSource(here ? here.source : null);
+  const src = here ? here.source : null;
+  const clock = src && (meta.metas || {})[src] ? (meta.metas[src].now ? +meta.metas[src].now : null) : null;
+  f.setNow(clock);
+  const dialog = query.get("new") === "project"
+    ? html`<${NewProjectDialog} meta=${meta} onClose=${() => setQuery({ new: null })} />` : null;
+  const bare = (content, cls = "") => html`
+    <header class="topbar">
+      <${Brand} />
+      <${Switcher} meta=${meta} org=${org || ""} project=${project || ""} />
+      <span class="spacer"></span>
+      <${Link} href=${`${BASE}/settings`} class="icon-btn" title="Settings" aria-label="Settings"><${Icon} name="settings" /></${Link}>
+    </header>
+    <main class=${`main bare ${cls}`}>${content}</main>
+    ${dialog}`;
+  if (!org) return bare(html`<${Home} meta=${meta} />`);
+  if (org === "settings" && !project) return bare(html`<${Settings} ctx=${{ meta, metaInfo: {}, query, source: null, writable: false, open: !!meta.open }} />`, "narrow");
+  if (!project) return bare(html`<${Home} meta=${meta} />`);
+  if (!here && !query.get("source")) {
+    const key = `${org}/${project}`;
+    if (!rechecked.has(key)) {
+      rechecked.add(key);
+      setTimeout(invalidate, 0);
+      return html`<${Loading} />`;
+    }
+    return bare(html`<div class="page-head"><div class="grow"><h1>No project ${org}/${project}</h1>
+      <p class="lede">It isn't in your workspace or in the example projects. It may have been renamed, or the link has a typo.</p>
+      <p><${Link} href=${BASE}>All projects</${Link}></p></div></div>`);
+  }
+  const ctx = { org, project, base: projectBase(org, project), meta, metaInfo: src ? (meta.metas || {})[src] || {} : {}, query,
+    source: src || getSource(), writable: src === "workspace", open: !!meta.open, info: here && here.project, orgInfo: here && here.org };
+  const rollout = query.get("rollout");
+  let page;
+  if (section === "") page = html`<${Overview} ctx=${ctx} />`;
+  else if (section === "runs" && id === "compare") page = html`<${CompareRuns} ctx=${ctx} />`;
+  else if (section === "runs" && id === "new") page = html`<${NewRun} ctx=${ctx} />`;
+  else if (section === "runs" && id) page = html`<${Run} ctx=${ctx} id=${id} />`;
+  else if (section === "runs") page = html`<${Runs} ctx=${ctx} />`;
+  else if (section === "evals" && id === "compare") page = html`<${Compare} ctx=${ctx} />`;
+  else if (section === "evals" && id) page = html`<${EvalDetail} ctx=${ctx} id=${id} />`;
+  else if (section === "evals") page = html`<${Evals} ctx=${ctx} />`;
+  else if (section === "tasks" && id) page = html`<${Task} ctx=${ctx} id=${id} />`;
+  else if (section === "environments" && id) page = html`<${Environment} ctx=${ctx} id=${id} />`;
+  else if (section === "environments") page = html`<${Environments} ctx=${ctx} />`;
+  else if (section === "datasets" && id) page = html`<${Dataset} ctx=${ctx} id=${id} />`;
+  else if (section === "datasets") page = html`<${Datasets} ctx=${ctx} />`;
+  else if (section === "models") page = html`<${Models} ctx=${ctx} />`;
+  else if (section === "jobs") page = html`<${Jobs} ctx=${ctx} />`;
+  else if (section === "compute") page = html`<${Compute} ctx=${ctx} />`;
+  else if (section === "usage") page = html`<${Usage} ctx=${ctx} />`;
+  else if (section === "reports") page = html`<${Reports} ctx=${ctx} />`;
+  else if (section === "settings") page = html`<${Settings} ctx=${ctx} />`;
+  else page = html`<div class="empty">Page not found.</div>`;
+  return html`
+    <header class="topbar">
+      <button class="icon-btn menu-btn" aria-label="Menu" onClick=${() => document.body.classList.toggle("nav-open")}><svg viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M4 7h16M4 12h16M4 17h16"/></svg></button>
+      <${Brand} />
+      <${Switcher} meta=${meta} org=${org} project=${project} />
+      <span class="spacer"></span>
+      <button class="search-btn" onClick=${() => setPalette(true)}><${Icon} name="search" size=${14} /><span class="label">Search</span><kbd>⌘K</kbd></button>
+      <${Link} href=${ctx.base + "/settings"} class=${`source-pill ${ctx.source}`} title="Where this project's data comes from (Settings explains the sources)">
+        <span class="dot"></span>${PILL[ctx.source] || ctx.source}</${Link}>
+    </header>
+    <${Sidebar} ctx=${ctx} section=${section} />
+    <main class=${`main ${rollout ? "with-drawer" : ""}`}>${ctx.source === "demo" ? html`<div class="example-banner">
+      <b>Example project</b> built from published sources. Published numbers link to their source; everything else is simulated to match them, and labelled so.
+      <span class="write-only"><${Link} href="/dashboard?new=project">Create your own project</${Link}></span></div>` : null}${page}</main>
+    ${rollout ? html`<${RolloutDrawer} ctx=${ctx} id=${rollout} />` : null}
+    ${palette ? html`<${Palette} ctx=${ctx} onClose=${() => setPalette(false)} />` : null}
+    ${dialog}
+  `;
+}
+
+render(html`<${Shell} />`, document.getElementById("app"));
diff --git a/viewer/static/benchflow-mark.svg b/viewer/static/benchflow-mark.svg
new file mode 100644
index 0000000000000000000000000000000000000000..dce8ea89e6ce7bba52479a829a5bb1165e26aaf3
--- /dev/null
+++ b/viewer/static/benchflow-mark.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="183.55 273.49 231.52 231.36"><path fill="#080808" fill-rule="evenodd" d="M412.5 273.49C412.18 279.33 406.7 288.2 404.42 293.87C398.71 308.08 392.47 322.09 386.74 336.3C380.37 352.09 373.87 367.91 367.05 383.54C364.11 390.28 362.11 398.45 358.09 404.6C353.87 411.03 345.27 417.65 339.71 423.2C334.04 428.86 328.39 434.55 322.71 440.2C320.08 442.82 317.61 446.02 314.4 447.97C305.42 453.43 293.26 456.76 283.5 460.98C267.37 467.95 251.12 474.61 234.92 481.45C224.14 486 213.36 490.57 202.56 495.08C196.45 497.63 190.04 501.39 183.55 502.5C193.2 493.01 202.85 483.52 212.5 474.03C215.75 477.2 218.36 479.63 220.97 474.5C219.65 472.83 218.34 471.17 217.02 469.5C224.85 461.67 232.67 453.85 240.5 446.02C245.17 450.45 249.83 454.87 254.5 459.29C255.68 458.03 256.87 456.76 258.05 455.5C253.68 450.83 249.3 446.17 244.92 441.5C252.78 433.64 260.64 425.78 268.5 417.92C270.17 419.28 271.83 420.64 273.5 421.99C274.66 420.83 275.82 419.66 276.98 418.5C275.66 416.83 274.34 415.17 273.02 413.5C280.85 405.67 288.67 397.83 296.5 390C301.17 394.31 305.83 398.63 310.5 402.95C311.75 401.8 313 400.65 314.24 399.5C309.84 394.83 305.44 390.17 301.04 385.5C308.86 377.57 316.68 369.64 324.5 361.71C326.17 363.12 327.83 364.53 329.5 365.93C330.72 364.79 331.94 363.64 333.15 362.5C331.82 360.5 330.49 358.5 329.15 356.5C336.94 348.89 344.72 341.27 352.5 333.66C357.17 338.02 361.83 342.39 366.5 346.76C367.75 345.67 369 344.59 370.25 343.5C365.87 338.5 361.48 333.5 357.1 328.5C364.9 320.76 372.7 313.02 380.5 305.28C382.5 306.59 384.5 307.91 386.5 309.23C387.53 307.98 388.55 306.74 389.58 305.5C388.19 303.83 386.79 302.17 385.4 300.5C394.43 291.5 403.47 282.49 412.5 273.49Z M415.02 286.16C415.04 357.07 415.05 427.99 415.07 498.91C411.61 497.99 409.16 494.46 406.59 491.9C401.75 487.08 396.96 482.21 392.1 477.41C385.4 470.77 378.77 464.07 372.11 457.39C369.64 454.92 364.56 451.54 363.39 448.21C361.69 443.35 363.06 432.94 363.06 427.5C363.06 421.3 361.91 413.77 363.31 407.72C364.73 401.59 369.08 394.11 371.6 388.18C378.78 371.29 385.96 354.34 392.82 337.32C397.39 325.99 402.54 314.85 406.96 303.47C408.91 298.45 411.04 289.56 415.02 286.16Z M409.69 504.85C338.92 504.85 268.16 504.85 197.4 504.85C200.53 500.63 208.58 499.02 213.45 496.91C226.99 491.03 240.6 485.3 254.26 479.73C268.39 473.97 282.48 468.06 296.48 461.96C302.37 459.4 312.52 453.9 318.5 452.96C324.59 452.01 331.34 452.77 337.5 452.77C343.03 452.77 354.4 451.32 359.22 453.33C362.69 454.78 366.24 459.96 368.89 462.63C375.86 469.66 382.86 476.65 389.86 483.65C394.83 488.64 407.42 499 409.69 504.85Z"/></svg>
diff --git a/viewer/static/favicon.svg b/viewer/static/favicon.svg
new file mode 100644
index 0000000000000000000000000000000000000000..2d8fea6790542205ac3d1619632afb56e7ce189d
--- /dev/null
+++ b/viewer/static/favicon.svg
@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" fill="#0006fc"/>
+  <svg x="0" y="0" width="32" height="32" viewBox="183.55 273.49 231.52 231.36" preserveAspectRatio="none">
+    <path fill="#ffffff" fill-rule="evenodd" d="M412.5 273.49C412.18 279.33 406.7 288.2 404.42 293.87C398.71 308.08 392.47 322.09 386.74 336.3C380.37 352.09 373.87 367.91 367.05 383.54C364.11 390.28 362.11 398.45 358.09 404.6C353.87 411.03 345.27 417.65 339.71 423.2C334.04 428.86 328.39 434.55 322.71 440.2C320.08 442.82 317.61 446.02 314.4 447.97C305.42 453.43 293.26 456.76 283.5 460.98C267.37 467.95 251.12 474.61 234.92 481.45C224.14 486 213.36 490.57 202.56 495.08C196.45 497.63 190.04 501.39 183.55 502.5C193.2 493.01 202.85 483.52 212.5 474.03C215.75 477.2 218.36 479.63 220.97 474.5C219.65 472.83 218.34 471.17 217.02 469.5C224.85 461.67 232.67 453.85 240.5 446.02C245.17 450.45 249.83 454.87 254.5 459.29C255.68 458.03 256.87 456.76 258.05 455.5C253.68 450.83 249.3 446.17 244.92 441.5C252.78 433.64 260.64 425.78 268.5 417.92C270.17 419.28 271.83 420.64 273.5 421.99C274.66 420.83 275.82 419.66 276.98 418.5C275.66 416.83 274.34 415.17 273.02 413.5C280.85 405.67 288.67 397.83 296.5 390C301.17 394.31 305.83 398.63 310.5 402.95C311.75 401.8 313 400.65 314.24 399.5C309.84 394.83 305.44 390.17 301.04 385.5C308.86 377.57 316.68 369.64 324.5 361.71C326.17 363.12 327.83 364.53 329.5 365.93C330.72 364.79 331.94 363.64 333.15 362.5C331.82 360.5 330.49 358.5 329.15 356.5C336.94 348.89 344.72 341.27 352.5 333.66C357.17 338.02 361.83 342.39 366.5 346.76C367.75 345.67 369 344.59 370.25 343.5C365.87 338.5 361.48 333.5 357.1 328.5C364.9 320.76 372.7 313.02 380.5 305.28C382.5 306.59 384.5 307.91 386.5 309.23C387.53 307.98 388.55 306.74 389.58 305.5C388.19 303.83 386.79 302.17 385.4 300.5C394.43 291.5 403.47 282.49 412.5 273.49Z M415.02 286.16C415.04 357.07 415.05 427.99 415.07 498.91C411.61 497.99 409.16 494.46 406.59 491.9C401.75 487.08 396.96 482.21 392.1 477.41C385.4 470.77 378.77 464.07 372.11 457.39C369.64 454.92 364.56 451.54 363.39 448.21C361.69 443.35 363.06 432.94 363.06 427.5C363.06 421.3 361.91 413.77 363.31 407.72C364.73 401.59 369.08 394.11 371.6 388.18C378.78 371.29 385.96 354.34 392.82 337.32C397.39 325.99 402.54 314.85 406.96 303.47C408.91 298.45 411.04 289.56 415.02 286.16Z M409.69 504.85C338.92 504.85 268.16 504.85 197.4 504.85C200.53 500.63 208.58 499.02 213.45 496.91C226.99 491.03 240.6 485.3 254.26 479.73C268.39 473.97 282.48 468.06 296.48 461.96C302.37 459.4 312.52 453.9 318.5 452.96C324.59 452.01 331.34 452.77 337.5 452.77C343.03 452.77 354.4 451.32 359.22 453.33C362.69 454.78 366.24 459.96 368.89 462.63C375.86 469.66 382.86 476.65 389.86 483.65C394.83 488.64 407.42 499 409.69 504.85Z"/>
+  </svg>
+</svg>
diff --git a/viewer/static/index.html b/viewer/static/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..e728ac43b432d75d3d08ccd9c05fe95d337ef617
--- /dev/null
+++ b/viewer/static/index.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="theme-color" content="#ffffff">
+<title>PostTrain</title>
+<link rel="icon" href="/dashboard/static/favicon.svg" type="image/svg+xml">
+<link rel="preload" href="/dashboard/static/vendor/InterVariable.woff2" as="font" type="font/woff2" crossorigin>
+<link rel="preload" href="/dashboard/static/vendor/InstrumentSerif-Regular.woff2" as="font" type="font/woff2" crossorigin>
+<link rel="stylesheet" href="/dashboard/static/style.css">
+<script type="importmap">
+{ "imports": {
+  "preact": "/dashboard/static/vendor/preact.js",
+  "preact/hooks": "/dashboard/static/vendor/hooks.js",
+  "htm": "/dashboard/static/vendor/htm.js"
+} }
+</script>
+</head>
+<body>
+<div id="app"></div>
+<script type="module" src="/dashboard/static/app.js"></script>
+</body>
+</html>
diff --git a/viewer/static/lib.js b/viewer/static/lib.js
new file mode 100644
index 0000000000000000000000000000000000000000..38f3b1f2fa5a4f517a77e62761b199b8eb6a14f8
--- /dev/null
+++ b/viewer/static/lib.js
@@ -0,0 +1,244 @@
+import { h, render, Fragment } from "preact";
+import { useState, useEffect, useMemo, useRef, useCallback, useLayoutEffect } from "preact/hooks";
+import htm from "htm";
+
+export const html = htm.bind(h);
+export { h, render, Fragment, useState, useEffect, useMemo, useRef, useCallback, useLayoutEffect };
+
+export const BASE = "/dashboard";
+
+// ------------------------------------------------------------------ data source
+// Every project lives in one source (your workspace, the examples, or BenchFlow's own runs), and
+// /meta says which. The shell sets the source of the project on screen before a page renders, so
+// every call the page makes goes to the source that holds it. `?source=` only matters for a project
+// that /meta doesn't list.
+let projectSource = null;
+export function setProjectSource(s) { projectSource = s || null; }
+export function getSource() {
+  return projectSource || new URLSearchParams(location.search).get("source") || "demo";
+}
+
+// What the server said about itself: `open` means it takes changes without a token.
+export const server = { open: false };
+
+// ------------------------------------------------------------------ API token (kept in this browser)
+const TOKEN_KEY = "posttrain.token";
+export function getToken() {
+  try { return localStorage.getItem(TOKEN_KEY) || ""; } catch (e) { return ""; }
+}
+export function setToken(t) {
+  try { if (t) localStorage.setItem(TOKEN_KEY, t.trim()); else localStorage.removeItem(TOKEN_KEY); } catch (e) { /* private mode */ }
+  invalidate();
+}
+export function needsToken() { return !server.open && !getToken(); }
+function authHeaders() {
+  const t = getToken();
+  return t ? { Authorization: `Bearer ${t}` } : {};
+}
+
+// ------------------------------------------------------------------ routing
+const listeners = new Set();
+function emit() { listeners.forEach((f) => f()); }
+window.addEventListener("popstate", emit);
+
+export function navigate(to, { replace = false } = {}) {
+  if (to === location.pathname + location.search) return;
+  history[replace ? "replaceState" : "pushState"](null, "", to);
+  emit();
+  if (!replace) window.scrollTo(0, 0);
+}
+
+export function setQuery(patch, { replace = true } = {}) {
+  const u = new URL(location.href);
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === null || v === undefined || v === "") u.searchParams.delete(k);
+    else u.searchParams.set(k, v);
+  }
+  history[replace ? "replaceState" : "pushState"](null, "", u.pathname + u.search);
+  emit();
+}
+
+export function useLocation() {
+  const [, force] = useState(0);
+  useEffect(() => {
+    const f = () => force((n) => n + 1);
+    listeners.add(f);
+    return () => listeners.delete(f);
+  }, []);
+  const path = location.pathname.startsWith(BASE) ? location.pathname.slice(BASE.length) : location.pathname;
+  const parts = path.split("/").filter(Boolean).map(decodeURIComponent);
+  return { parts, query: new URLSearchParams(location.search) };
+}
+
+export function Link({ href, children, class: cls, className, title, onClick, ...rest }) {
+  const go = (e) => {
+    if (onClick) onClick(e);
+    if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+    if (!href || href.startsWith("http")) return;
+    e.preventDefault();
+    navigate(href);
+  };
+  return html`<a href=${href} class=${cls || className} title=${title} onClick=${go} ...${rest}>${children}</a>`;
+}
+
+export function projectBase(org, project) { return `${BASE}/${org}/${project}`; }
+
+// ------------------------------------------------------------------ fetching
+export class ApiError extends Error {
+  constructor(status, message) { super(message); this.status = status; }
+}
+async function parse(r) {
+  if (!r.ok) {
+    let msg = `${r.status} ${r.statusText || ""}`.trim();
+    try {
+      const j = await r.json();
+      if (j && j.detail) msg = typeof j.detail === "string" ? j.detail : j.detail.map((d) => d.msg || JSON.stringify(d)).join("; ");
+    } catch (e) { /* not json */ }
+    throw new ApiError(r.status, msg);
+  }
+  return r.json();
+}
+async function fetchJson(url) {
+  return parse(await fetch(url, { headers: authHeaders(), cache: "no-store" }));
+}
+
+const cache = new Map();
+let version = 0;
+/** Forget cached reads and re-fetch what is on screen (after a write). */
+export function invalidate() { cache.clear(); version += 1; emit(); }
+
+export function apiUrl(path, params = {}) {
+  const u = new URL(`/api/v3${path}`, location.origin);
+  const src = params && "source" in params ? params.source : getSource();
+  if (src) u.searchParams.set("source", src);
+  for (const [k, v] of Object.entries(params || {})) if (k !== "source" && v !== undefined && v !== null && v !== "") u.searchParams.set(k, v);
+  return u.pathname + u.search;
+}
+export async function api(path, params) {
+  const url = apiUrl(path, params);
+  if (cache.has(url)) return cache.get(url);
+  const p = fetchJson(url);
+  cache.set(url, p);
+  p.catch(() => cache.delete(url));
+  return p;
+}
+/** A read that is never cached (log tails, polling). */
+export function getJson(path, params) { return fetchJson(apiUrl(path, params)); }
+/** A write: POST JSON with the browser's token. Throws ApiError (status 401 means "ask for a token"). */
+export async function apiPost(path, body) {
+  const r = await fetch(`/api/v3${path}`, {
+    method: "POST", headers: { "Content-Type": "application/json", ...authHeaders() }, body: JSON.stringify(body || {}) });
+  return parse(r);
+}
+
+/**
+ * Data for a page. `opts.every` (ms, or a function of the latest data returning ms) keeps it fresh:
+ * the page keeps what it shows while a refresh is in flight, so nothing flashes.
+ */
+export function useApi(path, params, deps = [], opts = {}) {
+  const key = path ? apiUrl(path, params) : null;
+  const [state, setState] = useState({ data: null, error: null, loading: !!path, key: null });
+  useEffect(() => {
+    if (!path) return;
+    let live = true;
+    setState((s) => ({ ...s, loading: true, error: null }));
+    api(path, params).then(
+      (data) => live && setState({ data, error: null, loading: false, key }),
+      (error) => live && setState({ data: null, error, loading: false, key }));
+    return () => { live = false; };
+  }, [key, version, ...deps]);
+  const every = typeof opts.every === "function" ? (state.data && state.key === key ? opts.every(state.data) : 0) : (opts.every || 0);
+  useEffect(() => {
+    if (!key || !every) return;
+    let live = true, timer = null;
+    const tick = () => {
+      timer = setTimeout(async () => {
+        if (!live) return;
+        if (!document.hidden) {
+          try {
+            const data = await fetchJson(key);
+            if (!live) return;
+            cache.set(key, Promise.resolve(data));
+            setState({ data, error: null, loading: false, key });
+          } catch (e) { /* keep what is on screen; the next tick tries again */ }
+        }
+        if (live) tick();
+      }, every);
+    };
+    tick();
+    return () => { live = false; clearTimeout(timer); };
+  }, [key, every]);
+  return state;
+}
+
+// ------------------------------------------------------------------ rollout order
+// A page that lists rollouts publishes them in the order it shows them, so the rollout drawer's
+// j/k and arrow keys walk the same list (across groups), not only the attempts of one group.
+let rolloutOrder = [];
+export function setRolloutOrder(ids) { rolloutOrder = ids || []; }
+export function rolloutOrderOf() { return rolloutOrder; }
+
+// ------------------------------------------------------------------ small utils
+export const by = (f, dir = 1) => (a, b) => {
+  const x = f(a), y = f(b);
+  if (x === y) return 0;
+  if (x === null || x === undefined) return 1;
+  if (y === null || y === undefined) return -1;
+  return (x < y ? -1 : 1) * dir;
+};
+export function groupBy(xs, f) {
+  const m = new Map();
+  for (const x of xs) {
+    const k = f(x);
+    if (!m.has(k)) m.set(k, []);
+    m.get(k).push(x);
+  }
+  return m;
+}
+export function useKey(handler, deps = []) {
+  useEffect(() => {
+    const f = (e) => {
+      const t = e.target;
+      if (t && (t.tagName === "INPUT" || t.tagName === "TEXTAREA" || t.tagName === "SELECT" || t.isContentEditable)) return;
+      handler(e);
+    };
+    window.addEventListener("keydown", f);
+    return () => window.removeEventListener("keydown", f);
+  }, deps);
+}
+export function useSize(ref) {
+  const [w, setW] = useState(0);
+  useLayoutEffect(() => {
+    if (!ref.current) return;
+    const ro = new ResizeObserver((es) => setW(Math.floor(es[0].contentRect.width)));
+    ro.observe(ref.current);
+    setW(Math.floor(ref.current.getBoundingClientRect().width));
+    return () => ro.disconnect();
+  }, []);
+  return w;
+}
+export function copyText(text) {
+  if (navigator.clipboard && window.isSecureContext) return navigator.clipboard.writeText(text).catch(() => fallbackCopy(text));
+  fallbackCopy(text);
+  return Promise.resolve();
+}
+function fallbackCopy(text) {
+  const ta = document.createElement("textarea");
+  ta.value = text;
+  ta.setAttribute("readonly", "");
+  ta.style.cssText = "position:fixed;top:-1000px;opacity:0";
+  document.body.appendChild(ta);
+  ta.select();
+  try { document.execCommand("copy"); } catch (e) { /* nothing else to try */ }
+  ta.remove();
+}
+/** A value as one shell word (single quotes when it needs any); <placeholders> stay as they are. */
+export function shq(v) {
+  const s = String(v ?? "");
+  if (/^<[^<>]*>$/.test(s)) return s;
+  return s && /^[A-Za-z0-9_@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+}
+/** Lowercase letters, digits and dashes, like `posttrain init` makes a project slug from its name. */
+export function slugify(s) {
+  return String(s || "").toLowerCase().replace(/[^\p{L}\p{N}]/gu, "-").replace(/^-+|-+$/g, "");
+}
diff --git a/viewer/static/pages/compute.js b/viewer/static/pages/compute.js
new file mode 100644
index 0000000000000000000000000000000000000000..a06b0e54063d8225052be5126fb298b4529f4c4e
--- /dev/null
+++ b/viewer/static/pages/compute.js
@@ -0,0 +1,220 @@
+// Compute targets of the organization, the runners that serve them, and the jobs waiting or running.
+import { html, useState, useApi, apiPost, invalidate, setQuery, shq, Link, projectBase } from "../lib.js";
+import { Loading, Err, Table, Presence, Status, Icon } from "../ui/common.js";
+import { Field, Command, Dialog, useSubmit, SubmitProblem } from "../ui/forms.js";
+import * as f from "../ui/fmt.js";
+
+const F = (key, label, placeholder = "", help = "", extra = {}) => ({ key, label, placeholder, help, ...extra });
+export const KINDS = [
+  { id: "local", label: "Local", about: "The runner's own machine: each job runs there as a process.", creds: "No credentials involved.", fields: [] },
+  { id: "ssh", label: "SSH", about: "A machine you can SSH into: the runner copies each job there and runs it.",
+    creds: "The runner uses the SSH keys or agent of the machine it runs on.",
+    fields: [F("host", "Host", "user@gpu-box", "What you would type after ssh.", { required: true }),
+      F("workdir", "Working directory", "~/posttrain-jobs", "Where job files go on that machine."),
+      F("python", "Python", "python3", "The interpreter jobs use there.")] },
+  { id: "slurm", label: "Slurm", about: "A Slurm cluster: each job is submitted with sbatch.",
+    creds: "The runner uses SSH keys to the login node; or run the runner on the login node and leave the host blank.",
+    fields: [F("host", "Login node", "user@login.cluster.edu", "Leave blank to call sbatch on the runner's machine."),
+      F("partition", "Partition", "gpu"), F("account", "Account", "", "The allocation to charge, if your cluster asks for one."),
+      F("gpus", "GPUs per job", "8", "", { int: true }), F("gpu", "GPU type", "h100", "As the cluster names it in --gres."),
+      F("time", "Time limit", "04:00:00", "HH:MM:SS; the job is stopped after it."), F("workdir", "Working directory", "$SCRATCH/posttrain"),
+      F("modules", "Modules", "cuda/12.4 python/3.11", "Loaded with module load before each job.")] },
+  { id: "prime", label: "Prime", about: "Prime Intellect: GPU pods for any recipe, or hosted RL (the prime-hosted recipe).",
+    creds: "The runner uses `prime login` on the machine it runs on.",
+    fields: [F("mode", "Mode", "", "pod: a GPU pod runs any recipe. hosted: Prime runs the RL training itself.", { choices: ["pod", "hosted"] }),
+      F("gpu", "GPU type", "H100_80GB", "", { only: "pod" }), F("gpus", "GPUs", "1", "", { int: true, only: "pod" }),
+      F("image", "Image", "", "Container image for the pod; blank uses Prime's default.", { only: "pod" })] },
+  { id: "hf-jobs", label: "HF Jobs", about: "Hugging Face Jobs: containers on Hugging Face GPUs, billed to your account or organization.",
+    creds: "The runner uses HF_TOKEN from its own environment.",
+    fields: [F("flavor", "Hardware", "a100-large", "An HF Jobs flavor: t4-small, l4x1, a10g-large, a100-large, h100, …", { required: true }),
+      F("namespace", "Bill to", "", "A username or organization; blank bills the token's owner."),
+      F("image", "Image", "", "Blank uses the recipe's image.")] },
+];
+const FLAGS = new Set(["host", "partition", "account", "gpus", "gpu", "workdir", "python", "image", "flavor", "time"]);
+
+function AddTarget({ ctx, existing, onClose }) {
+  const [kind, setKind] = useState("ssh");
+  const [name, setName] = useState("");
+  const [vals, setVals] = useState({ mode: "pod" });
+  const [tried, setTried] = useState(false);
+  const [added, setAdded] = useState(null);
+  const k = KINDS.find((x) => x.id === kind);
+  const fields = k.fields.filter((x) => !x.only || vals.mode === x.only);
+  const config = {};
+  for (const fl of fields) {
+    const v = String(vals[fl.key] ?? "").trim();
+    if (v) config[fl.key] = fl.int && /^\d+$/.test(v) ? parseInt(v, 10) : v;
+  }
+  const errors = {};
+  if (!name.trim()) errors.name = "Required.";
+  else if (!/^[a-z0-9][a-z0-9._-]*$/.test(name.trim())) errors.name = "Lowercase letters, digits, dots, dashes and underscores.";
+  for (const fl of fields) {
+    if (fl.required && !config[fl.key]) errors[fl.key] = "Required.";
+    if (fl.int && vals[fl.key] && !/^\d+$/.test(String(vals[fl.key]).trim())) errors[fl.key] = "A whole number.";
+  }
+  const replaces = existing.some((t) => t.name === name.trim() && !t.builtin);
+  const cli = `posttrain compute add ${shq(name.trim() || "<name>")} --kind ${kind}` + Object.entries(config)
+    .map(([key, v]) => (FLAGS.has(key) ? ` --${key} ${shq(v)}` : ` --set ${shq(`${key}=${v}`)}`)).join("");
+  const [submit, state] = useSubmit(async () => {
+    await apiPost(`/orgs/${ctx.org}/compute`, { name: name.trim(), kind, config });
+    setAdded(name.trim());
+    invalidate();
+  });
+  const go = (e) => {
+    e.preventDefault();
+    setTried(true);
+    if (!Object.keys(errors).length) submit();
+  };
+  if (added) {
+    return html`<${Dialog} title=${`Added ${added}`} onClose=${onClose} purpose="Runs can now target it. Nothing runs there until a runner serves it.">
+      <div class="form">
+        <div class="field wide"><span class="field-label">Start a runner on a machine that can reach ${added}</span>
+          <${Command} cmd=${`posttrain agent --targets ${shq(added)}`} />
+          <span class="field-help">It registers, polls for jobs queued on ${added}, runs them and streams their logs; stop it with Ctrl-C.</span></div>
+        <div class="field wide"><span class="field-label">Check that it can reach ${added}</span><${Command} cmd=${`posttrain compute test ${shq(added)}`} /></div>
+        <div class="form-actions"><button class="btn primary" onClick=${onClose}>Done</button></div>
+      </div><//>`;
+  }
+  const err = (key) => (tried ? errors[key] : null);
+  return html`<${Dialog} title="Add a compute target" onClose=${onClose} width=${620}
+      purpose=${`Register a place where ${ctx.orgInfo ? ctx.orgInfo.name : ctx.org}'s runs can execute. Every project in the organization can use it.`}>
+    <form class="form" onSubmit=${go} novalidate>
+      <div class="field wide" role="group"><span class="field-label">Kind</span>
+        <div class="seg wrap-seg">${KINDS.map((x) => html`<button type="button" class=${kind === x.id ? "on" : ""} onClick=${() => { setKind(x.id); setTried(false); }}>${x.label}</button>`)}</div>
+        <span class="field-help">${k.about}</span></div>
+      <${Field} label="Name" error=${err("name")} help=${html`Used in <span class="mono">--on ${name.trim() || "<name>"}</span> and <span class="mono">posttrain agent --targets ${name.trim() || "<name>"}</span>.`}>
+        <input class="input" value=${name} placeholder=${kind === "local" ? "workstation" : kind === "hf-jobs" ? "hf-a100" : kind === "prime" ? "prime-h100" : kind === "slurm" ? "cluster" : "gpu-box"}
+          spellcheck="false" autocomplete="off" onInput=${(e) => setName(e.target.value.toLowerCase())} /><//>
+      ${fields.length ? html`<div class="form-grid">${fields.map((fl) => fl.choices
+        ? html`<${Field} label=${fl.label} help=${fl.help}><select class="input" value=${vals[fl.key] || fl.choices[0]} onChange=${(e) => setVals({ ...vals, [fl.key]: e.target.value })}>
+            ${fl.choices.map((c) => html`<option value=${c}>${c}</option>`)}</select><//>`
+        : html`<${Field} label=${fl.label} optional=${!fl.required} error=${err(fl.key)} help=${fl.help}>
+            <input class="input" value=${vals[fl.key] || ""} placeholder=${fl.placeholder} spellcheck="false" autocomplete="off"
+              inputmode=${fl.int ? "numeric" : "text"} onInput=${(e) => setVals({ ...vals, [fl.key]: e.target.value })} /><//>`)}</div>` : null}
+      <div class="field wide"><span class="field-label">Same from a terminal</span><${Command} cmd=${cli} /></div>
+      <p class="consequence"><b>Credentials stay on the runner.</b> ${k.creds} Only the settings above are stored here; keys named like tokens, secrets or passwords are dropped.
+        ${replaces ? html` <b>${name.trim()}</b> exists already; its settings are replaced.` : ""}</p>
+      <${SubmitProblem} state=${state} onRetry=${submit.retry} />
+      <div class="form-actions"><button type="button" class="btn" onClick=${onClose}>Cancel</button>
+        <button type="submit" class="btn primary" disabled=${state.busy}>${state.busy ? "Adding…" : replaces ? "Replace target" : "Add target"}</button></div>
+    </form><//>`;
+}
+
+/** PRD 7.1, per kind: what a target can run. */
+function supportsText(t) {
+  if (t.kind === "prime" && (t.config || {}).mode === "hosted") return "prime-hosted RL (LoRA, managed by Prime)";
+  return { local: "SFT, preference, RL on 1 node, evals", ssh: "SFT, preference, RL on 1 node, evals, deploy",
+    slurm: "SFT, preference, multi-node RL, evals", prime: "SFT, preference, RL on 1 pod, evals, deploy",
+    "hf-jobs": "SFT, preference, RL on 1 node, evals" }[t.kind] || "—";
+}
+
+function AddRunner({ ctx, targets, onClose }) {
+  const [name, setName] = useState("");
+  const [serve, setServe] = useState(() => targets.slice(0, 1).map((t) => t.name));
+  const [tried, setTried] = useState(false);
+  const [token, setToken] = useState(null);
+  const nameErr = !name.trim() ? "Required." : !/^[a-z0-9][a-z0-9._-]*$/.test(name.trim()) ? "Lowercase letters, digits, dots, dashes and underscores." : null;
+  const [submit, state] = useSubmit(async () => {
+    const res = await apiPost("/tokens", { name: name.trim(), user: name.trim(), runner: true, targets: serve });
+    setToken(res.token);
+    invalidate();
+  });
+  const start = token ? `POSTTRAIN_TOKEN=${token} posttrain agent --url ${shq(location.origin)} --project ${shq(`${ctx.org}/${ctx.project}`)} --targets ${shq(serve.join(","))} --name ${shq(name.trim())}` : "";
+  if (token) {
+    return html`<${Dialog} title=${`Start ${name.trim()}`} onClose=${onClose} purpose="Run this on the machine that holds the credentials for its targets. The token is shown once.">
+      <div class="form"><${Command} cmd=${start} />
+        <span class="field-help">It connects out to this server (no open port), registers, claims runs queued for ${serve.join(", ")}, and reports them. It shows up under Runners within seconds.</span>
+        <div class="form-actions"><button class="btn primary" onClick=${onClose}>Done</button></div></div><//>`;
+  }
+  return html`<${Dialog} title="Add a runner" onClose=${onClose}
+      purpose="A runner is posttrain agent on a machine you control. It uses that machine's credentials, claims the runs queued for its targets, and reports them.">
+    <form class="form" onSubmit=${(e) => { e.preventDefault(); setTried(true); if (!nameErr && serve.length) submit(); }} novalidate>
+      <${Field} label="Name" error=${tried ? nameErr : null} help="Shown on run pages as who launched and watches a run.">
+        <input class="input" value=${name} placeholder="lab-runner" spellcheck="false" autocomplete="off" onInput=${(e) => setName(e.target.value.toLowerCase())} /><//>
+      <div class="field wide" role="group"><span class="field-label">Targets it serves</span>
+        <div class="pick-list">${targets.map((t) => html`<label class="pick"><input type="checkbox" checked=${serve.includes(t.name)}
+            onChange=${() => setServe(serve.includes(t.name) ? serve.filter((x) => x !== t.name) : [...serve, t.name])} />
+          <span class="grow"><b>${t.name}</b> <span class="muted small">${t.kind}</span></span></label>`)}</div>
+        ${tried && !serve.length ? html`<span class="field-error">Choose at least one target.</span>` : html`<span class="field-help">It needs the credentials for each: SSH keys, prime login or HF_TOKEN on its machine.</span>`}</div>
+      <p class="consequence">Creates a runner token and shows it once. It can only claim, watch and report runs on these targets; revoke it under Settings → API tokens.</p>
+      <${SubmitProblem} state=${state} onRetry=${submit.retry} />
+      <div class="form-actions"><button type="button" class="btn" onClick=${onClose}>Cancel</button>
+        <button type="submit" class="btn primary" disabled=${state.busy}>${state.busy ? "Creating…" : "Create runner token"}</button></div>
+    </form><//>`;
+}
+
+export function Compute({ ctx }) {
+  const comp = useApi(ctx.writable ? `/orgs/${ctx.org}/compute` : null, { source: "" }, [], { every: 5000 });
+  const jobs = useApi(ctx.writable ? `/orgs/${ctx.org}/jobs` : null, { source: "" }, [], { every: 5000 });
+  const dialog = ctx.query.get("add");
+  if (!ctx.writable) {
+    return html`<div class="page-head"><div class="grow"><h1>Compute</h1>
+      <p class="lede">Compute targets belong to organizations in your workspace. This is an example project; its clusters are listed on the Usage page.</p></div></div>`;
+  }
+  if (comp.error && !comp.data) return html`<${Err} error=${comp.error} />`;
+  if (!comp.data) return html`<${Loading} />`;
+  const orgName = ctx.orgInfo ? ctx.orgInfo.name : ctx.org;
+  const runners = comp.data.runners;
+  const live = jobs.data || [];
+  const targets = [...comp.data.targets];
+  if (!targets.some((t) => t.name === "local")) {
+    targets.unshift({ name: "local", kind: "local", config: {}, builtin: true,
+      runners: runners.filter((r) => r.online && (r.targets || []).includes("local")).map((r) => r.name) });
+  }
+  const runningOn = (name) => live.filter((j) => j.target === name && j.status === "running");
+  const byRunner = (id) => live.filter((j) => j.runner && j.runner.id === id);
+  const queue = live.filter((j) => j.status === "queued" || j.status === "starting").sort((a, b) => a.created_at - b.created_at);
+  const runLink = (j) => j.run_id ? html`<${Link} href=${`${projectBase(ctx.org, j.project)}/runs/${j.run_id}`}>${j.run_name || j.name}</${Link}>` : j.name;
+  return html`
+    <div class="page-head"><div class="grow">
+      <div class="crumb-line">${orgName} · organization</div>
+      <h1>Compute</h1>
+      <p class="lede">Where runs execute. Targets belong to ${orgName}, so every project in it can launch on them; a runner (<span class="mono">posttrain agent</span>) on a machine with access starts the runs queued for its targets.</p>
+    </div>
+    <div class="row"><button class="btn" onClick=${() => setQuery({ add: "runner" }, { replace: false })}>Add runner</button>
+      <button class="btn primary" onClick=${() => setQuery({ add: "1" }, { replace: false })}><${Icon} name="plus" size=${14} />Add target</button></div></div>
+
+    <div class="section" style="margin-top:0"><div class="section-head"><h2>Targets</h2><span class="muted small">settings are stored without secrets; credentials stay on the runner</span></div>
+    <${Table} rows=${targets} rowKey=${(t) => t.name} columns=${[
+      { key: "name", label: "Target", render: (t) => html`<b>${t.name}</b><span class="sub">${(KINDS.find((k) => k.id === t.kind) || {}).label || t.kind}${t.builtin ? " · built in" : ""}</span>` },
+      { key: "supports", label: "Supports", sortable: false, render: (t) => html`<span class="small">${supportsText(t)}</span>` },
+      { key: "config", label: "Settings", sortable: false, render: (t) => Object.keys(t.config || {}).length
+        ? html`<span class="mono small">${Object.entries(t.config).map(([k, v]) => `${k}=${v}`).join("  ")}</span>`
+        : html`<span class="muted small">${t.builtin ? "the runner's own machine" : "none"}</span>` },
+      { key: "runners", label: "Runners", sortValue: (t) => (t.runners || []).length, render: (t) => (t.runners || []).length
+        ? html`<${Presence} online=${true} label=${t.runners.join(", ")} />`
+        : html`<${Presence} online=${false} label="none online" /><div class="cell-cmd"><${Command} cmd=${`posttrain agent --targets ${shq(t.name)}`} compact=${true} /></div>` },
+      { key: "now", label: "Runs now", sortValue: (t) => runningOn(t.name).length, render: (t) => runningOn(t.name).length
+        ? html`${runningOn(t.name).map((j, i) => html`${i ? ", " : ""}${runLink(j)}`)}` : html`<span class="muted">—</span>` },
+      { key: "created_at", label: "Added", num: true, render: (t) => t.builtin ? html`<span class="muted">—</span>` : html`<span class="nowrap">${f.ago(t.created_at)}</span>${t.created_by ? html`<span class="sub nowrap">by ${t.created_by}</span>` : null}` },
+    ]} /></div>
+
+    <div class="section"><div class="section-head"><h2>Runners</h2><span class="muted small">online means heard from in the last 90 seconds</span></div>
+      <${Table} rows=${runners} rowKey=${(r) => r.id} empty=${html`No runner has connected yet. Add one, or start one where the jobs should run:
+          <div style="max-width:460px;margin:8px auto 0;text-align:left"><${Command} cmd="posttrain agent --targets local" compact=${true} /></div>`} columns=${[
+        { key: "name", label: "Runner", render: (r) => html`<b>${r.name}</b><span class="sub">${r.hostname || ""}</span>` },
+        { key: "version", label: "Version", render: (r) => r.version || html`<span class="muted">—</span>` },
+        { key: "targets", label: "Targets", sortable: false, render: (r) => (r.targets || []).join(", ") || html`<span class="muted">—</span>` },
+        { key: "online", label: "Status", render: (r) => html`<${Presence} online=${r.online} label=${r.online ? "online" : `offline since ${f.ago(r.last_seen)}`} />` },
+        { key: "last_seen", label: "Last heartbeat", num: true, render: (r) => f.ago(r.last_seen) },
+        { key: "runs", label: "Runs", sortable: false, render: (r) => byRunner(r.id).length ? html`${byRunner(r.id).map((j, i) => html`${i ? ", " : ""}${runLink(j)}`)}` : html`<span class="muted">—</span>` },
+      ]} /></div>
+
+    <div class="section"><div class="section-head"><h2>Launch queue</h2><span class="muted small">runs of every project in ${orgName} waiting for a runner, oldest first</span></div>
+      <${Table} rows=${queue} rowKey=${(j) => j.id} empty="Nothing is waiting." columns=${[
+        { key: "run_name", label: "Run", render: (j) => html`${runLink(j)}<span class="sub">${j.project_name}</span>` },
+        { key: "target", label: "Target" },
+        { key: "status", label: "Status", render: (j) => html`<${Status} status=${j.status} />${j.runner ? html`<span class="sub">claimed by ${j.runner.name}</span>` : null}` },
+        { key: "age", label: "Waiting", num: true, sortValue: (j) => j.created_at, render: (j) => f.duration(f.now() - j.created_at) },
+      ]} /></div>
+
+    <div class="section"><div class="section-head"><h2>From a terminal</h2></div>
+      <div class="panel"><div class="panel-body cmd-list">
+        <div><span class="small sec">List targets and the runners serving them</span><${Command} cmd="posttrain compute ls" compact=${true} /></div>
+        <div><span class="small sec">Add or replace a target</span><${Command} cmd="posttrain compute add gpu-box --kind ssh --host user@gpu-box" compact=${true} /></div>
+        <div><span class="small sec">Check that this machine can reach it</span><${Command} cmd="posttrain compute test gpu-box" compact=${true} /></div>
+        <div><span class="small sec">Serve targets: start the runs launched from the website</span><${Command} cmd="posttrain agent --targets gpu-box,local" compact=${true} /></div>
+      </div></div></div>
+    ${dialog === "1" ? html`<${AddTarget} ctx=${ctx} existing=${targets} onClose=${() => setQuery({ add: null })} />` : null}
+    ${dialog === "runner" ? html`<${AddRunner} ctx=${ctx} targets=${targets} onClose=${() => setQuery({ add: null })} />` : null}`;
+}
diff --git a/viewer/static/pages/datasets.js b/viewer/static/pages/datasets.js
new file mode 100644
index 0000000000000000000000000000000000000000..d60fd306641afb1a03f8960d0331f6918b51746b
--- /dev/null
+++ b/viewer/static/pages/datasets.js
@@ -0,0 +1,102 @@
+import { html, useApi, useState, navigate, setQuery } from "../lib.js";
+import { Loading, Err, Table, ProjectLink, Facts, Empty, Provenance, Icon } from "../ui/common.js";
+import { Command } from "../ui/forms.js";
+import { AddInputDialog } from "./stages.js";
+import * as f from "../ui/fmt.js";
+
+const KIND = { sft: "Supervised", preference: "Preference", rl: "RL prompts", eval: "Eval", midtrain: "Mid-training" };
+
+export function Datasets({ ctx }) {
+  const adding = ctx.writable && ctx.query.get("add") === "dataset";
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/datasets`, undefined, [], { every: adding ? 4000 : 0 });
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const newest = data.reduce((a, d) => (!a || (d.created_at || 0) > (a.created_at || 0) ? d : a), null);
+  return html`
+    <div class="page-head"><div class="grow"><h1>Datasets</h1>
+      <p class="lede">Supervised, preference and prompt datasets: what they are made of, how they were filtered, and which runs trained on them.</p></div>
+      ${ctx.writable ? html`<button class="btn primary" onClick=${() => setQuery({ add: "dataset" }, { replace: false })}><${Icon} name="plus" size=${14} />Add dataset</button>` : null}</div>
+    ${adding ? html`<${AddInputDialog} ctx=${ctx} kind="dataset" count=${data.length} latest=${newest} onClose=${() => setQuery({ add: null })} />` : null}
+    ${data.length === 0 ? (ctx.writable ? html`<div class="panel"><div class="panel-body"><b>No datasets yet.</b>
+        <div class="sec small" style="margin:3px 0 10px">Add one here, or from a terminal:</div>
+        <div style="max-width:560px"><${Command} cmd="posttrain data add ./code_sft.jsonl --kind sft" /></div></div></div>`
+      : html`<${Empty}>This project's published record has no datasets; its RL runs draw tasks from environments.</${Empty}>`) : html`
+    <${Table} rows=${data} rowKey=${(d) => d.id} onRow=${(d) => navigate(`${ctx.base}/datasets/${d.id}`)} columns=${[
+      { key: "name", label: "Dataset", render: (d) => html`<${ProjectLink} ctx=${ctx} to=${`/datasets/${d.id}`}>${d.name}</${ProjectLink}><span class="sub">${d.hf_repo || ""}</span>` },
+      { key: "kind", label: "Kind", render: (d) => KIND[d.kind] || d.kind },
+      { key: "rows", label: "Rows", num: true, render: (d) => f.compact(d.rows) },
+      { key: "tokens", label: "Tokens", num: true, render: (d) => f.compact(d.tokens) },
+      { key: "sources", label: "Sources", num: true, sortValue: (d) => d.sources.length, render: (d) => f.int(d.sources.length) },
+      { key: "synthetic", label: "Synthetic", num: true, sortValue: (d) => synthShare(d), render: (d) => f.pct(synthShare(d), 0) },
+      { key: "license", label: "License", render: (d) => d.license || "—" },
+      { key: "runs", label: "Used by", sortValue: (d) => d.runs.length, render: (d) => d.runs.length ? html`<span class="small">${d.runs.map((r) => r.name).join(", ")}</span>` : html`<span class="muted">—</span>` },
+    ]} />`}`;
+}
+
+function synthShare(d) {
+  const tot = d.sources.reduce((s, x) => s + (x.rows || 0), 0);
+  if (!tot) return null;
+  return d.sources.filter((x) => x.synthetic).reduce((s, x) => s + (x.rows || 0), 0) / tot;
+}
+
+function RowView({ row }) {
+  const d = row.data || {};
+  if (d.messages) {
+    return html`${d.messages.map((m) => html`<div class="msg" style="margin-top:6px"><div class="msg-head"><span class="role">${m.role}</span></div><div class="msg-body">${m.content}</div></div>`)}`;
+  }
+  if (d.chosen) {
+    return html`<div class="msg-body" style="padding:0 0 6px"><b>Prompt</b><div>${d.prompt}</div></div>
+      <div class="grid cols-2"><div class="msg"><div class="msg-head"><span class="role">Chosen</span></div><div class="msg-body">${d.chosen}</div></div>
+      <div class="msg"><div class="msg-head"><span class="role">Rejected</span></div><div class="msg-body">${d.rejected}</div></div></div>`;
+  }
+  return html`<pre class="code">${JSON.stringify(d, null, 2)}</pre>`;
+}
+
+export function Dataset({ ctx, id }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/datasets/${id}`);
+  const [open, setOpen] = useState(0);
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const d = data.dataset;
+  const total = d.sources.reduce((s, x) => s + (x.rows || 0), 0) || 1;
+  const proc = d.processing || [];
+  return html`
+    <div class="page-head"><div class="grow">
+      <div class="crumb-line"><${ProjectLink} ctx=${ctx} to="/datasets">Datasets</${ProjectLink}> / ${KIND[d.kind] || d.kind}</div>
+      <div class="row wrap" style="gap:12px"><h1>${d.name}</h1>${d.version ? html`<span class="chip">${d.version}</span>` : null}<${Provenance} value=${d.provenance} source=${d.source} /></div>
+      ${d.description ? html`<p class="lede">${d.description}</p>` : null}
+      <div style="margin-top:10px"><${Facts} items=${[["rows", f.int(d.rows)], ["tokens", f.compact(d.tokens)], ["sources", f.int(d.sources.length)], ["license", d.license || "—"],
+        d.hf_repo ? ["repository", html`<a href=${`https://huggingface.co/datasets/${d.hf_repo}`} target="_blank" rel="noopener">${d.hf_repo}</a>`] : null, ["created", f.date(d.created_at, false)]]} /></div>
+    </div></div>
+    <div class="grid cols-2" style="align-items:start">
+      <div><h2 style="margin-bottom:10px">Composition</h2>
+        <${Table} dense=${true} rows=${d.sources} rowKey=${(s) => s.name} initialSort=${{ key: "rows", dir: -1 }} columns=${[
+          { key: "name", label: "Source", render: (s) => html`${s.url ? html`<a href=${s.url} target="_blank" rel="noopener">${s.name}</a>` : s.name}<span class="sub">${s.category}${s.generator ? ` · generated by ${s.generator}` : ""}</span>` },
+          { key: "rows", label: "Rows", num: true, render: (s) => html`<div class="bar-cell" style="justify-content:flex-end"><span class="bar" style="max-width:90px"><i style=${`width:${(s.rows / total) * 100}%`}></i></span>${f.compact(s.rows)}</div>` },
+          { key: "tokens", label: "Tokens", num: true, render: (s) => f.compact(s.tokens) },
+          { key: "synthetic", label: "Synthetic", render: (s) => s.synthetic ? "yes" : s.synthetic === 0 ? "no" : "—" },
+          { key: "license", label: "License", render: (s) => s.license || "—" },
+        ]} /></div>
+      <div><h2 style="margin-bottom:10px">Processing</h2>
+        ${proc.length ? html`<div class="table-wrap"><table class="t dense"><thead><tr><th>Step</th><th class="num">In</th><th class="num">Out</th><th class="num">Dropped</th></tr></thead>
+          <tbody>${proc.map((p) => html`<tr><td>${p.step}${p.note ? html`<span class="sub">${p.note}</span>` : null}</td><td class="num">${f.compact(p.rows_in)}</td><td class="num">${f.compact(p.rows_out)}</td>
+            <td class="num">${p.rows_in ? f.pct(1 - p.rows_out / p.rows_in, 1) : "—"}</td></tr>`)}</tbody></table></div>` : html`<div class="empty panel">No processing steps recorded.</div>`}
+        <h2 style="margin:18px 0 10px">Runs trained on it</h2>
+        <${Table} dense=${true} rows=${data.runs} rowKey=${(r) => r.id} onRow=${(r) => navigate(`${ctx.base}/runs/${r.id}`)} columns=${[
+          { key: "name", label: "Run" }, { key: "kind", label: "Kind" }, { key: "weight", label: "Weight", num: true, render: (r) => f.num(r.weight, 2) }]} />
+      </div>
+    </div>
+    <div class="section"><div class="section-head"><h2>Rows</h2><span class="muted small">${f.int(data.row_count)} sample rows stored of ${f.int(d.rows)}</span></div>
+      <div class="split split-list">
+        <div class="table-wrap" style="max-height:560px"><table class="t dense"><tbody>${data.rows.map((r, i) => html`<tr class=${`click ${i === open ? "sel" : ""}`} onClick=${() => setOpen(i)}>
+          <td><span class="muted small">#${r.idx} · ${r.source || r.category || ""}</span><span class="sub ellipsis" style="max-width:280px;color:var(--ink)">${preview(r)}</span></td></tr>`)}</tbody></table></div>
+        <div class="panel"><div class="panel-body">${data.rows[open] ? html`<${RowView} row=${data.rows[open]} />` : html`<span class="muted">No rows stored.</span>`}</div></div>
+      </div></div>`;
+}
+
+function preview(r) {
+  const d = r.data || {};
+  if (d.messages) return (d.messages.find((m) => m.role === "user") || d.messages[0]).content.slice(0, 120);
+  if (d.prompt) return String(d.prompt).slice(0, 120);
+  return JSON.stringify(d).slice(0, 120);
+}
diff --git a/viewer/static/pages/environments.js b/viewer/static/pages/environments.js
new file mode 100644
index 0000000000000000000000000000000000000000..0862b9e793f7909c54791518dca00ef3094a2d9d
--- /dev/null
+++ b/viewer/static/pages/environments.js
@@ -0,0 +1,204 @@
+import { html, useApi, useState, setQuery, navigate, setRolloutOrder } from "../lib.js";
+import { Loading, Err, Table, ProjectLink, Tabs, Facts, Hist, Delta, Status, Outcome, Empty, Provenance, Level, Icon } from "../ui/common.js";
+import { Command } from "../ui/forms.js";
+import { AddInputDialog } from "./stages.js";
+import { LineChart, Columns, SERIES } from "../ui/chart.js";
+import * as f from "../ui/fmt.js";
+
+const STATUS_LABEL = { ok: "OK", flaky: "Flaky", invalid: "Invalid", leaky: "Leaky", hackable: "Hackable", too_easy: "Too easy", too_hard: "Too hard", excluded: "Excluded" };
+
+export function Environments({ ctx }) {
+  const adding = ctx.writable && ctx.query.get("add") === "environment";
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/environments`, undefined, [], { every: adding ? 4000 : 0 });
+  const { data: hs } = useApi(`/p/${ctx.org}/${ctx.project}/harnesses`);
+  const [text, setText] = useState("");
+  const domain = ctx.query.get("domain") || "";
+  const view = ctx.query.get("view") || "environments";
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const multiHarness = hs && hs.length > 1;
+  const domains = [...new Set(data.map((e) => e.domain))];
+  const rows = data.filter((e) => (!domain || e.domain === domain) && (!text || e.name.toLowerCase().includes(text.toLowerCase())));
+  const totalTasks = data.reduce((s, e) => s + (e.task_count || 0), 0);
+  const newest = data.reduce((a, e) => (!a || (e.created_at || 0) > (a.created_at || 0) ? e : a), null);
+  const head = html`<div class="page-head"><div class="grow"><h1>Environments</h1>
+      <p class="lede">Where rollouts happen: the task pool, the harness that drives the model, the sandbox, and the grader that turns an attempt into a reward. ${f.int(data.length)} environments, ${f.int(totalTasks)} tasks.</p></div>
+      ${ctx.writable ? html`<button class="btn primary" onClick=${() => setQuery({ add: "environment" }, { replace: false })}><${Icon} name="plus" size=${14} />Add environment</button>` : null}</div>
+    ${adding ? html`<${AddInputDialog} ctx=${ctx} kind="environment" count=${data.length} latest=${newest} onClose=${() => setQuery({ add: null })} />` : null}`;
+  if (ctx.writable && !data.length) {
+    return html`${head}<div class="panel"><div class="panel-body"><b>No environments yet.</b>
+      <div class="sec small" style="margin:3px 0 10px">RL trains on environments: tasks, a harness, a sandbox and a grader. Add one here, or from a terminal:</div>
+      <div style="max-width:560px"><${Command} cmd="posttrain env add ./code-tasks" /></div></div></div>`;
+  }
+  return html`
+    ${head}
+    ${multiHarness ? html`<${Tabs} param="view" current=${view} tabs=${[{ id: "environments", label: "Environments", count: data.length }, { id: "harnesses", label: "Harnesses", count: hs.length }]} />` : null}
+    ${view === "harnesses" && multiHarness ? html`<${Harnesses} rows=${hs} />` : html`<div>
+    <div class="filters">
+      <input class="input search" placeholder="Filter environments" value=${text} onInput=${(e) => setText(e.target.value)} />
+      <div class="seg">${[["", "All"], ...domains.map((d) => [d, d])].map(([k, l]) => html`<button class=${domain === k ? "on" : ""} onClick=${() => setQuery({ domain: k })}>${l}</button>`)}</div>
+      <span class="muted small">${rows.length} shown</span>
+    </div>
+    <${Table} rows=${rows} rowKey=${(e) => e.id} onRow=${(e) => navigate(`${ctx.base}/environments/${e.id}`)} initialSort=${{ key: "task_count", dir: -1 }} columns=${[
+      { key: "name", label: "Environment", render: (e) => html`<${ProjectLink} ctx=${ctx} to=${`/environments/${e.id}`}>${e.name}</${ProjectLink}><span class="sub">${e.domain}${e.harness ? ` · ${e.harness}` : ""}</span>` },
+      { key: "task_count", label: "Tasks", num: true, render: (e) => f.int(e.task_count) },
+      { key: "grader", label: "Grader", render: (e) => html`${e.grader_kind ? e.grader_kind.replace("_", " ") : "—"}<span class="sub">${e.reward_kind} reward</span>` },
+      { key: "flagged", label: "Flagged tasks", num: true, sortValue: (e) => e.stats.flagged, render: (e) => e.stats.flagged ? html`<span class="lvl warn">${f.int(e.stats.flagged)}</span>` : html`<span class="muted">0</span>` },
+      { key: "base", label: "Base pass rate", num: true, sortValue: (e) => e.stats.base, render: (e) => f.pct(e.stats.base, 1) },
+      { key: "latest", label: "Latest policy", num: true, sortValue: (e) => e.stats.latest, render: (e) => html`${f.pct(e.stats.latest, 1)} <span class="small"><${Delta} a=${e.stats.base} b=${e.stats.latest} /></span>` },
+      { key: "signal", label: "No signal now (never · always solved)", num: true, sortValue: (e) => ((e.stats.hard_now || 0) + (e.stats.easy_now || 0)) / (e.stats.n || 1),
+        render: (e) => e.stats.n ? html`${f.pct((e.stats.hard_now || 0) / e.stats.n, 0)} · ${f.pct((e.stats.easy_now || 0) / e.stats.n, 0)}` : "—" },
+      { key: "infra", label: "Infra errors", num: true, sortValue: (e) => e.rollouts.n ? e.rollouts.infra / e.rollouts.n : null, render: (e) => e.rollouts.n ? f.pct(e.rollouts.infra / e.rollouts.n, 1) : "—" },
+      { key: "secs", label: "Time per attempt", num: true, sortValue: (e) => e.rollouts.secs, render: (e) => f.duration(e.rollouts.secs) },
+      { key: "runs", label: "Used by", sortValue: (e) => e.runs.length, render: (e) => e.runs.length ? html`<span class="small">${e.runs.slice(0, 2).map((r) => r.name).join(", ")}${e.runs.length > 2 ? ` +${e.runs.length - 2}` : ""}</span>` : html`<span class="muted">—</span>` },
+    ]} /></div>`}`;
+}
+
+function Harnesses({ rows }) {
+  return html`<p class="lede small" style="margin-top:0">The agent loops rollouts ran in: the same task can be attempted through different tools and prompts. Counts are over stored rollouts.</p>
+    <${Table} rows=${rows} rowKey=${(h) => h.harness} initialSort=${{ key: "n", dir: -1 }} columns=${[
+      { key: "harness", label: "Harness", render: (h) => html`<span class="mono">${h.harness}</span>` },
+      { key: "n", label: "Rollouts", num: true, render: (h) => f.int(h.n) },
+      { key: "pass", label: "Passed", num: true, sortValue: (h) => h.passed / (h.scored || 1), render: (h) => html`${f.pct(h.passed / (h.scored || 1), 1)} <span class="muted small">of ${f.int(h.scored)}</span>` },
+      { key: "limits", label: "Hit a limit", num: true, sortValue: (h) => h.limits / (h.n || 1), render: (h) => f.pct(h.limits / (h.n || 1), 1) },
+      { key: "infra", label: "Infra errors", num: true, sortValue: (h) => h.infra / (h.n || 1), render: (h) => f.pct(h.infra / (h.n || 1), 1) },
+      { key: "turns", label: "Turns", num: true, render: (h) => f.num(h.turns, 1) },
+      { key: "tokens_out", label: "Tokens out", num: true, render: (h) => f.compact(h.tokens_out) },
+      { key: "secs", label: "Time per attempt", num: true, render: (h) => f.duration(h.secs) },
+      { key: "envs", label: "Environments", num: true },
+    ]} />`;
+}
+
+export function Environment({ ctx, id }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/environments/${id}`);
+  const tab = ctx.query.get("tab") || "overview";
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const e = data.environment;
+  const flagged = Object.entries(data.status_counts).filter(([k]) => k !== "ok").reduce((s, [, n]) => s + n, 0) + (e.checks || []).filter((k) => k.status !== "pass").length;
+  const tabs = [{ id: "overview", label: "Overview" }, { id: "tasks", label: "Tasks", count: f.int(data.tasks.length) },
+    { id: "validation", label: "Validation", count: flagged || null }, { id: "rollouts", label: "Recent rollouts" }];
+  return html`
+    <div class="page-head"><div class="grow">
+      <div class="crumb-line"><${ProjectLink} ctx=${ctx} to="/environments">Environments</${ProjectLink}> / ${e.domain}</div>
+      <div class="row wrap" style="gap:12px"><h1>${e.name}</h1><span class="chip">${e.domain}</span><${Provenance} value=${e.provenance} source=${e.source} /></div>
+      ${e.description ? html`<p class="lede">${e.description}</p>` : null}
+      <div style="margin-top:10px"><${Facts} items=${[["tasks", f.int(e.task_count)], ["harness", e.harness || "—"], ["tools", (e.tools || []).join(", ") || "none"],
+        ["reward", e.reward_kind], data.grader ? ["grader", data.grader.name] : null,
+        e.sandbox ? ["sandbox", Object.entries(e.sandbox).map(([k, v]) => `${k} ${v}`).join(", ")] : null, e.version ? ["version", e.version] : null]} /></div>
+    </div></div>
+    <${Tabs} tabs=${tabs} current=${tab} />
+    ${tab === "overview" ? html`<${EnvOverview} ctx=${ctx} data=${data} />` : null}
+    ${tab === "tasks" ? html`<${EnvTasks} ctx=${ctx} data=${data} />` : null}
+    ${tab === "validation" ? html`<${EnvValidation} data=${data} />` : null}
+    ${tab === "rollouts" ? html`<${EnvRollouts} ctx=${ctx} data=${data} />` : null}`;
+}
+
+function EnvOverview({ ctx, data }) {
+  const g = data.grader;
+  const runs = data.runs.filter((r) => r.pass_rate && r.pass_rate.length);
+  const bins = (h) => h.map((n, i) => ({ label: `${i * 10}`, title: `${i * 10}–${i * 10 + 10}% pass rate`, value: n }));
+  return html`
+    <div class="grid cols-2">
+      <div class="chart-card"><div class="cc-head"><span class="cc-title">Task pass rates, base model</span></div>
+        <${Columns} height=${130} bars=${bins(data.hist_base).map((b) => ({ ...b, color: "var(--s1)" }))} />
+        <div class="cc-desc">Tasks in the first bin are never solved and those in the last are always solved; neither produces a gradient.</div></div>
+      <div class="chart-card"><div class="cc-head"><span class="cc-title">Task pass rates, latest policy</span></div>
+        <${Columns} height=${130} bars=${bins(data.hist_latest).map((b) => ({ ...b, color: "var(--train)" }))} />
+        <div class="cc-desc">The same tasks under the most recent checkpoint that trained on this environment.</div></div>
+    </div>
+    ${runs.length ? html`<div class="section"><div class="section-head"><h2>Pass rate in each run</h2><span class="muted small">training attempts on this environment only</span></div>
+      <div class="chart-card"><${LineChart} height=${200} yFormat=${(v) => f.pct(v, 0)}
+        series=${runs.map((r, i) => ({ key: r.id, label: r.name, color: SERIES[i % 8], points: r.pass_rate }))} /></div></div>` : null}
+    <div class="section grid cols-2">
+      <div class="panel"><div class="panel-head"><h3>Grader</h3>${g ? html`<span class="muted small">${g.kind}</span>` : null}</div>
+        <div class="panel-body">${g ? html`<p class="small" style="margin-top:0">${g.description}</p>
+          <${Table} dense=${true} rows=${g.components || []} rowKey=${(c) => c.name} columns=${[
+            { key: "name", label: "Component" }, { key: "weight", label: "Weight", num: true }, { key: "rule", label: "Rule" }]} />
+          ${g.formula ? html`<p class="mono small">${g.formula}</p>` : null}` : html`<span class="muted">No grader recorded.</span>`}</div></div>
+      <div class="panel"><div class="panel-head"><h3>Runs using it</h3></div>
+        <${Table} dense=${true} rows=${data.runs} rowKey=${(r) => r.id} onRow=${(r) => navigate(`${ctx.base}/runs/${r.id}`)} columns=${[
+          { key: "name", label: "Run" }, { key: "status", label: "Status", render: (r) => html`<${Status} status=${r.status} />` },
+          { key: "weight", label: "Prompts per step", num: true, render: (r) => f.num(r.weight, 1) }]} /></div>
+    </div>`;
+}
+
+function EnvTasks({ ctx, data }) {
+  const q = ctx.query;
+  const [text, setText] = useState(q.get("q") || "");
+  const status = q.get("status") || "";
+  const band = q.get("band") || "";
+  const rows = data.tasks.filter((t) => (!status || t.status === status) && (!text || `${t.name} ${t.instruction}`.toLowerCase().includes(text.toLowerCase())) &&
+    (!band || (band === "never" ? t.latest_pass < 0.02 : band === "always" ? t.latest_pass > 0.98 : t.latest_pass >= 0.02 && t.latest_pass <= 0.98)));
+  return html`
+    <div class="filters">
+      <input class="input search" placeholder="Task name or instruction" value=${text} onInput=${(e) => { setText(e.target.value); }} onKeyDown=${(e) => e.key === "Enter" && setQuery({ q: text })} />
+      <select class="input" value=${status} onChange=${(e) => setQuery({ status: e.target.value })}>
+        <option value="">Any status</option>${Object.keys(data.status_counts).map((s) => html`<option value=${s}>${STATUS_LABEL[s] || s} (${data.status_counts[s]})</option>`)}</select>
+      <div class="seg">${[["", "All"], ["learnable", "Learnable now"], ["never", "Never solved"], ["always", "Always solved"]].map(([k, l]) => html`<button class=${band === k ? "on" : ""} onClick=${() => setQuery({ band: k })}>${l}</button>`)}</div>
+      <span class="muted small">${f.int(rows.length)} of ${f.int(data.tasks.length)}</span>
+    </div>
+    <${Table} dense=${true} maxHeight="640px" rows=${rows.slice(0, 1500)} rowKey=${(t) => t.id} initialSort=${{ key: "latest_pass", dir: 1 }}
+      onRow=${(t) => navigate(`${ctx.base}/tasks/${t.id}`)} columns=${[
+      { key: "name", label: "Task", render: (t) => html`<span class="mono small">${t.name}</span><span class="sub ellipsis" style="max-width:520px">${t.instruction}</span>` },
+      { key: "status", label: "Status", render: (t) => t.status === "ok" ? html`<span class="muted">OK</span>` : html`<span class="lvl warn" title=${t.status_reason}>${STATUS_LABEL[t.status] || t.status}</span>` },
+      { key: "base_pass", label: "Base", num: true, render: (t) => f.pct(t.base_pass, 0) },
+      { key: "latest_pass", label: "Latest", num: true, render: (t) => f.pct(t.latest_pass, 0) },
+      { key: "delta", label: "Change", num: true, sortValue: (t) => (t.latest_pass ?? 0) - (t.base_pass ?? 0), render: (t) => html`<${Delta} a=${t.base_pass} b=${t.latest_pass} />` },
+      { key: "oracle_score", label: "Oracle", num: true, render: (t) => f.num(t.oracle_score, 2) },
+      { key: "rerun_agree", label: "Rerun agreement", num: true, render: (t) => f.pct(t.rerun_agree, 0) },
+    ]} />
+    ${rows.length > 1500 ? html`<p class="muted small">Showing the first 1,500; filter to narrow.</p>` : null}`;
+}
+
+function EnvValidation({ data }) {
+  const n = data.tasks.length;
+  const c = data.status_counts;
+  const published = data.environment.checks || [];
+  const ran = {
+    oracle: data.tasks.some((t) => t.oracle_score !== null && t.oracle_score !== undefined),
+    noop: data.tasks.some((t) => t.noop_score !== null && t.noop_score !== undefined),
+    rerun: data.tasks.some((t) => t.reruns && t.rerun_agree !== null && t.rerun_agree !== undefined),
+    hack: (c.hackable || 0) > 0 || data.tasks.some((t) => t.status === "hackable"),
+    overlap: (c.excluded || 0) > 0,
+  };
+  const derived = [
+    ["Oracle solves it", "A reference solution must score 1. Tasks where it doesn't are invalid.", c.invalid || 0, ran.oracle],
+    ["Doing nothing fails", "An empty or no-op attempt must score 0; otherwise the expected answer leaks.", (c.leaky || 0), ran.noop],
+    ["Grader agrees with itself", "The oracle is re-run several times; any disagreement marks the task flaky.", c.flaky || 0, ran.rerun],
+    ["No shortcut", "A probe agent tries to get reward without solving the task.", c.hackable || 0, ran.hack],
+    ["Not in a held-out benchmark", "13-gram overlap with every eval set in the project.", c.excluded || 0, ran.overlap],
+  ];
+  const LV = { pass: "ok", warn: "warn", fail: "bad" };
+  return html`
+    ${published.length ? html`<div class="section" style="margin-top:0"><div class="section-head"><h2>Published checks</h2><span class="muted small">what the team reported about this environment</span></div>
+      <div class="panel"><div class="list-rows">${published.map((k) => html`<div class="finding" style="grid-template-columns:18px 220px 1fr">
+        <${Level} level=${LV[k.status] || "warn"} label="" /><b>${k.name}</b>
+        <div><div class="sec small">${k.detail}</div>
+          ${k.rounds && k.rounds.length ? html`<div class="row small" style="margin-top:4px"><span class="muted">by round:</span> ${k.rounds.map((v, i) => html`${i ? html`<span class="muted">→</span>` : null}<b>${typeof v === "number" && v <= 1 ? f.pct(v, 0) : v}</b>`)}</div>` : null}
+          ${k.source ? html`<a class="small" href=${k.source} target="_blank" rel="noopener">source</a>` : null}</div></div>`)}</div></div></div>` : null}
+    <div class="section" style=${published.length ? "" : "margin-top:0"}><div class="section-head"><h2>Task checks</h2><span class="muted small">per task, from the stored validation results</span></div>
+    <div class="panel"><div class="list-rows">${derived.map(([name, desc, bad, didRun]) => html`<div class="finding" style="grid-template-columns:18px 200px 1fr 170px">
+      ${didRun ? html`<${Level} level=${bad ? "warn" : "ok"} label="" />` : html`<span class="muted">–</span>`}<b>${name}</b><span class="sec small">${desc}</span>
+      <span class="num">${!didRun ? html`<span class="muted">not recorded</span>` : bad ? html`${f.int(bad)} of ${f.int(n)} fail` : html`all ${f.int(n)} pass`}</span></div>`)}</div></div>
+    <p class="muted small">Flagged tasks stay listed with their reason; runs sample only tasks that pass.</p></div>`;
+}
+
+function EnvRollouts({ ctx, data }) {
+  const kind = data.environment.reward_kind;
+  setRolloutOrder(data.rollouts.map((r) => r.id));
+  // a scalar reward has no pass or fail: its passed / failed / partial counts are one group of scored attempts
+  const scalar = kind === "scalar" || kind === "not observed";
+  const verdicts = ["passed", "failed", "partial"];
+  const outcomes = scalar ? [{ outcome: "scored", n: data.outcomes.filter((o) => verdicts.includes(o.outcome)).reduce((s, o) => s + o.n, 0) },
+    ...data.outcomes.filter((o) => !verdicts.includes(o.outcome))].filter((o) => o.n) : data.outcomes;
+  return html`<div class="grid cols-2" style="align-items:start">
+    <${Table} dense=${true} rows=${data.rollouts} rowKey=${(r) => r.id} onRow=${(r) => setQuery({ rollout: r.id })} columns=${[
+      { key: "task", label: "Task", render: (r) => html`<span class="ellipsis" style="display:inline-block;max-width:280px" title=${r.task}>${r.task}</span>` },
+      { key: "step", label: "Step", num: true }, { key: "outcome", label: scalar ? "Reward" : "Outcome", render: (r) => html`<${Outcome} outcome=${r.outcome} reward=${r.reward} kind=${kind} />` },
+      { key: "turns", label: "Turns", num: true }, { key: "duration_s", label: "Time", num: true, render: (r) => f.duration(r.duration_s) }]} />
+    <div class="panel"><div class="panel-head"><h3>Outcomes of stored attempts</h3>${scalar ? html`<span class="muted small">scalar reward: scored, not passed or failed</span>` : null}</div><div class="panel-body">
+      ${outcomes.map((o) => html`<div class="row" style="padding:3px 0">${o.outcome === "scored" ? html`<span class="oc scored"><i></i>Scored</span>` : html`<${Outcome} outcome=${o.outcome} />`}
+        <span class="grow"></span><span class="num">${f.int(o.n)}</span></div>`)}</div></div>
+  </div>`;
+}
diff --git a/viewer/static/pages/evals.js b/viewer/static/pages/evals.js
new file mode 100644
index 0000000000000000000000000000000000000000..046c68c241d437153c25bebc620a4f631d23da69
--- /dev/null
+++ b/viewer/static/pages/evals.js
@@ -0,0 +1,192 @@
+import { html, useApi, useState, setQuery, navigate, setRolloutOrder } from "../lib.js";
+import { Loading, Err, Table, ProjectLink, Delta, Provenance, Empty, Facts, Outcome } from "../ui/common.js";
+import { Command } from "../ui/forms.js";
+import { LineChart, Columns, SERIES } from "../ui/chart.js";
+import * as f from "../ui/fmt.js";
+
+export function Evals({ ctx }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/evals`);
+  const focus = ctx.query.get("benchmark");
+  const [allCols, setAllCols] = useState(false);
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  if (!data.benchmarks.length) {
+    return html`<div class="page-head"><div class="grow"><h1>Evals</h1></div>
+      ${ctx.writable ? html`<button class="btn primary" onClick=${() => navigate(`${ctx.base}/runs/new?stage=eval`)}>Run eval</button>` : null}</div>
+      ${ctx.writable ? html`<div class="panel"><div class="panel-body"><b>No evals yet.</b>
+        <div class="sec small" style="margin:3px 0 10px">An eval scores one model on a held-out benchmark, with a standard error over its tasks. Run one here, or from a terminal:</div>
+        <div style="max-width:560px"><${Command} cmd="posttrain eval <model> --bench gsm8k" /></div></div></div>` : html`<${Empty}>No benchmarks in this project yet.</${Empty}>`}`;
+  }
+  const benches = focus ? data.benchmarks.filter((b) => b.id === focus) : data.benchmarks;
+  const colsAll = data.columns.filter((c) => benches.some((b) => c.cells[b.id]));
+  const cols = allCols ? colsAll : colsAll.slice(0, 7);
+  const runColor = {};
+  Object.keys(data.run_names).forEach((id, i) => { runColor[id] = SERIES[i % 8]; });
+  return html`
+    <div class="page-head"><div class="grow"><h1>Evals</h1>
+      <p class="lede">Held-out benchmarks for every model and checkpoint. Scores carry their standard error over tasks; a difference smaller than about two standard errors is noise.</p></div>
+      ${ctx.writable ? html`<button class="btn primary" onClick=${() => navigate(`${ctx.base}/runs/new?stage=eval`)}>Run eval</button>` : null}</div>
+    ${focus ? html`<p><a href="#" onClick=${(e) => { e.preventDefault(); setQuery({ benchmark: null }); }}>All benchmarks</a></p>` : null}
+    <div class="table-wrap"><table class="t">
+      <thead><tr><th>Benchmark</th><th>Metric</th><th class="num">Tasks × attempts</th>${cols.map((c) => html`<th class="num col-name" title=${c.label}><span>${c.label}</span></th>`)}</tr></thead>
+      <tbody>${benches.map((b) => html`<tr>
+        <td class="bench-cell"><a href=${`?benchmark=${b.id}`} onClick=${(e) => { e.preventDefault(); setQuery({ benchmark: b.id }); }}>${b.name}</a><span class="sub">${[b.category, b.harness, b.version].filter(Boolean).join(" · ")}</span></td>
+        <td class="small">${b.metric}</td>
+        <td class="num">${f.int(b.n_tasks)} × ${b.k}</td>
+        ${cols.map((col) => {
+          const cell = col.cells[b.id];
+          if (!cell) return html`<td class="num muted">—</td>`;
+          return html`<td class="num"><${ProjectLink} ctx=${ctx} to=${`/evals/${cell.eval_id}`}><b>${f.score(b.metric, cell.score)}</b></${ProjectLink}>
+            <span class="muted small"> ${f.scoreErr(b.metric, cell.stderr)}</span>${cell.step !== null && cell.step !== undefined ? html`<span class="sub">step ${cell.step}</span>` : null}</td>`;
+        })}
+      </tr>`)}</tbody></table></div>
+    ${colsAll.length > 7 ? html`<p class="small"><a href="#" onClick=${(e) => { e.preventDefault(); setAllCols(!allCols); }}>${allCols ? "Show the 7 most recent models" : `Show all ${colsAll.length} models`}</a></p>` : null}
+
+    <div class="section"><div class="section-head"><h2>During training</h2><span class="muted small">one line per run; band is ±1 SE; click a point to open the eval</span></div>
+      <div class="grid ${benches.length > 1 ? "cols-2" : ""}">${benches.map((b) => {
+        const curves = data.curves[b.id] || {};
+        const ser = Object.entries(curves).map(([rid, pts]) => ({ key: rid, label: data.run_names[rid] || rid, color: runColor[rid],
+          points: pts.map((p) => [p[0], p[1]]), band: pts.map((p) => [p[0], p[1] - (p[2] || 0), p[1] + (p[2] || 0)]), dots: pts.length < 40 }));
+        if (!ser.length) return null;
+        return html`<div class="chart-card"><div class="cc-head"><span class="cc-title">${b.name}</span><span class="cc-unit">${b.metric}</span></div>
+          <${LineChart} height=${200} series=${ser} yFormat=${(v) => f.score(b.metric, v, 0)}
+            onPick=${(step) => { const e = Object.values(curves).flat().find((p) => p[0] === step); if (e) navigate(`${ctx.base}/evals/${e[3]}`); }} /></div>`;
+      })}</div></div>
+
+    <div class="section"><div class="section-head"><h2>All evals</h2><span class="muted small">${data.evals.length}</span></div>
+      <${Table} dense=${true} maxHeight="520px" rows=${data.evals.filter((e) => !focus || e.benchmark_id === focus)} rowKey=${(e) => e.id}
+        onRow=${(e) => navigate(`${ctx.base}/evals/${e.id}`)} initialSort=${{ key: "started_at", dir: -1 }} columns=${[
+        { key: "benchmark", label: "Benchmark" },
+        { key: "who", label: "Model", render: (e) => html`${e.run_name || e.model_name || "—"}${e.step !== null && e.step !== undefined ? html`<span class="sub">step ${e.step}</span>` : null}` },
+        { key: "score", label: "Score", num: true, render: (e) => e.status === "completed" ? html`<b>${f.score(e.metric, e.score, 2)}</b> <span class="muted small">${f.scoreErr(e.metric, e.stderr)}</span>` : html`<span class="muted">${e.status}</span>` },
+        { key: "n", label: "Tasks × attempts", num: true, render: (e) => `${f.int(e.n_tasks)} × ${e.k}` },
+        { key: "n_infra", label: "Infra excluded", num: true, render: (e) => f.int(e.n_infra) },
+        { key: "started_at", label: "Ran", num: true, render: (e) => f.shortDate(e.started_at) },
+      ]} /></div>`;
+}
+
+export function EvalDetail({ ctx, id }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/evals/${id}`);
+  const [filter, setFilter] = useState("");
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const e = data.eval, b = data.benchmark;
+  const others = data.siblings.filter((s) => s.id !== id);
+  const byTask = new Map();
+  for (const r of data.rollouts) {
+    if (!byTask.has(r.task_id)) byTask.set(r.task_id, []);
+    byTask.get(r.task_id).push(r);
+  }
+  setRolloutOrder(data.rollouts.map((r) => r.id));
+  const tasks = data.tasks.filter((t) => !filter || (filter === "solved" ? t.passes === t.attempts : filter === "unsolved" ? t.passes === 0 : t.passes > 0 && t.passes < t.attempts));
+  return html`
+    <div class="page-head"><div class="grow">
+      <div class="crumb-line"><${ProjectLink} ctx=${ctx} to="/evals">Evals</${ProjectLink}> / ${b.name}</div>
+      <div class="row wrap" style="gap:12px"><h1>${b.name}</h1><span class="chip">${e.run_name || e.model_name}${e.step !== null && e.step !== undefined ? ` · step ${e.step}` : ""}</span><${Provenance} value=${e.provenance} source=${e.source} /></div>
+      <div style="margin-top:10px;display:flex;align-items:baseline;gap:14px">
+        <span style="font-size:34px;font-weight:600;letter-spacing:-0.02em">${f.score(b.metric, e.score, 2)}</span>
+        ${e.stderr !== null && e.stderr !== undefined ? html`<span class="sec">${f.scoreErr(b.metric, e.stderr)}${f.isRaw(b.metric) ? "" : " pp"} (1 SE over ${f.int(e.n_tasks)} tasks)</span>` : html`<span class="sec">no per-task results published</span>`}</div>
+      <div style="margin-top:6px"><${Facts} items=${[["metric", b.metric], ["tasks × attempts", `${f.int(e.n_tasks)} × ${e.k}`], ["infra errors excluded", f.int(e.n_infra)],
+        ["harness", b.harness || "—"], ["ran", f.date(e.started_at)], e.cost_usd ? ["cost", f.money(e.cost_usd)] : null]} /></div>
+      ${e.command ? html`<pre class="code" style="margin-top:10px">${e.command}</pre>` : null}
+      ${b.description ? html`<p class="lede small">${b.description}</p>` : null}
+    </div></div>
+    <div class="grid cols-2">
+      <div class="chart-card"><div class="cc-head"><span class="cc-title">Tasks by attempts passed</span><span class="cc-unit">of ${e.k}</span></div>
+        <${Columns} height=${130} bars=${data.histogram.map((n, i) => ({ label: `${i}/${e.k}`, title: `${i} of ${e.k} attempts passed`, value: n, color: "var(--eval)" }))} />
+        <div class="cc-desc">Tasks at 0/${e.k} are never solved; tasks at ${e.k}/${e.k} always are. Only the ones in between are uncertain.</div></div>
+      <div class="chart-card"><div class="cc-head"><span class="cc-title">Other evals on ${b.name}</span></div>
+        ${others.length ? html`<${Table} dense=${true} maxHeight="170px" rows=${others.slice().reverse()} rowKey=${(s) => s.id} columns=${[
+          { key: "who", label: "Model", render: (s) => html`${s.run_name || s.model_name}${s.step !== null ? html` <span class="muted">step ${s.step}</span>` : ""}` },
+          { key: "score", label: "Score", num: true, render: (s) => html`${f.score(b.metric, s.score)} ${f.isRaw(b.metric) ? null : html`<${Delta} a=${e.score} b=${s.score} />`}` },
+          { key: "cmp", label: "", sortable: false, render: (s) => html`<${ProjectLink} ctx=${ctx} to=${`/evals/compare?a=${id}&b=${s.id}`}>Compare</${ProjectLink}>` },
+        ]} />` : html`<div class="empty">None yet.</div>`}</div>
+    </div>
+    <div class="section"><div class="section-head"><h2>Tasks</h2>
+      <div class="seg">${[["", "All"], ["solved", "Always solved"], ["mixed", "Sometimes"], ["unsolved", "Never solved"]].map(([k, l]) => html`<button class=${filter === k ? "on" : ""} onClick=${() => setFilter(k)}>${l}</button>`)}</div>
+      <span class="muted small">${tasks.length} of ${data.tasks.length}${data.rollouts.length ? ` · transcripts stored for ${byTask.size} tasks` : ""}</span></div>
+      <${Table} dense=${true} maxHeight="560px" rows=${tasks} rowKey=${(t) => t.task_name} initialSort=${{ key: "score", dir: 1 }}
+        onRow=${(t) => { const rs = byTask.get(t.task_id); if (rs) setQuery({ rollout: rs[0].id }); }}
+        rowClass=${(t) => byTask.has(t.task_id) ? "" : ""} columns=${[
+        { key: "task_name", label: "Task", render: (t) => html`${t.task_name}${byTask.has(t.task_id) ? html` <span class="tag">transcripts</span>` : null}` },
+        { key: "passes", label: "Passed", num: true, render: (t) => `${t.passes} / ${t.attempts}` },
+        { key: "score", label: "Score", num: true, render: (t) => f.pct(t.score, 0) },
+      ]} /></div>`;
+}
+
+/** The paired difference B − A over tasks both evals scored: mean, standard error, and how many tasks. */
+function paired(rows) {
+  const d = rows.filter((r) => r.a !== null && r.a !== undefined && r.b !== null && r.b !== undefined).map((r) => r.b - r.a);
+  const n = d.length;
+  if (!n) return { n: 0, mean: null, se: null };
+  const mean = d.reduce((s, x) => s + x, 0) / n;
+  const sd = n > 1 ? Math.sqrt(d.reduce((s, x) => s + (x - mean) ** 2, 0) / (n - 1)) : null;
+  return { n, mean, se: sd === null ? null : sd / Math.sqrt(n) };
+}
+
+export function Compare({ ctx }) {
+  const a = ctx.query.get("a"), b = ctx.query.get("b");
+  const { data, error } = useApi(a && b ? `/p/${ctx.org}/${ctx.project}/compare` : null, { a, b });
+  const [show, setShow] = useState("changed");
+  if (!a || !b) return html`<${Empty}>Pick two evals of the same benchmark to compare.</${Empty}>`;
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const A = data.a, B = data.b, bench = data.benchmark, metric = bench.metric;
+  // one run at two checkpoints is a before/after; anything else is two models side by side
+  const progression = A.run_id && A.run_id === B.run_id;
+  const who = (e) => e.run_name || e.model_name || "model";
+  const name = (e) => `${who(e)}${e.step !== null && e.step !== undefined ? ` @ step ${e.step}` : ""}`;
+  const la = progression ? `Step ${A.step}` : "A", lb = progression ? `Step ${B.step}` : "B";
+  const sameBench = A.benchmark_id === B.benchmark_id;
+  const rows = data.rows;
+  const both = rows.filter((r) => r.a !== null && r.a !== undefined && r.b !== null && r.b !== undefined);
+  const onlyA = rows.filter((r) => r.a !== null && r.a !== undefined && (r.b === null || r.b === undefined)).length;
+  const onlyB = rows.filter((r) => r.b !== null && r.b !== undefined && (r.a === null || r.a === undefined)).length;
+  const pd = paired(rows);
+  const unpaired = !pd.n && A.score !== null && B.score !== null ? { mean: B.score - A.score, se: Math.hypot(A.stderr || 0, B.stderr || 0) } : null;
+  const diff = pd.n ? pd : unpaired;
+  const raw = f.isRaw(metric);
+  const fmtDiff = (v) => (raw ? f.signed(v, 1) : f.pp(v));
+  const fmtSe = (v) => (v === null || v === undefined ? "" : raw ? `± ${f.num(v, 1)}` : `± ${f.num(v * 100, 1)} pp`);
+  const beyond = diff && diff.se ? Math.abs(diff.mean) > 2 * diff.se : null;
+  const verdict = !diff || diff.se === null ? "" : !beyond ? "within noise (under 2 SE)"
+    : diff.mean > 0 ? `${progression ? "higher at the later step" : `${who(B)} scores higher`}, beyond noise` : `${progression ? "lower at the later step" : `${who(A)} scores higher`}, beyond noise`;
+  const higherB = both.filter((r) => r.b > r.a), higherA = both.filter((r) => r.b < r.a);
+  const same1 = both.filter((r) => r.a === r.b && r.a === 1), same0 = both.filter((r) => r.a === r.b && r.a === 0);
+  const cards = progression
+    ? [["Gained", higherB.length, "scored higher at the later step"], ["Lost", higherA.length, "scored lower at the later step"],
+      ["Still solved", same1.length, "every attempt passed both times"], ["Still unsolved", same0.length, "no attempt passed either time"]]
+    : [[`${who(A)} higher`, higherA.length, "shared tasks where A scored more"], [`${who(B)} higher`, higherB.length, "shared tasks where B scored more"],
+      ["Both solve", same1.length, "every attempt passed for both"], ["Neither solves", same0.length, "no attempt passed for either"]];
+  const shown = show === "changed" ? both.filter((r) => r.a !== r.b) : show === "b" ? higherB : show === "a" ? higherA : rows;
+  const scoreLine = (e) => html`<b>${f.score(metric, e.score, 2)}</b> <span class="muted">${f.scoreErr(metric, e.stderr)}${raw ? "" : " pp"} · ${f.plural(e.n_tasks || 0, "task")}${e.k ? ` × ${e.k}` : ""}</span>`;
+  return html`
+    <div class="page-head"><div class="grow">
+      <div class="crumb-line"><${ProjectLink} ctx=${ctx} to="/evals">Evals</${ProjectLink}> / ${bench.name} / compare</div>
+      <h1>${progression ? html`${who(A)}: step ${A.step} → step ${B.step}` : html`${name(A)} vs ${name(B)}`}</h1>
+      <p class="lede">${progression ? `One run at two checkpoints on ${bench.name}.` : `Two models on the same benchmark, ${bench.name}: A is ${name(A)}, B is ${name(B)}.`}</p>
+      <div class="compare-facts">
+        <div><span class="k">${la}${progression ? "" : ` · ${name(A)}`}</span>${scoreLine(A)}</div>
+        <div><span class="k">${lb}${progression ? "" : ` · ${name(B)}`}</span>${scoreLine(B)}</div>
+        <div><span class="k">${pd.n ? `Paired difference, ${lb} − ${la}` : `Difference, ${lb} − ${la} (unpaired)`}</span>
+          ${diff ? html`<b class=${progression && beyond ? (diff.mean > 0 ? "delta-up" : "delta-down") : ""}>${fmtDiff(diff.mean)}</b> <span class="muted">${fmtSe(diff.se)}${pd.n ? ` over ${f.plural(pd.n, "shared task")}` : ""}</span>
+            ${verdict ? html`<div class="small sec">${verdict}</div>` : null}` : html`<span class="muted">—</span>`}</div>
+      </div>
+      ${!sameBench ? html`<div class="notice warn" style="margin-top:12px">These evals are on different benchmarks, so their scores are not comparable.</div>`
+        : onlyA || onlyB ? html`<div class="notice warn" style="margin-top:12px">The task sets differ: ${name(A)} has ${f.plural(both.length + onlyA, "scored task")} and ${name(B)} has ${f.int(both.length + onlyB)}; ${f.plural(both.length, "task is", "tasks are")} shared.
+            The paired difference uses only the shared tasks; each headline score uses its own tasks.</div>`
+        : !pd.n ? html`<div class="notice" style="margin-top:12px">Neither eval stored per-task results for the same tasks, so the difference is unpaired: its SE is the two SEs combined.</div>` : null}
+    </div></div>
+    ${both.length ? html`<div class="grid cols-4">
+      ${cards.map(([l, n, d]) => html`<div class="panel"><div class="panel-body"><div class="muted small ellipsis" title=${l}>${l}</div><div style="font-size:24px;font-weight:600">${f.int(n)}</div><div class="small muted">${d}</div></div></div>`)}
+    </div>` : null}
+    <div class="section"><div class="filters"><div class="seg">${(progression ? [["changed", "Changed"], ["b", "Gained"], ["a", "Lost"], ["all", "All"]]
+        : [["changed", "Changed"], ["a", "A higher"], ["b", "B higher"], ["all", "All"]]).map(([k, l]) => html`<button class=${show === k ? "on" : ""} onClick=${() => setShow(k)}>${l}</button>`)}</div>
+        <span class="muted small">${f.plural(rows.length, "task")}${onlyA || onlyB ? ` · ${f.int(both.length)} shared · ${f.int(onlyA)} only in ${la} · ${f.int(onlyB)} only in ${lb}` : ""}</span></div>
+      <${Table} dense=${true} maxHeight="600px" rows=${shown} rowKey=${(r) => r.task} initialSort=${{ key: "delta", dir: -1 }} columns=${[
+        { key: "task", label: "Task" },
+        { key: "a", label: progression ? la : `A · ${who(A)}`, num: true, render: (r) => r.a === null || r.a === undefined ? html`<span class="muted" title="Not in this eval">—</span>` : f.pct(r.a, 0) },
+        { key: "b", label: progression ? lb : `B · ${who(B)}`, num: true, render: (r) => r.b === null || r.b === undefined ? html`<span class="muted" title="Not in this eval">—</span>` : f.pct(r.b, 0) },
+        { key: "delta", label: `${lb} − ${la}`, num: true, render: (r) => html`<${Delta} a=${r.a} b=${r.b} better=${progression ? "up" : "none"} />` },
+      ]} /></div>`;
+}
diff --git a/viewer/static/pages/home.js b/viewer/static/pages/home.js
new file mode 100644
index 0000000000000000000000000000000000000000..7fe6f06bc238e953b7bc18046364422063aa0724
--- /dev/null
+++ b/viewer/static/pages/home.js
@@ -0,0 +1,58 @@
+import { html, useApi, Link, projectBase, setQuery } from "../lib.js";
+import { Loading, Err, Status, Icon } from "../ui/common.js";
+import { Command } from "../ui/forms.js";
+import * as f from "../ui/fmt.js";
+
+const KIND = { sft: "SFT", dpo: "preference", rl: "RL", distill: "distillation", rm: "reward model", eval: "eval" };
+
+export const SOURCES = [
+  { key: "workspace", title: "Your projects", about: "Projects in this workspace. You and the CLI add data, launch runs and record results here." },
+  { key: "demo", title: "Examples", about: "Read-only projects built from public recipes, with their published numbers." },
+  { key: "live", title: "BenchFlow runs", about: "Read-only record of BenchFlow's own training runs." },
+];
+
+function ProjectRows({ rows, now }) {
+  return html`<div class="table-wrap"><table class="t">
+    <thead><tr><th>Project</th><th>Organization</th><th>Stages</th><th class="num">Runs</th><th class="num">Benchmarks</th><th class="num">Environments</th>
+      <th class="num">Datasets</th><th>Released</th><th class="num">Last activity</th><th class="num">Spend</th></tr></thead>
+    <tbody>${rows.map((p) => html`<tr>
+      <td class="proj-cell"><${Link} href=${projectBase(p.org_slug, p.slug)}><b>${p.name}</b></${Link}>${p.source === "demo" ? html` <span class="tag">Example</span>` : null}
+        ${p.summary ? html`<span class="sub clamp2" title=${p.summary}>${p.summary}</span>` : null}</td>
+      <td class="small nowrap">${p.org_name}</td>
+      <td class="small">${p.kinds.map((k) => KIND[k] || k).join(" · ") || html`<span class="muted">—</span>`}</td>
+      <td class="num">${f.int(p.runs)}${p.running ? html`<span class="sub"><${Status} status="running" /> ${p.running}</span>` : null}
+        ${p.queued ? html`<span class="sub"><${Status} status="queued" /> ${p.queued}</span>` : null}</td>
+      <td class="num">${f.int(p.benchmarks)}</td><td class="num">${f.int(p.environments)}</td><td class="num">${f.int(p.datasets)}</td>
+      <td class="small released" title=${p.models.join("\n")}>${p.models.length ? html`${p.models.slice(0, 2).map((m) => html`<span class="ellipsis" style="display:block">${m}</span>`)}${p.models.length > 2 ? html`<span class="muted">+${p.models.length - 2} more</span>` : null}` : html`<span class="muted">—</span>`}</td>
+      <td class="num nowrap">${f.ago(p.last, now)}</td><td class="num">${f.money(p.cost)}</td></tr>`)}</tbody></table></div>`;
+}
+
+export function Home({ meta }) {
+  const { data, error } = useApi("/projects", { source: "" });
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const metas = meta.metas || {};
+  const newProject = () => setQuery({ new: "project" }, { replace: false });
+  return html`
+    <div class="page-head"><div class="grow"><h1>Projects</h1>
+      <p class="lede">Each project is one model program: its runs, the data and environments they train on, and the evals that judge them.</p></div>
+      <button class="btn primary write-only" onClick=${newProject}><${Icon} name="plus" size=${14} />New project</button></div>
+    ${meta.readonly ? html`<div class="notice" style="margin-bottom:18px">A read-only public copy of the PostTrain console. The example projects are built from published post-training programs; their published numbers link to the source, and everything else is simulated to agree and labelled so.</div>` : null}
+    ${SOURCES.map((s) => {
+      const rows = data.filter((p) => p.source === s.key);
+      if (!rows.length && s.key !== "workspace") return null;
+      const clock = metas[s.key] && metas[s.key].now ? +metas[s.key].now : null;
+      return html`<div class=${"section" + (s.key === "workspace" ? " write-only" : "")}>
+        <div class="section-head"><h2>${s.title}</h2><span class="muted small">${s.about}</span></div>
+        ${rows.length ? html`<${ProjectRows} rows=${rows} now=${clock} />` : html`<div class="panel first-project">
+          <div class="panel-body">
+            <div class="row wrap" style="gap:14px;align-items:flex-start">
+              <div class="grow" style="min-width:260px"><b>No projects yet.</b>
+                <div class="sec small" style="margin-top:3px">Create one, or from a terminal. The examples below show what a finished project looks like.</div></div>
+              <button class="btn primary" onClick=${newProject}><${Icon} name="plus" size=${14} />New project</button>
+            </div>
+            <div style="margin-top:12px;max-width:640px"><${Command} cmd="posttrain init --org <org> --name <name> --base <hf-model>" /></div>
+          </div></div>`}
+      </div>`;
+    })}`;
+}
diff --git a/viewer/static/pages/launch.js b/viewer/static/pages/launch.js
new file mode 100644
index 0000000000000000000000000000000000000000..711bf9efef1379140829a69ac443363c3074f937
--- /dev/null
+++ b/viewer/static/pages/launch.js
@@ -0,0 +1,420 @@
+// Launch a run from the browser (PRD 6.4): fields on the left; on the right the checks, rerun as you
+// edit, and the exact command. Launching queues the run for a runner (POST /p/{org}/{project}/runs with
+// launch: "runner"). The spec carries stage, recipe and params but no command: the runner builds the
+// job with posttrain.recipes.build(stage, recipe, params), as `posttrain train … --via-runner` does.
+import { html, useState, useApi, apiPost, invalidate, navigate, shq, slugify, Link } from "../lib.js";
+import { Loading, Err, Presence, ProjectLink } from "../ui/common.js";
+import { Field, Command, useSubmit, SubmitProblem, useHfModel, hfLine } from "../ui/forms.js";
+import * as f from "../ui/fmt.js";
+
+const STAGES = [
+  { id: "sft", label: "SFT", about: "Learn from example conversations." },
+  { id: "dpo", label: "Preference", about: "Prefer chosen over rejected responses (DPO)." },
+  { id: "rl", label: "RL", about: "Improve on tasks that a grader scores." },
+  { id: "eval", label: "Eval", about: "Score a model on held-out benchmarks." },
+];
+const STAGE_NAME = { sft: "SFT", dpo: "Preference", rl: "RL", eval: "Eval" };
+const HF_MODELS = ["Qwen/Qwen3-0.6B", "Qwen/Qwen3-1.7B", "Qwen/Qwen3-4B", "HuggingFaceTB/SmolLM2-135M-Instruct", "allenai/OLMo-2-0425-1B-Instruct"];
+const BENCHES = ["gsm8k", "ifeval", "mmlu_pro", "mmlu", "arc_challenge", "minerva_math"];
+const OUTPUT_FROM = { sft: [], dpo: ["sft"], rl: ["dpo", "sft"], eval: ["rl", "dpo", "sft"] };
+const HF_ID = /^[\w.-]+\/[\w.-]+$/;
+
+/** A number as the CLI and JSON both read it: 2e-5 rather than 0.00002. */
+function num(v) {
+  if (typeof v !== "number") return String(v);
+  return v !== 0 && Math.abs(v) < 1e-3 ? v.toExponential().replace("e+", "e") : String(v);
+}
+function parseValue(p, raw) {
+  if (raw === undefined) return p.default;
+  if (p.type === "bool") return !!raw;
+  const s = String(raw).trim();
+  if (s === "") return null;
+  if (p.type === "int") return /^-?\d+$/.test(s) ? parseInt(s, 10) : NaN;
+  if (p.type === "float") return /^-?(\d+\.?\d*|\.\d+)(e-?\d+)?$/i.test(s) ? parseFloat(s) : NaN;
+  return s;
+}
+function parseExtra(text) {
+  const out = {}, bad = [];
+  for (const line of text.split(/\n/)) {
+    const t = line.trim();
+    if (!t) continue;
+    const i = t.indexOf("=");
+    if (i < 1) { bad.push(t); continue; }
+    const k = t.slice(0, i).trim(), v = t.slice(i + 1).trim();
+    try { out[k] = JSON.parse(v); } catch (e) { out[k] = v; }
+  }
+  return { out, bad };
+}
+function short(base) {
+  const last = String(base || "").split(/[/:]/).filter(Boolean).pop() || "model";
+  return slugify(last).replace(/-+/g, "-").slice(0, 32) || "model";
+}
+/** The CLI line that launches a job spec the way the website does (`--via-runner`). */
+export function specCli(spec, target, project, group) {
+  const p = spec.params || {};
+  const own = new Set(["base", "data", "env", "steps", "name", "model", "benchmarks", "limit"]);
+  const sets = Object.entries(p).filter(([k, v]) => !own.has(k) && v !== null && v !== undefined && v !== "")
+    .map(([k, v]) => `--set ${shq(`${k}=${typeof v === "object" ? JSON.stringify(v) : num(v)}`)}`);
+  const head = spec.stage === "eval"
+    ? `posttrain eval ${shq(p.model || spec.base_model || "<model>")} --bench ${shq(p.benchmarks || "<benchmark>")}${p.limit ? ` --limit ${p.limit}` : ""}`
+    : `posttrain train ${spec.stage} --base ${shq(p.base || spec.base_model || "<model>")}${p.data ? ` --data ${shq(p.data)}` : ""}${p.env ? ` --env ${shq(p.env)}` : ""}`;
+  return [head, `--recipe ${spec.recipe}`, `--on ${shq(target || "<target>")}`, p.steps ? `--steps ${p.steps}` : null, p.name ? `--name ${shq(p.name)}` : null,
+    group ? `--group ${shq(group)}` : null, ...sets, "--via-runner", `--project ${shq(project)}`].filter(Boolean).join(" ");
+}
+
+/** PRD 7.1: which targets run which recipe. Prime in hosted mode runs prime-hosted and nothing else. */
+export function supports(recipe, t) {
+  const hosted = t.kind === "prime" && (t.config || {}).mode === "hosted";
+  if (recipe === "prime-hosted") return hosted;
+  return !hosted && ["local", "ssh", "slurm", "prime", "hf-jobs"].includes(t.kind);
+}
+
+function modelFrom(opts, ref) {
+  if (!ref) return null;
+  const m = opts.models.find((x) => x.name === ref || x.hf_repo === ref || x.id === ref);
+  if (m) return { mode: "project", key: `m:${m.id}`, hf: "" };
+  const k = opts.checkpoints.find((x) => x.path === ref);
+  if (k) return { mode: "project", key: `k:${k.id}`, hf: "" };
+  return { mode: "hf", key: "", hf: ref };
+}
+function defaultBase(opts, stage) {
+  const done = (kinds) => opts.models.find((m) => m.run_id && kinds.includes(m.run_kind) && m.run_status === "completed");
+  const m = done(OUTPUT_FROM[stage]) || opts.models.find((x) => x.kind === "base") || opts.models[0];
+  return m ? { mode: "project", key: `m:${m.id}`, hf: "" } : { mode: "hf", key: "", hf: "" };
+}
+function defaultInputs(opts, stage) {
+  if (stage === "sft") { const d = opts.datasets.find((x) => x.kind === "sft"); return d ? [d.name] : []; }
+  if (stage === "dpo") { const d = opts.datasets.find((x) => x.kind === "preference"); return d ? [d.name] : []; }
+  if (stage === "rl") {
+    const e = opts.environments.find((x) => x.ready) || opts.environments[0];
+    return e ? [`env:${e.name}`] : opts.datasets.filter((x) => x.kind === "rl").slice(0, 1).map((d) => d.name);
+  }
+  return [];
+}
+function recipesFor(opts, stage) {
+  return (opts.stage_recipes[stage] || []).map((id) => opts.recipes.find((r) => r.id === id)).filter((r) => r && stage in r.stages);
+}
+function defaultTarget(opts, recipe) {
+  const ts = opts.compute.targets.filter((t) => supports(recipe, t));
+  return (ts.find((t) => (t.runners || []).length) || ts.find((t) => t.name === "local") || ts[0] || { name: "" }).name;
+}
+
+export function NewRun({ ctx }) {
+  const from = ctx.query.get("from");
+  const opts = useApi(ctx.writable ? `/p/${ctx.org}/${ctx.project}/launch` : null, undefined, [], { every: 5000 });
+  const prev = useApi(ctx.writable && from ? `/runs/${from}/jobs` : null, { source: "" });
+  if (!ctx.writable) {
+    return html`<div class="page-head"><div class="grow"><h1>Launch a run</h1>
+      <p class="lede">This is an example project, so it is read-only. Runs launch in your own projects.</p>
+      <p><${Link} href="/dashboard?new=project">Create a project</${Link}></p></div></div>`;
+  }
+  if (opts.error && !opts.data) return html`<${Err} error=${opts.error} />`;
+  if (!opts.data || (from && !prev.data && !prev.error)) return html`<${Loading} />`;
+  const job = prev.data && prev.data.jobs.length ? prev.data.jobs[prev.data.jobs.length - 1] : null;
+  return html`<${LaunchForm} ctx=${ctx} opts=${opts.data} spec=${job && job.spec && job.spec.stage ? { ...job.spec, target: job.target } : null}
+    fromName=${prev.data ? prev.data.run.name : null} />`;
+}
+
+function LaunchForm({ ctx, opts, spec, fromName }) {
+  const q = ctx.query;
+  const first = spec ? spec.stage : STAGES.some((s) => s.id === q.get("stage")) ? q.get("stage") : "sft";
+  const firstRecipe = spec && recipesFor(opts, first).some((r) => r.id === spec.recipe) ? spec.recipe : opts.default_recipe[first];
+  const [stage, setStageRaw] = useState(first);
+  const [recipe, setRecipe] = useState(firstRecipe);
+  // a prefill (Launch again) puts the key settings back in their fields and anything else under Advanced
+  const firstKeys = new Set(((recipesFor(opts, first).find((r) => r.id === firstRecipe) || { params: {} }).params[first] || []).map((p) => p.key));
+  const prevParams = Object.entries((spec && spec.hyperparams) || {});
+  const [values, setValues] = useState(() => Object.fromEntries(prevParams.filter(([k]) => firstKeys.has(k)).map(([k, v]) => [k, typeof v === "boolean" ? v : num(v)])));
+  const [base, setBase] = useState(() => modelFrom(opts, spec ? spec.base_model : q.get("model")) || defaultBase(opts, first));
+  const [inputs, setInputs] = useState(() => (spec ? (spec.inputs || []).map((i) => (i.kind === "environment" ? `env:${i.ref}` : i.ref)) : defaultInputs(opts, first)));
+  const [benches, setBenches] = useState(() => (spec && spec.params && spec.params.benchmarks) || (opts.benchmarks.length ? opts.benchmarks.slice(0, 2).map((b) => b.name) : ["gsm8k"]).join(","));
+  const [steps, setSteps] = useState(spec && spec.steps_planned ? String(spec.steps_planned) : first === "rl" ? "200" : "");
+  const [target, setTarget] = useState(() => (spec && spec.target) || defaultTarget(opts, firstRecipe));
+  const [name, setName] = useState("");
+  const [group, setGroup] = useState(spec && spec.params && spec.params.group ? spec.params.group : "");
+  const [notes, setNotes] = useState("");
+  const [extra, setExtra] = useState(() => prevParams.filter(([k]) => !firstKeys.has(k)).map(([k, v]) => `${k}=${typeof v === "object" ? JSON.stringify(v) : num(v)}`).join("\n"));
+
+  const setStage = (s) => {
+    const r = opts.default_recipe[s];
+    setStageRaw(s);
+    setRecipe(r);
+    setValues({});
+    setBase(defaultBase(opts, s));
+    setInputs(defaultInputs(opts, s));
+    setSteps(s === "rl" ? "200" : "");
+    if (!supports(r, opts.compute.targets.find((t) => t.name === target) || { kind: "" })) setTarget(defaultTarget(opts, r));
+    const u = new URL(location.href);
+    u.searchParams.set("stage", s);
+    u.searchParams.delete("from");
+    u.searchParams.delete("model");
+    history.replaceState(null, "", u.pathname + u.search);
+  };
+  const pickRecipe = (id) => {
+    setRecipe(id);
+    setValues({});
+    if (!supports(id, opts.compute.targets.find((t) => t.name === target) || { kind: "" })) setTarget(defaultTarget(opts, id));
+  };
+  const recipes = recipesFor(opts, stage);
+  const rdef = recipes.find((r) => r.id === recipe) || recipes[0];
+  const pdefs = rdef.params[stage] || [];
+  const mdef = pdefs.find((p) => p.key === "method");
+  const method = mdef ? ("method" in values ? values.method : mdef.default) : null;
+  const lora = method === "lora";
+  const effDefault = (p) => (p.lr_by_method && method ? p.lr_by_method[method] : p.default);
+  const valueOf = (p) => (p.key in values ? parseValue(p, values[p.key]) : effDefault(p));
+  const visible = pdefs.filter((p) => !p.when || valueOf(pdefs.find((x) => x.key === p.when[0]) || {}) === p.when[1]);
+  const params = {};
+  const badParams = [];
+  for (const p of visible) {
+    const v = valueOf(p);
+    if (typeof v === "number" && isNaN(v)) badParams.push(p.label);
+    else if (v !== null && v !== undefined && v !== "") params[p.key] = v;
+  }
+  const ex = parseExtra(extra);
+  const known = new Set([...pdefs.map((p) => p.key), ...((rdef.more || {})[stage] || []).map((p) => p.key)]);
+  const unknown = (rdef.checked || {})[stage] ? Object.keys(ex.out).filter((k) => !known.has(k)) : [];
+  Object.assign(params, ex.out);
+  const changed = visible.filter((p) => p.key in values && valueOf(p) !== effDefault(p));
+
+  // the model
+  const models = opts.models, ckpts = opts.checkpoints;
+  let baseValue = "", baseLabel = "", baseModel = null;
+  if (base.mode === "hf") { baseValue = base.hf.trim(); baseLabel = baseValue; }
+  else if (base.key.startsWith("m:")) {
+    baseModel = models.find((x) => `m:${x.id}` === base.key);
+    if (baseModel) { baseValue = baseModel.hf_repo || baseModel.name; baseLabel = baseModel.name; }
+  } else if (base.key.startsWith("k:")) {
+    const k = ckpts.find((x) => `k:${x.id}` === base.key);
+    if (k) { baseValue = k.path; baseLabel = `${k.run_name} step ${k.step}`; }
+  }
+  const trainedInput = !!(baseModel && baseModel.run_id) || base.key.startsWith("k:");
+  const hf = useHfModel(base.mode === "hf" ? baseValue : "");
+  // inputs
+  const envNames = inputs.filter((x) => x.startsWith("env:")).map((x) => x.slice(4));
+  const dataNames = inputs.filter((x) => !x.startsWith("env:"));
+  const benchList = benches.split(",").map((s) => s.trim()).filter(Boolean);
+  const stepsNum = steps.trim() === "" ? null : /^\d+$/.test(steps.trim()) ? parseInt(steps, 10) : NaN;
+  const taken = new Set(opts.runs.map((r) => r.name));
+  let autoName = `${stage}-${short(baseLabel || baseValue)}`;
+  for (let i = 2; taken.has(autoName) && i < 100; i++) autoName = `${autoName.replace(/-\d+$/, "")}-${i}`;
+  const runName = name.trim() || autoName;
+  const targets = opts.compute.targets.filter((t) => supports(rdef.id, t));
+  const t = targets.find((x) => x.name === target) || null;
+  const online = t ? t.runners || [] : [];
+
+  // checks, with the CLI's ids (PRD section 4); fail blocks the launch, warn does not
+  const checks = [];
+  const check = (id, level, text) => checks.push({ id, level, text });
+  if (!baseValue) check("model.resolves", "fail", stage === "eval" ? "Choose the model to evaluate." : "Choose the input model.");
+  else if (base.mode === "hf" && !HF_ID.test(baseValue)) check("model.resolves", "fail", `${baseValue} isn't a Hugging Face id (org/name).`);
+  else if (base.mode === "hf" && hf && hf.state === "missing") check("model.resolves", "warn", `${baseValue}: ${hfLine(hf)}`);
+  else if (base.mode === "hf" && hf && hf.state === "found") check("model.resolves", hf.gated ? "warn" : "ok", `${baseValue} resolves (revision ${String(hf.sha || "").slice(0, 7)}${hf.license ? `, ${hf.license}` : ""}${hf.gated ? "); gated: the runner's HF token must have accepted its license" : ")"}`);
+  else check("model.resolves", "ok", base.mode === "hf" ? `${baseValue}: ${hf && hf.state === "checking" ? "checking on Hugging Face…" : "the runner resolves its revision"}` : `${baseLabel} is in this project`);
+  if (stage === "sft" || stage === "dpo") {
+    const need = stage === "sft" ? "sft" : "preference";
+    const chosen = opts.datasets.filter((d) => dataNames.includes(d.name));
+    const wrong = chosen.filter((d) => d.kind && d.kind !== need);
+    if (!chosen.length) check("data.ready", "fail", `Choose ${stage === "dpo" ? "a preference dataset" : "at least one SFT dataset"}.`);
+    else if (wrong.length) check("data.ready", "fail", `${wrong.map((d) => d.name).join(", ")} ${wrong.length === 1 ? "holds" : "hold"} ${wrong[0].kind} rows; ${STAGE_NAME[stage]} needs ${need} rows.`);
+    else check("data.ready", "ok", `${chosen.map((d) => `${d.name}${d.rows ? ` (${f.int(d.rows)} rows)` : ""}`).join(", ")}`);
+  }
+  if (stage === "rl") {
+    const chosen = opts.environments.filter((e) => envNames.includes(e.name));
+    const notReady = chosen.filter((e) => !e.ready);
+    if (!chosen.length && !dataNames.length) check("env.ready", "fail", "Choose at least one environment or RL dataset.");
+    else if (notReady.length) check("env.ready", "warn", `${notReady.map((e) => `${e.name}: ${e.reason}`).join("; ")}. Validate: posttrain env validate ${shq(notReady[0].name)} --on ${shq(target || "<target>")}`);
+    else check("env.ready", "ok", chosen.length ? chosen.map((e) => `${e.name} ready (${f.int(e.usable)} usable, ${f.int(e.learnable)} learnable)`).join(", ") : `${dataNames.join(", ")} with the ${params.reward || "exact_match"} reward`);
+  }
+  if (stage === "eval" && !benchList.length) check("eval.benchmarks", "fail", "Name at least one benchmark.");
+  if (!targets.length) check("target.supports", "fail", rdef.id === "prime-hosted" ? "No Prime target in hosted mode. Add one on the Compute page." : `No compute target runs ${rdef.label}. Add one on the Compute page.`);
+  else if (!t) check("target.supports", "fail", "Choose a compute target.");
+  else check("target.supports", "ok", `${rdef.label} runs on ${t.name} (${t.kind}${t.kind === "prime" ? `, ${(t.config || {}).mode || "pod"}` : ""})`);
+  if (stepsNum !== null && isNaN(stepsNum)) check("params", "fail", "Steps must be a whole number, or blank.");
+  if (badParams.length) check("params", "fail", `Not a number: ${badParams.join(", ")}.`);
+  if (ex.bad.length) check("params", "fail", `Write extra parameters as key=value: ${ex.bad.join(", ")}.`);
+  if (unknown.length) check("params", "fail", `${rdef.id} has no parameter ${unknown.join(", ")}.`);
+  if (stage === "dpo" && baseValue && !trainedInput) check("pref.base_input", "warn", "The input is a base model rather than an SFT model.");
+  if (stage === "dpo" && typeof params.beta === "number" && (params.beta < 0.01 || params.beta > 0.5)) check("pref.beta", "warn", `β ${num(params.beta)} is outside 0.01–0.5.`);
+  if (stage === "rl") {
+    const g = params.group_size;
+    if (typeof params.lr === "number" && mdef && ((lora && params.lr < 5e-6) || (!lora && params.lr > 1e-5))) {
+      check("hparams.lr", "warn", lora ? `LoRA learning rate ${num(params.lr)} is below 5e-6.` : `Full fine-tuning learning rate ${num(params.lr)} is above 1e-5.`);
+    }
+    if (typeof g === "number" && g < 8) check("hparams.group_size", "warn", `Group size ${g} is under 8.`);
+  }
+  const fails = checks.filter((c) => c.level === "fail");
+  const warns = checks.filter((c) => c.level === "warn");
+
+  const algorithm = rdef.stages[stage] || null;
+  const framework = (rdef.framework || {})[stage] || rdef.id;
+  const inputsPayload = [...dataNames.map((n) => ({ kind: "dataset", ref: n })), ...envNames.map((n) => ({ kind: "environment", ref: n }))];
+  const specParams = stage === "eval"
+    ? { model: baseValue, benchmarks: benchList.join(","), name: runName, ...params }
+    : { base: baseValue, data: dataNames.join(",") || null, env: envNames.join(",") || null, steps: stepsNum, name: runName, ...params };
+  const jobSpec = { stage, recipe: rdef.id, framework, algorithm, base_model: baseValue, inputs: inputsPayload,
+    hyperparams: params, steps_planned: stepsNum, params: specParams };
+  const body = { name: runName, kind: stage, stage: STAGE_NAME[stage], algorithm, framework, base_model: baseValue,
+    inputs: inputsPayload, hyperparams: params, steps_planned: stepsNum, group: group.trim() || undefined, description: notes.trim(),
+    launch: "runner", target, spec: jobSpec, metric_defs: (rdef.metric_defs || {})[stage] || [] };
+
+  // the same launch from a terminal
+  const cli = specCli(jobSpec, target, `${ctx.org}/${ctx.project}`, group.trim());
+
+  const [submit, state] = useSubmit(async () => {
+    const res = await apiPost(`/p/${ctx.org}/${ctx.project}/runs`, body);
+    invalidate();
+    navigate(res.url);
+  });
+  const launch = (e) => {
+    e.preventDefault();
+    if (!fails.length) submit();
+  };
+  const toggle = (v, only) => setInputs(only ? [v] : inputs.includes(v) ? inputs.filter((x) => x !== v) : [...inputs, v]);
+  const setVal = (k, v) => setValues({ ...values, [k]: v });
+
+  return html`
+    <div class="page-head"><div class="grow">
+      <div class="crumb-line"><${ProjectLink} ctx=${ctx} to="/runs">Runs</${ProjectLink}> / new</div>
+      <h1>Launch a run</h1>
+      <p class="lede">${fromName ? html`Prefilled from <b>${fromName}</b>. ` : null}Train or evaluate a model on your compute. A runner that serves the target starts it, and its logs and metrics stream to the run page.</p>
+    </div></div>
+    <form class="launch" onSubmit=${launch} novalidate>
+      <div class="launch-form">
+        <section class="lf-sec"><h3><span class="lf-num">1</span>Stage</h3>
+          <div class="choices four" role="radiogroup" aria-label="Stage">${STAGES.map((s) => html`<button type="button" role="radio" aria-checked=${stage === s.id}
+              class=${`choice ${stage === s.id ? "on" : ""}`} onClick=${() => stage !== s.id && setStage(s.id)}>
+            <b>${s.label}</b><span class="small sec">${s.about}</span></button>`)}</div>
+        </section>
+
+        <section class="lf-sec"><h3><span class="lf-num">2</span>${stage === "eval" ? "Model to evaluate" : "Input model"}</h3>
+          <div class="seg" style="margin-bottom:10px">
+            <button type="button" class=${base.mode === "project" ? "on" : ""} disabled=${!models.length && !ckpts.length}
+              onClick=${() => setBase({ ...base, mode: "project", key: base.key || (models[0] ? `m:${models[0].id}` : ckpts[0] ? `k:${ckpts[0].id}` : "") })}>From this project</button>
+            <button type="button" class=${base.mode === "hf" ? "on" : ""} onClick=${() => setBase({ ...base, mode: "hf" })}>Hugging Face</button>
+          </div>
+          ${base.mode === "project" ? html`<${Field} label="Model or checkpoint" help="Base models, models this project's runs produced, and checkpoints they saved.">
+              <select class="input" value=${base.key} onChange=${(e) => setBase({ ...base, key: e.target.value })}>
+                ${models.length ? html`<optgroup label="Models">${models.map((m) => html`<option value=${`m:${m.id}`}>${m.name}${m.run_name ? ` (from ${m.run_name})` : m.hf_repo && m.hf_repo !== m.name ? ` (${m.hf_repo})` : ""}</option>`)}</optgroup>` : null}
+                ${ckpts.length ? html`<optgroup label="Checkpoints">${ckpts.map((k) => html`<option value=${`k:${k.id}`}>${k.run_name} step ${k.step}</option>`)}</optgroup>` : null}
+              </select><//>`
+            : html`<${Field} label="Hugging Face model" help=${hfLine(hf) || "An id such as Qwen/Qwen3-0.6B. The runner downloads it, so a gated model needs its license accepted on that machine."}>
+              <input class="input mono" list="pt-hf-models" value=${base.hf} placeholder="org/model" spellcheck="false" autocomplete="off"
+                onInput=${(e) => setBase({ ...base, hf: e.target.value })} />
+              <datalist id="pt-hf-models">${HF_MODELS.map((m) => html`<option value=${m} />`)}</datalist><//>`}
+        </section>
+
+        <section class="lf-sec"><h3><span class="lf-num">3</span>${stage === "eval" ? "Benchmarks" : stage === "rl" ? "Environments" : stage === "dpo" ? "Preference dataset" : "Datasets"}</h3>
+          ${stage === "eval" ? html`<${Field} label="Benchmarks" help="lm-evaluation-harness task names, comma-separated.">
+              <input class="input mono" value=${benches} spellcheck="false" onInput=${(e) => setBenches(e.target.value)} /><//>
+            <div class="row wrap" style="margin-top:8px;gap:6px">${[...new Set([...opts.benchmarks.map((b) => b.name), ...BENCHES])].slice(0, 12).map((b) => html`
+              <button type="button" class=${`chip-btn ${benchList.includes(b) ? "on" : ""}`} aria-pressed=${benchList.includes(b)}
+                onClick=${() => setBenches((benchList.includes(b) ? benchList.filter((x) => x !== b) : [...benchList, b]).join(","))}>${b}</button>`)}</div>`
+          : html`<${InputPicker} opts=${opts} stage=${stage} inputs=${inputs} toggle=${toggle} />`}
+        </section>
+
+        <section class="lf-sec"><h3><span class="lf-num">4</span>Recipe and settings</h3>
+          ${recipes.length > 1 ? html`<div class="choices" role="radiogroup" aria-label="Recipe">${recipes.map((r) => html`<button type="button" role="radio" aria-checked=${rdef.id === r.id}
+              class=${`choice row-choice ${rdef.id === r.id ? "on" : ""}`} onClick=${() => pickRecipe(r.id)}>
+            <span class="radio-dot"></span><span><b>${r.label}</b> <span class="mono small muted">${r.id}</span><span class="small sec block">${r.about}</span></span></button>`)}</div>`
+            : html`<div class="small"><b>${rdef.label}</b> <span class="mono muted">${rdef.id}</span><div class="sec">${rdef.about}</div></div>`}
+          ${rdef.note ? html`<div class="notice" style="margin-top:10px">${rdef.note}</div>` : null}
+          ${mdef ? html`<div class="field" style="margin-top:14px"><span class="field-label">Method</span>
+            <div class="seg"><button type="button" class=${lora ? "on" : ""} onClick=${() => setVal("method", "lora")}>LoRA</button>
+              <button type="button" class=${!lora ? "on" : ""} onClick=${() => setVal("method", "full")}>Full</button></div>
+            <span class="field-help">${mdef.help}</span></div>` : null}
+          <div class="param-grid">
+            ${stage === "eval" ? null : html`<${Field} label="Steps" optional=${stage !== "rl"} error=${stepsNum !== null && isNaN(stepsNum) ? "A whole number, or blank." : null}
+                help=${stage === "rl" ? "Training steps." : "Blank trains for the epochs set here."}>
+                <input class="input" inputmode="numeric" value=${steps} placeholder=${stage === "rl" ? "200" : "all"} onInput=${(e) => setSteps(e.target.value)} /><//>`}
+            ${visible.filter((p) => p.key !== "method").map((p) => p.type === "bool" ? html`<div class="field"><span class="field-label">${p.label}</span>
+                <label class="check"><input type="checkbox" checked=${!!valueOf(p)} onChange=${(e) => setVal(p.key, e.target.checked)} /><span class="small">${p.help}</span></label></div>`
+              : p.type === "choice" ? html`<${Field} label=${p.label} help=${p.help}>
+                <select class="input" value=${valueOf(p)} onChange=${(e) => setVal(p.key, e.target.value)}>${p.choices.map((c) => html`<option value=${c}>${c}</option>`)}</select><//>`
+              : html`<${Field} label=${p.label} help=${changed.includes(p) ? `Default ${effDefault(p) === null ? "blank" : num(effDefault(p))}. ${p.help || ""}` : p.help}>
+                <input class=${`input ${changed.includes(p) ? "changed" : ""}`} value=${p.key in values ? values[p.key] : effDefault(p) === null ? "" : num(effDefault(p))}
+                  placeholder=${effDefault(p) === null ? "default" : ""} inputmode=${p.type === "str" ? "text" : "decimal"} spellcheck="false"
+                  onInput=${(e) => setVal(p.key, e.target.value)} /><//>`)}
+          </div>
+          <details class="more" open=${!!extra}><summary>Advanced</summary>
+            <${Field} label="More parameters" help=${html`One <span class="mono">key=value</span> per line, as with <span class="mono">--set</span>; values are read as JSON when they parse.`}>
+              <textarea class="input mono" rows="3" value=${extra} placeholder=${(rdef.more && rdef.more[stage] && rdef.more[stage][0]) ? `${rdef.more[stage][0].key}=${num(rdef.more[stage][0].default ?? "")}` : "key=value"} spellcheck="false" onInput=${(e) => setExtra(e.target.value)}></textarea><//>
+            ${(rdef.more || {})[stage] && rdef.more[stage].length ? html`<div class="table-wrap" style="margin-top:10px;max-height:240px"><table class="t dense">
+              <thead><tr><th>Parameter</th><th>Default</th><th>What it does</th></tr></thead>
+              <tbody>${rdef.more[stage].map((m) => html`<tr><td class="mono small">${m.key}</td><td class="mono small">${m.default === null ? "—" : num(m.default)}</td><td class="small sec">${m.help}</td></tr>`)}</tbody></table></div>` : null}
+          </details>
+        </section>
+
+        <section class="lf-sec"><h3><span class="lf-num">5</span>Compute target</h3>
+          ${targets.length ? html`<div class="choices">${targets.map((x) => html`<button type="button" role="radio" aria-checked=${target === x.name}
+              class=${`choice row-choice ${target === x.name ? "on" : ""}`} onClick=${() => setTarget(x.name)}>
+            <span class="radio-dot"></span>
+            <span class="grow"><b>${x.name}</b> <span class="muted small">${x.kind}${x.builtin ? ", the runner's own machine" : ""}</span>
+              ${Object.keys(x.config || {}).length ? html`<span class="small mono muted block ellipsis">${Object.entries(x.config).map(([k, v]) => `${k}=${v}`).join(" ")}</span>` : null}</span>
+            <span class="small nowrap"><${Presence} online=${(x.runners || []).length > 0} label=${(x.runners || []).length ? `${x.runners.join(", ")} online` : "no runner online"} />
+              ${x.queued ? html`<span class="block muted">${f.int(x.queued)} queued</span>` : null}</span></button>`)}</div>`
+            : html`<div class="notice warn">${rdef.id === "prime-hosted" ? "No Prime target in hosted mode yet." : `No compute target runs ${rdef.label} yet.`}</div>`}
+          <div class="small" style="margin-top:8px"><${ProjectLink} ctx=${ctx} to="/compute?add=1">Add a compute target</${ProjectLink}>
+            <span class="muted"> · only targets that run ${rdef.label} are listed</span></div>
+        </section>
+
+        <section class="lf-sec"><h3><span class="lf-num">6</span>Also</h3>
+          <div class="form-grid">
+            <${Field} label="Run name" optional=${true} help="Shown in lists and comparisons.">
+              <input class="input" value=${name} placeholder=${autoName} spellcheck="false" onInput=${(e) => setName(e.target.value)} /><//>
+            <${Field} label="Group" optional=${true} help="Runs in one group can be compared as a sweep.">
+              <input class="input" value=${group} list="pt-groups" spellcheck="false" onInput=${(e) => setGroup(e.target.value)} />
+              <datalist id="pt-groups">${[...new Set(opts.runs.map((r) => r.group_name).filter(Boolean))].map((g) => html`<option value=${g} />`)}</datalist><//>
+            <${Field} label="Notes" optional=${true} wide=${true} help="What this run tries; shown on the run page.">
+              <textarea class="input" rows="2" value=${notes} onInput=${(e) => setNotes(e.target.value)}></textarea><//>
+          </div>
+        </section>
+      </div>
+
+      <aside class="rail" aria-label="Checks and command">
+        <div class="rail-panel">
+          <h3>Checks</h3>
+          <div class="small sec" style="margin:2px 0 8px"><b>${runName}</b> · ${STAGE_NAME[stage]} with ${rdef.label}${t ? ` on ${t.name}` : ""}</div>
+          <ul class="checks">${checks.map((c) => html`<li class=${c.level}><span class="ck">${c.level}</span>
+            <span class="mono ck-id">${c.id}</span><span class="ck-text">${c.text}</span></li>`)}</ul>
+          ${t && !online.length ? html`<div class="notice" style="margin-top:10px">No runner is online for <b>${t.name}</b>. The run will wait in the queue until one connects (<${ProjectLink} ctx=${ctx} to="/compute">Compute → Runners</${ProjectLink}>). Start one on a machine that can reach ${t.name}:
+            <div style="margin-top:6px"><${Command} cmd=${`posttrain agent --targets ${shq(t.name)}`} compact=${true} /></div></div>` : null}
+          <${SubmitProblem} state=${state} onRetry=${submit.retry} />
+          <button type="submit" class="btn primary launch-btn" disabled=${state.busy || fails.length > 0}>${state.busy ? "Launching…" : `Launch run${warns.length ? ` · ${f.plural(warns.length, "warning")}` : ""}`}</button>
+          ${fails.length ? html`<div class="small" style="color:var(--bad-ink)">${fails[0].text}</div>` : html`<div class="small muted">Opens the run page, where the run is queued until ${online.length ? online[0] : "a runner"} picks it up.</div>`}
+        </div>
+        <div class="rail-panel">
+          <h3>Command</h3>
+          <${Command} cmd=${cli} />
+          <details class="more"><summary>Job spec for the runner</summary>
+            <pre class="code small-code">${JSON.stringify(jobSpec, null, 2)}</pre>
+            <p class="small muted">No command inside: the runner builds it with <span class="mono">posttrain.recipes.build</span> from stage, recipe and params.</p></details>
+        </div>
+      </aside>
+    </form>`;
+}
+
+function InputPicker({ opts, stage, inputs, toggle }) {
+  const one = stage === "dpo";
+  const need = stage === "sft" ? "sft" : stage === "dpo" ? "preference" : "rl";
+  const ds = opts.datasets.filter((d) => d.kind === need).concat(stage === "rl" ? [] : opts.datasets.filter((d) => d.kind !== need));
+  const envs = stage === "rl" ? opts.environments : [];
+  const none = stage === "rl" ? !envs.length && !opts.datasets.some((d) => d.kind === "rl") : !opts.datasets.some((d) => d.kind === need);
+  const hint = stage === "rl" ? "posttrain env add ./my-env" : `posttrain data add ${stage === "dpo" ? "./pairs.jsonl --kind preference" : "./train.jsonl --kind sft"}`;
+  return html`<div class="field wide" role="group">
+    ${none ? html`<div class="notice">No ${stage === "rl" ? "environments or RL datasets" : `${need} datasets`} in this project yet. Add one from the machine that has the files:
+        <div style="margin-top:8px"><${Command} cmd=${hint} compact=${true} /></div></div>` : null}
+    ${envs.length || ds.length ? html`<div class="pick-list">
+      ${envs.map((e) => html`<label class="pick"><input type=${one ? "radio" : "checkbox"} name="pt-inputs" checked=${inputs.includes(`env:${e.name}`)} onChange=${() => toggle(`env:${e.name}`, one)} />
+        <span class="grow"><b>${e.name}</b> <span class="muted small">environment${e.domain ? ` · ${e.domain}` : ""}</span>
+          <span class=${`block small ${e.ready ? "muted" : "warn-ink"}`}>${e.ready ? `ready: ${f.int(e.usable)} usable tasks, ${f.int(e.learnable)} learnable` : `not ready: ${e.reason}`}</span></span>
+        <span class="small muted nowrap">${f.plural(e.task_count || e.tasks || 0, "task")}</span></label>`)}
+      ${ds.map((d) => html`<label class=${`pick ${d.kind !== need ? "other" : ""}`}><input type=${one ? "radio" : "checkbox"} name="pt-inputs" checked=${inputs.includes(d.name)}
+          disabled=${d.kind !== need && !inputs.includes(d.name)} onChange=${() => toggle(d.name, one)} />
+        <span class="grow"><b>${d.name}</b> <span class="muted small">${d.kind || "dataset"}${d.version ? ` · ${d.version}` : ""}</span>
+          ${d.kind !== need ? html`<span class="block small muted">${d.kind || "unknown"} rows; ${STAGE_NAME[stage]} needs ${need} rows</span>` : null}</span>
+        <span class="small muted nowrap">${d.rows ? `${f.int(d.rows)} rows` : ""}</span></label>`)}
+    </div>` : null}
+    <span class="field-help">${stage === "sft" ? "Conversations to imitate; several are mixed." : stage === "dpo" ? "Each row holds a prompt, a chosen and a rejected response." : "Rewards come from each environment's grader, or from the reward set for an RL dataset."}</span>
+  </div>`;
+}
diff --git a/viewer/static/pages/live.js b/viewer/static/pages/live.js
new file mode 100644
index 0000000000000000000000000000000000000000..38581656262943983a39c181b502ad65724e6acc
--- /dev/null
+++ b/viewer/static/pages/live.js
@@ -0,0 +1,202 @@
+// A workspace run's status strip (PRD 6.5): what it is doing or waiting for, who has it, and the
+// actions (Stop run, Launch again, Copy command); and its log as it is written (GET /runs/{id}/logs?after=).
+import { html, useState, useEffect, useRef, getJson, apiPost, invalidate, navigate, shq, copyText } from "../lib.js";
+import { Status, Icon, ProjectLink } from "../ui/common.js";
+import { Command, useSubmit, SubmitProblem } from "../ui/forms.js";
+import { specCli } from "./launch.js";
+import * as f from "../ui/fmt.js";
+
+export const ACTIVE_JOB = new Set(["queued", "starting", "running"]);
+/** Run statuses that can still change on their own; pages showing them refresh themselves. */
+export const LIVE_RUN = new Set(["queued", "starting", "running", "stopping", "stalled"]);
+export const STALL = 300;   // seconds without a report before a running run counts as stalled (PRD 7.3)
+
+/** The job that decides what the run is doing now: the newest active one, else the newest. */
+export function currentJob(jobs) {
+  const js = (jobs && jobs.jobs) || [];
+  return [...js].reverse().find((j) => ACTIVE_JOB.has(j.status)) || js[js.length - 1] || null;
+}
+
+/** The run's status as people should read it: claimed is "starting", a stop request "stopping", silence "stalled". */
+export function liveStatus(run, jobs) {
+  const j = currentJob(jobs);
+  const now = jobs ? jobs.now : f.now();
+  if (run.status === "stopping" || run.status === "stalled" || run.status === "starting") return run.status;   // the server's own word
+  if (j && j.cancel && ACTIVE_JOB.has(j.status) && !["stopped", "completed", "failed"].includes(run.status)) return "stopping";
+  if (j && j.status === "starting" && run.status === "queued") return "starting";
+  const seen = lastReport(run);
+  if (run.status === "running" && seen && now - seen > STALL) return "stalled";
+  return run.status;
+}
+
+const HANDLE = { slurm: "Slurm job", local: "process", ssh: "process", "hf-jobs": "HF job", hf: "HF job", prime: "Prime pod", "prime-pod": "Prime pod",
+  "prime-train": "Prime run", "prime-hosted": "Prime run" };
+function handle(j) {
+  if (!j || !j.external_id) return null;
+  let h = j.external_id;
+  try { h = JSON.parse(h); } catch (e) { /* a plain id */ }
+  if (h && typeof h === "object") return `${HANDLE[h.kind] || h.kind || "job"} ${h.id ?? ""}`.trim();
+  return String(h);
+}
+/** When the run last reported anything: a heartbeat, a metric, a log line or a status. */
+export function lastReport(run) {
+  return Math.max(run.last_seen || 0, run.updated_at || 0) || null;
+}
+function age(s) { return s < 10 ? "just now" : f.duration(s); }
+
+function StopButton({ run, queued }) {
+  const [confirm, setConfirm] = useState(false);
+  const [submit, state] = useSubmit(async () => {
+    await apiPost(`/runs/${run.id}/cancel`);
+    setConfirm(false);
+    invalidate();
+  });
+  if (!confirm) {
+    return html`<button class="btn small" onClick=${() => setConfirm(true)}><${Icon} name="stop" size=${12} />${queued ? "Cancel run" : "Stop run"}</button>`;
+  }
+  return html`<div class="confirm" role="alertdialog" aria-label="Confirm stop">
+    <div class="small">${queued ? html`<b>Cancel run?</b> It hasn't started: it leaves the queue and is marked stopped.`
+      : html`<b>Stop run?</b> The trainer gets 120 seconds to save a checkpoint; checkpoints already saved stay available.`}</div>
+    <${SubmitProblem} state=${state} onRetry=${submit.retry} />
+    <div class="row" style="justify-content:flex-end;margin-top:8px">
+      <button class="btn small" onClick=${() => setConfirm(false)}>${queued ? "Keep it queued" : "Keep running"}</button>
+      <button class="btn small danger" disabled=${state.busy} onClick=${() => submit()}>${state.busy ? "Sending…" : queued ? "Cancel run" : "Stop run"}</button></div>
+  </div>`;
+}
+
+function CopyCommand({ cmd }) {
+  const [done, setDone] = useState(false);
+  return html`<button class="btn small ghost" title=${cmd} onClick=${() => { copyText(cmd); setDone(true); setTimeout(() => setDone(false), 1400); }}>
+    <${Icon} name="copy" size=${12} />${done ? "Copied" : "Copy command"}</button>`;
+}
+
+export function StatusStrip({ ctx, run, jobs }) {
+  const j = currentJob(jobs);
+  const status = liveStatus(run, jobs);
+  const now = jobs ? jobs.now : f.now();
+  const active = (j && ACTIVE_JOB.has(j.status)) || ["starting", "running", "stalled"].includes(run.status);
+  const h = handle(j);
+  const r = j && j.runner;
+  const reported = lastReport(run);
+  const quietFor = reported ? now - reported : null;
+  let line, extra = null;
+  if (status === "queued") {
+    const online = (j && j.runners_online) || [];
+    line = html`Queued ${age(now - ((j && j.created_at) || run.started_at))} · waiting for a runner that serves <b>${j ? j.target : "its target"}</b>
+      ${online.length ? ` (${online.length} online: ${online.join(", ")})` : " (none online)"}${j && j.ahead ? ` · ${f.plural(j.ahead, "run")} ahead of it` : ""}`;
+    if (j && !j.target_registered) {
+      extra = html`<b>${j.target}</b> isn't a compute target of this organization. <${ProjectLink} ctx=${ctx} to="/compute?add=1">Add it</${ProjectLink}>, then start a runner for it.`;
+    } else if (j && !online.length) {
+      extra = html`<div>Start one on a machine that can reach ${j.target}:</div><div style="margin-top:6px;max-width:520px"><${Command} cmd=${`posttrain agent --targets ${shq(j.target)}`} compact=${true} /></div>`;
+    }
+  } else if (status === "starting") {
+    line = html`Starting${h ? html` · ${h}` : ""}${j && j.message ? html` · ${j.message}` : ""} · picked up by ${r ? html`<b>${r.name}</b>${r.hostname ? ` on ${r.hostname}` : ""}` : "a runner"} ${f.ago(j.claimed_at, now)}`;
+    if (r && !r.online) extra = html`<span class="warn-ink">${r.name} was last heard from ${f.ago(r.last_seen, now)}.</span>`;
+  } else if (status === "running" || status === "stalled") {
+    const where = [h, j && j.message, r ? `via ${r.name}${r.hostname ? ` on ${r.hostname}` : ""}` : j ? null : "reported by the CLI or SDK where it runs"].filter(Boolean).join(" · ");
+    line = status === "stalled"
+      ? html`No report for ${f.duration(quietFor)} · last step ${f.int(run.steps_done)}${where ? ` · ${where}` : ""}`
+      : html`Running · step ${f.int(run.steps_done)}${run.steps_planned ? ` of ${f.int(run.steps_planned)}` : ""} · last report ${f.ago(reported, now)}${where ? ` · ${where}` : ""}`;
+    if (status === "stalled") extra = html`The job may be stuck, or the machine running it asleep or offline. It turns failed when its backend confirms the job ended.`;
+  } else if (status === "stopping") {
+    const ev = jobs && jobs.last_event && jobs.last_event.title === "Stop requested" ? jobs.last_event : null;
+    line = html`Stopping · requested ${ev ? f.ago(ev.t, now) : ""} · the trainer has up to 120 s to save a checkpoint`;
+    extra = html`${j && j.runner ? `${j.runner.name} stops the job` : "Whoever runs the job stops it"} at its next heartbeat.`;
+  } else if (status === "completed") {
+    line = html`Completed in ${f.duration((run.ended_at || now) - run.started_at)} · ${run.cost_usd ? f.money(run.cost_usd) : "$0 (no price set)"}`;
+  } else if (status === "failed") {
+    line = html`Failed at step ${f.int(run.steps_done)}${run.status_reason ? `: ${run.status_reason}` : ""} · <a href="?tab=logs" onClick=${(e) => { e.preventDefault(); navigate(`${ctx.base}/runs/${run.id}?tab=logs`); }}>last log lines</a>`;
+  } else if (status === "stopped") {
+    line = html`Stopped at step ${f.int(run.steps_done)}${run.status_reason ? ` · ${run.status_reason}` : ""}`;
+  } else {
+    line = run.status;
+  }
+  const spec = j && j.spec && j.spec.stage ? j.spec : null;
+  const queued = j && j.status === "queued";
+  return html`<div class=${`status-strip ${status}`}>
+    <${Status} status=${status} reason=${run.status_reason} />
+    <div class="grow"><div>${line}</div>${extra ? html`<div class="small sec" style="margin-top:4px">${extra}</div>` : null}</div>
+    <div class="strip-actions">
+      ${active && status !== "stopping" ? html`<${StopButton} run=${run} queued=${queued} />` : null}
+      ${spec ? html`<button class="btn small ghost" onClick=${() => navigate(`${ctx.base}/runs/new?from=${run.id}`)}>Launch again</button>` : null}
+      ${spec ? html`<${CopyCommand} cmd=${specCli(spec, j.target, `${ctx.org}/${ctx.project}`, run.group_name)} />` : null}
+      ${active ? html`<span class="small muted nowrap">updates every 3 s</span>` : null}
+    </div>
+  </div>`;
+}
+
+// ------------------------------------------------------------------ logs
+const KEEP = 50000, SHOW = 4000;
+function hms(t) {
+  const d = new Date(t * 1000);
+  return [d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds()].map((x) => String(x).padStart(2, "0")).join(":");
+}
+
+export function RunLogs({ run, live, queued }) {
+  const [lines, setLines] = useState([]);
+  const [loaded, setLoaded] = useState(false);
+  const [error, setError] = useState(null);
+  const [filter, setFilter] = useState("");
+  const [stream, setStream] = useState("");
+  const [follow, setFollow] = useState(true);
+  const [wrap, setWrap] = useState(true);
+  const after = useRef(0);
+  const box = useRef(null);
+  useEffect(() => { after.current = 0; setLines([]); setLoaded(false); }, [run.id]);
+  useEffect(() => {
+    let alive = true, timer = null;
+    const pull = async () => {
+      try {
+        for (let more = true; more && alive;) {
+          const batch = await getJson(`/runs/${run.id}/logs`, { source: "", after: after.current, limit: 2000 });
+          if (!alive) return;
+          if (batch.length) {
+            after.current = batch[batch.length - 1].seq;
+            setLines((ls) => (ls.length + batch.length > KEEP ? [...ls, ...batch].slice(-KEEP) : [...ls, ...batch]));
+          }
+          more = batch.length === 2000;
+        }
+        setError(null);
+      } catch (e) {
+        if (alive) setError(e);
+      }
+      if (!alive) return;
+      setLoaded(true);
+      if (live) timer = setTimeout(pull, 2500);
+    };
+    pull();
+    return () => { alive = false; clearTimeout(timer); };
+  }, [run.id, live]);
+  useEffect(() => {
+    if (follow && box.current) box.current.scrollTop = box.current.scrollHeight;
+  }, [lines, follow, filter, stream]);
+  const q = filter.trim().toLowerCase();
+  const streams = [...new Set(lines.map((l) => l.stream || "stdout"))];
+  const matched = lines.filter((l) => (!stream || (l.stream || "stdout") === stream) && (!q || l.text.toLowerCase().includes(q)));
+  const shown = matched.length > SHOW ? matched.slice(-SHOW) : matched;
+  const download = () => {
+    const a = document.createElement("a");
+    a.href = URL.createObjectURL(new Blob([lines.map((l) => l.text).join("\n") + "\n"], { type: "text/plain" }));
+    a.download = `${run.name}.log`;
+    a.click();
+  };
+  return html`<div>
+    <div class="filters">
+      <input class="input search" placeholder="Search the log" value=${filter} onInput=${(e) => setFilter(e.target.value)} />
+      ${streams.length > 1 ? html`<select class="input" value=${stream} onChange=${(e) => setStream(e.target.value)} aria-label="Stream">
+        <option value="">Every stream</option>${streams.map((s) => html`<option value=${s}>${s}</option>`)}</select>` : null}
+      <label class="check small"><input type="checkbox" checked=${follow} onChange=${(e) => setFollow(e.target.checked)} />Follow</label>
+      <label class="check small"><input type="checkbox" checked=${wrap} onChange=${(e) => setWrap(e.target.checked)} />Wrap lines</label>
+      <span class="muted small">${q || stream ? `${f.int(matched.length)} of ` : ""}${f.plural(lines.length, "line")}${live ? " · streaming" : ""}${matched.length > SHOW ? ` · showing the last ${f.int(SHOW)}` : ""}</span>
+      <span class="grow"></span>
+      <button class="btn small" disabled=${!lines.length} onClick=${download}><${Icon} name="download" size=${13} />Download</button>
+    </div>
+    ${error ? html`<div class="form-error">${String(error.message || error)}</div>` : null}
+    <div class=${`logs ${wrap ? "wrap" : ""}`} ref=${box} role="log" aria-live="polite"
+        onScroll=${(e) => { const el = e.currentTarget; const bottom = el.scrollHeight - el.scrollTop - el.clientHeight < 24; if (bottom !== follow) setFollow(bottom); }}>
+      ${!loaded ? html`<div class="log-empty">Loading…</div>`
+        : !lines.length ? html`<div class="log-empty">${queued ? "No output yet: logs appear once a runner starts the job." : live ? "No output yet." : "This run wrote no log lines."}</div>`
+        : shown.map((l) => html`<div class=${`ll ${l.stream === "stderr" ? "stderr" : ""}`} key=${l.seq}><span class="lt" title=${`${f.date(l.t)} · ${l.stream || "stdout"}`}>${hms(l.t)}</span><span class="lx">${l.text}</span></div>`)}
+    </div>
+  </div>`;
+}
diff --git a/viewer/static/pages/models.js b/viewer/static/pages/models.js
new file mode 100644
index 0000000000000000000000000000000000000000..310a2777cef683712a72b542eb7f52deb2ff16f0
--- /dev/null
+++ b/viewer/static/pages/models.js
@@ -0,0 +1,90 @@
+import { html, useApi, navigate, useState, getSource } from "../lib.js";
+import { Loading, Err, Table, ProjectLink, Status, Empty } from "../ui/common.js";
+import * as f from "../ui/fmt.js";
+
+const KIND = { base: "Base", checkpoint: "Checkpoint", teacher: "Teacher", reward: "Reward model", judge: "Judge", external: "Reference" };
+
+function DeployDialog({ data, onClose }) {
+  const candidates = data.models.filter((m) => m.kind !== "external" && m.kind !== "judge");
+  const [modelId, setModelId] = useState((candidates.find((m) => m.status === "released") || candidates[candidates.length - 1] || {}).id);
+  const m = candidates.find((x) => x.id === modelId) || {};
+  const [name, setName] = useState("");
+  const [ckpt, setCkpt] = useState(null);
+  const [sent, setSent] = useState(null);
+  const slug = (name || m.name || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  const ckpts = data.checkpoints.filter((k) => m.run_id ? k.run_id === m.run_id : data.runs.some((r) => r.output_model_id === m.id && r.id === k.run_id));
+  const body = { model: m.hf_repo || m.name, checkpoint: ckpt ? ckpt.path : null, name: slug, api: "openai-compatible" };
+  return html`<div class="palette-overlay" onMouseDown=${(e) => e.target === e.currentTarget && onClose()}>
+    <div class="palette" style="width:760px;max-height:80vh;padding:22px 24px;overflow:auto">
+      <h2 style="font-size:20px">Deploy a model</h2>
+      <p class="sec" style="margin:6px 0 16px">Serve a model or one of its training checkpoints as an OpenAI-compatible endpoint.</p>
+      <div class="grid cols-2">
+        <label><div class="small" style="font-weight:550;margin-bottom:4px">Model</div>
+          <select class="input" style="width:100%" value=${modelId} onChange=${(e) => { setModelId(e.target.value); setCkpt(null); }}>
+            ${candidates.map((c) => html`<option value=${c.id}>${c.name}</option>`)}</select></label>
+        <label><div class="small" style="font-weight:550;margin-bottom:4px">Deployment name</div>
+          <input class="input" style="width:100%" value=${name} placeholder=${slug} onInput=${(e) => setName(e.target.value)} />
+          <div class="small muted" style="margin-top:4px">Becomes <span class="mono">${slug || "…"}</span> in the endpoint URL.</div></label>
+      </div>
+      <div style="margin-top:16px"><div class="small" style="font-weight:550">Source</div>
+        <div class="small muted" style="margin:2px 0 8px">The model as released, or a saved checkpoint of the run that made it.</div>
+        <label class="row" style="padding:8px 10px;border:1px solid var(--line);border-radius:var(--r-lg);cursor:pointer"><input type="radio" checked=${!ckpt} onChange=${() => setCkpt(null)} />
+          <div><b>${m.name}</b><div class="small muted mono">${m.hf_repo || "stored weights"}</div></div></label>
+        ${ckpts.length ? html`<div class="table-wrap" style="margin-top:8px;max-height:220px"><table class="t dense"><thead><tr><th></th><th>Checkpoint</th><th>Run</th><th class="num">Saved</th></tr></thead>
+          <tbody>${ckpts.map((k) => html`<tr class="click" onClick=${() => setCkpt(k)}><td><input type="radio" checked=${ckpt && ckpt.id === k.id} /></td>
+            <td>Step ${k.step}<span class="sub mono">${k.path}</span></td><td>${k.run_name}</td><td class="num">${f.shortDate(k.created_at)}</td></tr>`)}</tbody></table></div>` : null}
+      </div>
+      ${sent ? html`<div class="panel" style="margin-top:16px"><div class="panel-body small">
+        ${getSource() === "workspace" ? html`<p style="margin-top:0"><b>Nothing was deployed:</b> serving isn't connected to the workspace yet. This is the request it will send:</p>`
+          : html`<p style="margin-top:0"><b>Example data:</b> nothing was deployed. This is the request the console sends:</p>`}
+        <pre class="code">POST /v1/deployments
+${JSON.stringify(body, null, 2)}</pre></div></div>` : null}
+      <div class="row" style="margin-top:18px;justify-content:flex-end"><button class="btn" onClick=${onClose}>Cancel</button>
+        <button class="btn primary" disabled=${!slug} onClick=${() => setSent(true)}>Deploy</button></div>
+    </div></div>`;
+}
+
+export function Models({ ctx }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/models`);
+  const [deploy, setDeploy] = useState(false);
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const ms = data.models;
+  const byId = new Map(ms.map((m) => [m.id, m]));
+  const children = new Map();
+  for (const m of ms) { if (!children.has(m.parent_id || "")) children.set(m.parent_id || "", []); children.get(m.parent_id || "").push(m); }
+  const roots = ms.filter((m) => !m.parent_id || !byId.has(m.parent_id));
+  const lines = [];
+  const walk = (m, depth) => { lines.push({ m, depth }); for (const c of children.get(m.id) || []) walk(c, depth + 1); };
+  roots.forEach((r) => walk(r, 0));
+  const producer = (m) => m.run ? m.run : data.runs.find((r) => r.output_model_id === m.id);
+  return html`
+    <div class="page-head"><div class="grow"><h1>Models</h1>
+      <p class="lede">Every model in the project and how it was made: each checkpoint points at the run that produced it and the model that run started from.</p></div>
+      <button class="btn primary" onClick=${() => setDeploy(true)}>Deploy a model</button></div>
+    ${deploy ? html`<${DeployDialog} data=${data} onClose=${() => setDeploy(false)} />` : null}
+    <div class="table-wrap"><table class="t">
+      <thead><tr><th>Model</th><th>Kind</th><th>Made by</th><th class="num">Parameters</th><th>Held-out scores</th><th>Status</th></tr></thead>
+      <tbody>${lines.map(({ m, depth }) => {
+        const run = producer(m);
+        const evals = (m.evals || []).slice(0, 3);
+        return html`<tr>
+          <td style=${`padding-left:${12 + depth * 22}px`}>${depth ? html`<span class="muted">└ </span>` : null}<b>${m.name}</b>
+            <span class="sub">${m.hf_repo ? html`<a href=${`https://huggingface.co/${m.hf_repo}`} target="_blank" rel="noopener">${m.hf_repo}</a>` : m.stage || ""}</span></td>
+          <td>${KIND[m.kind] || m.kind}</td>
+          <td>${run ? html`<${ProjectLink} ctx=${ctx} to=${`/runs/${run.id}`}>${run.name}</${ProjectLink}><span class="sub">${[run.stage, run.algorithm].filter(Boolean).join(" · ")}</span>` : html`<span class="muted">${m.kind === "base" ? "pretrained" : "—"}</span>`}</td>
+          <td class="num">${m.params_total ? html`${f.params(m.params_total)}${m.params_active ? html`<span class="sub">${f.params(m.params_active)} active</span>` : null}` : "—"}</td>
+          <td>${evals.length ? evals.map((e) => html`<div class="small nowrap"><${ProjectLink} ctx=${ctx} to=${`/evals/${e.id}`}>${e.name}</${ProjectLink}> <b>${f.score(e.metric, e.score)}</b></div>`) : html`<span class="muted">—</span>`}
+            ${(m.evals || []).length > 3 ? html`<span class="sub">+${m.evals.length - 3} more</span>` : null}</td>
+          <td>${m.status || "—"}</td>
+        </tr>`;
+      })}</tbody></table></div>
+    ${data.deployments.length ? html`<div class="section"><div class="section-head"><h2>Deployments</h2></div>
+      <${Table} rows=${data.deployments} rowKey=${(d) => d.id} columns=${[
+        { key: "name", label: "Endpoint" }, { key: "status", label: "Status" }, { key: "gpu", label: "Hardware", render: (d) => `${d.replicas} × ${d.gpu}` },
+        { key: "requests_24h", label: "Requests (24 h)", num: true, render: (d) => f.int(d.requests_24h) }, { key: "p50_ms", label: "p50 latency", num: true, render: (d) => `${f.int(d.p50_ms)} ms` }]} /></div>` : null}
+    <div class="section"><div class="section-head"><h2>Checkpoints</h2><span class="muted small">${data.checkpoints.length}</span></div>
+      <${Table} dense=${true} maxHeight="420px" rows=${data.checkpoints} rowKey=${(k) => k.id} onRow=${(k) => navigate(`${ctx.base}/runs/${k.run_id}`)} columns=${[
+        { key: "run_name", label: "Run" }, { key: "step", label: "Step", num: true }, { key: "path", label: "Path", render: (k) => html`<span class="mono small">${k.path}</span>` },
+        { key: "created_at", label: "Saved", num: true, render: (k) => f.shortDate(k.created_at) }]} /></div>`;
+}
diff --git a/viewer/static/pages/newproject.js b/viewer/static/pages/newproject.js
new file mode 100644
index 0000000000000000000000000000000000000000..06731a6d916ebc04794a75423c74e96c9a988522
--- /dev/null
+++ b/viewer/static/pages/newproject.js
@@ -0,0 +1,70 @@
+import { html, useState, apiPost, api, invalidate, navigate, shq, slugify } from "../lib.js";
+import { Field, Dialog, Command, useSubmit, SubmitProblem, useHfModel, hfLine } from "../ui/forms.js";
+
+const ORG_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+/** Create a project in the workspace (POST /projects) and open it. */
+export function NewProjectDialog({ meta, onClose }) {
+  const mine = (meta.orgs || []).filter((o) => o.source === "workspace");
+  const [org, setOrg] = useState(mine.length ? mine[0].slug : "");
+  const [name, setName] = useState("");
+  const [summary, setSummary] = useState("");
+  const [base, setBase] = useState("");
+  const hf = useHfModel(base);
+  const [touched, setTouched] = useState(false);
+  const slug = slugify(name);
+  const orgError = org && !ORG_RE.test(org) ? "Use lowercase letters, digits and dashes, starting with a letter or digit." : null;
+  const taken = (meta.orgs || []).flatMap((o) => o.projects.filter((p) => o.slug === org && p.slug === slug).map((p) => ({ ...p, source: o.source })))[0];
+  const readOnly = taken && taken.source !== "workspace";
+  const baseBad = base.trim() && !/^[\w.-]+\/[\w.-]+$/.test(base.trim()) ? "A Hugging Face id: org/name." : null;
+  const ready = org && !orgError && slug && !readOnly && !baseBad;
+  const cli = `posttrain init --org ${shq(org || "<org>")} --name ${shq(name || "<name>")}${base.trim() ? ` --base ${shq(base.trim())}` : ""}${summary.trim() ? ` --summary ${shq(summary.trim())}` : ""}`;
+  const [submit, state] = useSubmit(async () => {
+    const res = await apiPost("/projects", { org, slug, name: name.trim(), summary: summary.trim() });
+    if (base.trim()) {   // the project's base model: later stages and the launch form start from it
+      await apiPost(`/p/${org}/${slug}/models`, { name: base.trim(), kind: "base", hf_repo: base.trim(), status: "available",
+        notes: hf && hf.state === "found" ? `revision ${hf.sha}${hf.license ? `, ${hf.license}` : ""}` : "" });
+    }
+    invalidate();
+    await api("/meta", { source: "" });   // the shell must know the project's source before the page loads
+    onClose(true);
+    navigate(res.url);
+  });
+  const go = (e) => {
+    e.preventDefault();
+    setTouched(true);
+    if (ready) submit();
+  };
+  return html`<${Dialog} title="Create a project" onClose=${() => onClose(false)}
+      purpose="One model program, from a base model to a deployed model.">
+    <form class="form" onSubmit=${go}>
+      <${Field} label="Organization" error=${orgError || (touched && !org ? "Required." : null)}
+          help="Lowercase letters, digits and dashes. Projects in one organization share compute targets and runners.">
+        <input class="input" list="pt-orgs" value=${org} placeholder="acme" autocomplete="off" spellcheck="false"
+          onInput=${(e) => setOrg(e.target.value.trim().toLowerCase())} />
+        <datalist id="pt-orgs">${mine.map((o) => html`<option value=${o.slug}>${o.name}</option>`)}</datalist>
+      <//>
+      <${Field} label="Name" error=${touched && !slug ? "Required." : readOnly ? `An example project already uses ${org}/${slug}; pick another name.` : null}
+          help=${slug ? html`<span class="mono">${org || "<org>"}/${slug}</span>: used in URLs and CLI commands.` : "Its slug is used in URLs and CLI commands."}>
+        <input class="input" value=${name} placeholder="Qwen3 math reasoning" onInput=${(e) => setName(e.target.value)} />
+      <//>
+      <${Field} label="Base model" optional=${true} error=${baseBad} help=${hfLine(hf) || "A Hugging Face id. Stages start from it unless you choose another model."}>
+        <input class="input mono" value=${base} placeholder="Qwen/Qwen3-0.6B" spellcheck="false" autocomplete="off" onInput=${(e) => setBase(e.target.value)} />
+      <//>
+      <${Field} label="Summary" optional=${true} help="One line on what the model should learn to do.">
+        <input class="input" value=${summary} placeholder="GRPO on verifiable math, from an SFT warm start" onInput=${(e) => setSummary(e.target.value)} />
+      <//>
+      <div class="field wide"><span class="field-label">Same from a terminal</span>
+        <${Command} cmd=${cli} />
+        <span class="field-help">Run it in your repository: it also writes <span class="mono">posttrain.toml</span> there, so later commands know the project.</span></div>
+      <p class="consequence">${taken && !readOnly
+        ? html`<b>${org}/${slug}</b> already exists in your workspace; this opens it.`
+        : html`Creates an empty project in your workspace${slug && org ? html` at <b>${org}/${slug}</b>` : ""}. Nothing runs until you add data and launch a run.`}</p>
+      <${SubmitProblem} state=${state} onRetry=${submit.retry} />
+      <div class="form-actions">
+        <button type="button" class="btn" onClick=${() => onClose(false)}>Cancel</button>
+        <button type="submit" class="btn primary" disabled=${state.busy || (touched && !ready)}>${state.busy ? "Creating…" : taken && !readOnly ? "Open project" : "Create project"}</button>
+      </div>
+    </form>
+  <//>`;
+}
diff --git a/viewer/static/pages/ops.js b/viewer/static/pages/ops.js
new file mode 100644
index 0000000000000000000000000000000000000000..fb80a96659c8ab5c810178c09e5dfe8d82991a5a
--- /dev/null
+++ b/viewer/static/pages/ops.js
@@ -0,0 +1,68 @@
+import { html, useApi, navigate } from "../lib.js";
+import { Loading, Err, Table, ProjectLink, Status, Empty, Level } from "../ui/common.js";
+import { StackedColumns, SERIES } from "../ui/chart.js";
+import * as f from "../ui/fmt.js";
+
+export function Jobs({ ctx }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/jobs`);
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  return html`
+    <div class="page-head"><div class="grow"><h1>Jobs</h1>
+      <p class="lede">Every workload behind the runs: trainers, rollout workers, evaluations, data processing and serving. A restarted run shows each attempt.</p></div></div>
+    <${Table} rows=${data} rowKey=${(j) => j.id} initialSort=${{ key: "started_at", dir: -1 }} columns=${[
+      { key: "name", label: "Job", render: (j) => html`${j.name}<span class="sub">${j.kind}</span>` },
+      { key: "status", label: "Status", render: (j) => html`<${Status} status=${j.status} />${j.exit && j.exit !== j.status ? html`<span class="sub">${j.exit}</span>` : null}` },
+      { key: "run_name", label: "Run", render: (j) => j.run_id ? html`<${ProjectLink} ctx=${ctx} to=${`/runs/${j.run_id}`}>${j.run_name}</${ProjectLink}>` : "—" },
+      { key: "cluster", label: "Cluster", render: (j) => j.cluster || "—" },
+      { key: "gpus", label: "GPUs", num: true, render: (j) => j.gpus ? `${j.gpus} × ${j.gpu}` : "—" },
+      { key: "started_at", label: "Started", num: true, render: (j) => f.shortDate(j.started_at) },
+      { key: "dur", label: "Duration", num: true, sortValue: (j) => (j.ended_at || f.now()) - j.started_at, render: (j) => f.duration((j.ended_at || f.now()) - j.started_at) },
+      { key: "cost_usd", label: "Cost", num: true, render: (j) => f.money(j.cost_usd) },
+    ]} />`;
+}
+
+export function Usage({ ctx }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/usage`);
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const cats = [...new Set(data.days.map((d) => d.category))];
+  const days = [...new Set(data.days.map((d) => d.day))].map((day) => ({ day, parts: Object.fromEntries(data.days.filter((d) => d.day === day).map((d) => [d.category, d.cost])) }));
+  const total = data.days.reduce((s, d) => s + (d.cost || 0), 0);
+  const byCat = cats.map((c) => [c, data.days.filter((d) => d.category === c).reduce((s, d) => s + d.cost, 0)]);
+  return html`
+    <div class="page-head"><div class="grow"><h1>Usage</h1>
+      <p class="lede">What the project has spent, by day and by kind of work, and which runs spent it.</p>
+      <div class="facts" style="margin-top:10px"><span class="f"><span class="k">total</span><b>${f.money(total)}</b></span>
+        ${byCat.map(([c, v]) => html`<span class="f"><span class="k">${c}</span><b>${f.money(v)}</b> <span class="muted">(${f.pct(v / (total || 1), 0)})</span></span>`)}</div></div></div>
+    ${days.length ? html`<div class="chart-card"><div class="cc-head"><span class="cc-title">Spend by day</span><span class="cc-unit">USD</span></div>
+      <${StackedColumns} days=${days} cats=${cats.map((c, i) => ({ key: c, label: c, color: SERIES[i % 8] }))} /></div>` : html`<${Empty}>No spend recorded.</${Empty}>`}
+    <div class="section"><div class="section-head"><h2>By run</h2></div>
+      <${Table} rows=${data.runs.filter((r) => r.cost_usd)} rowKey=${(r) => r.id} onRow=${(r) => navigate(`${ctx.base}/runs/${r.id}`)} columns=${[
+        { key: "name", label: "Run" }, { key: "kind", label: "Kind" }, { key: "status", label: "Status", render: (r) => html`<${Status} status=${r.status} />` },
+        { key: "gpus", label: "Compute", render: (r) => r.gpus ? `${r.gpus} × ${r.gpu}` : "—" },
+        { key: "dur", label: "Duration", num: true, sortValue: (r) => (r.ended_at || f.now()) - r.started_at, render: (r) => f.duration((r.ended_at || f.now()) - r.started_at) },
+        { key: "cost_usd", label: "Cost", num: true, render: (r) => html`<b>${f.money(r.cost_usd)}</b>` },
+        { key: "share", label: "Share", num: true, sortValue: (r) => r.cost_usd, render: (r) => f.pct(r.cost_usd / (total || 1), 1) }]} /></div>
+    ${data.clusters.length ? html`<div class="section"><div class="section-head"><h2>Clusters</h2></div>
+      <${Table} rows=${data.clusters} rowKey=${(c) => c.id} columns=${[{ key: "name", label: "Cluster" }, { key: "provider", label: "Provider" },
+        { key: "gpu", label: "GPUs", render: (c) => c.gpus ? `${f.int(c.gpus)} × ${c.gpu}` : "—" }, { key: "region", label: "Region", render: (c) => c.region || "—" },
+        { key: "price_hour", label: "Price per GPU-hour", num: true, render: (c) => c.price_hour ? f.money(c.price_hour) : "—" }]} /></div>` : null}`;
+}
+
+export function Reports({ ctx }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/reports`);
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const V = { upheld: ["ok", "Upheld"], rejected: ["bad", "Rejected"], open: ["warn", "Open"] };
+  return html`
+    <div class="page-head"><div class="grow"><h1>Reports</h1>
+      <p class="lede">Written findings about runs, as claims with a verdict and the evidence behind it.</p></div></div>
+    ${data.length === 0 ? html`<${Empty}>No reports yet.</${Empty}>` : data.map((r) => html`<div class="panel" style="margin-bottom:14px">
+      <div class="panel-head"><h3>${r.title}</h3><span class="grow"></span><span class="muted small">${r.author} · ${f.date(r.created_at, false)}</span></div>
+      <div class="panel-body">${r.summary ? html`<p style="margin-top:0">${r.summary}</p>` : null}
+        ${(r.claims || []).map((c) => html`<div class="finding" style="grid-template-columns:110px 1fr;padding:8px 0"><${Level} level=${(V[c.verdict] || V.open)[0]} label=${(V[c.verdict] || V.open)[1]} />
+          <div><div>${c.claim}</div>${c.evidence ? html`<div class="small sec">${c.evidence}</div>` : null}</div></div>`)}
+        ${(r.run_ids || []).length ? html`<div class="small muted" style="margin-top:8px">Runs: ${(r.run_ids || []).map((id, i) => html`${i ? ", " : ""}<${ProjectLink} ctx=${ctx} to=${`/runs/${id}`}>${id}</${ProjectLink}>`)}</div>` : null}
+      </div></div>`)}`;
+}
diff --git a/viewer/static/pages/overview.js b/viewer/static/pages/overview.js
new file mode 100644
index 0000000000000000000000000000000000000000..f3b36866cfd0e8ac85a3d3631f504a79fe2cb951
--- /dev/null
+++ b/viewer/static/pages/overview.js
@@ -0,0 +1,177 @@
+import { html, useApi, Link, useState, setQuery } from "../lib.js";
+import { Status, Level, Loading, Err, Progress, Delta, Table, ProjectLink } from "../ui/common.js";
+import { Spark } from "../ui/chart.js";
+import { Stages, FirstRun, AddInputDialog } from "./stages.js";
+import * as f from "../ui/fmt.js";
+
+export function metricText(v) {
+  if (v === null || v === undefined) return "—";
+  return Math.abs(v) <= 1.5 ? f.num(v, 3) : f.num(v, 2);
+}
+
+const EVENT_LABEL = { restart: "Restart", notice: "Notice", start: "Started", end: "Finished", alert: "Alert", data: "Data change", config: "Config change", incident: "Incident", eval: "Eval" };
+const LIVE = new Set(["queued", "starting", "running", "stopping", "stalled"]);
+
+export function RunsTable({ ctx, runs, compactCols, selected, onSelect }) {
+  const cols = [
+    ...(onSelect ? [{ key: "sel", label: "", sortable: false, width: "28px", render: (r) => html`<input type="checkbox" aria-label=${`Select ${r.name}`}
+        checked=${selected.includes(r.id)} onClick=${(e) => e.stopPropagation()} onChange=${() => onSelect(r.id)} />` }] : []),
+    { key: "status", label: "Status", render: (r) => html`<${Status} status=${r.status} reason=${r.status_reason} />`, sortValue: (r) => r.status },
+    { key: "name", label: "Run", render: (r) => {
+      const what = [...new Set([r.stage, r.algorithm, r.framework].filter(Boolean))].join(" · ");
+      return html`<${ProjectLink} ctx=${ctx} to=${`/runs/${r.id}`} class="cell-name" title=${r.name}>${r.name}</${ProjectLink}>
+        <span class="sub cell-clip" title=${what}>${what}</span>`; } },
+    { key: "progress", label: "Steps", render: (r) => html`<${Progress} done=${r.steps_done} planned=${r.steps_planned} />`, sortValue: (r) => r.steps_done },
+    { key: "primary", label: "Training metric", sortable: false, render: (r) => r.primary && r.primary.points.length ? html`<div class="row">
+        <${Spark} points=${r.primary.points} color="var(--train)" width=${64} height=${22} />
+        <span class="small nowrap"><span class="muted">${metricText(r.primary.first)} →</span> <b>${metricText(r.primary.last)}</b></span></div>
+        <span class="sub mono cell-clip tag-clip" title=${r.primary.tag}>${r.primary.tag}</span>` : html`<span class="muted">—</span>` },
+    { key: "evals", label: "Held-out", sortable: false, render: (r) => r.evals && r.evals.length ? html`${r.evals.slice(0, 2).map((e) => html`
+        <div class="small held"><span class="held-name" title=${e.name}>${e.name}</span>
+          <span class="nowrap" title=${`${e.name}: ${f.score(e.metric, e.first)} at step ${e.first_step} → ${f.score(e.metric, e.last)} at step ${e.last_step}`}><b>${f.score(e.metric, e.last)}</b>${" "}${f.isRaw(e.metric) ? null
+            : e.first === e.last ? html`<span class="muted">unchanged</span>` : html`<${Delta} a=${e.first} b=${e.last} />`}</span></div>`)}
+        ${r.evals.length > 2 ? html`<span class="sub" title=${r.evals.slice(2).map((e) => e.name).join(", ")}>+${r.evals.length - 2} more</span>` : null}` : html`<span class="muted">—</span>` },
+    { key: "alerts", label: "Checks", num: true, render: (r) => !(r.findings || []).length ? html`<span class="muted">—</span>` : r.alerts ? html`<${Level} level="warn" label=${`${r.alerts}`} />` : html`<${Level} level="ok" label="OK" />` },
+    { key: "updated_at", label: "Updated", num: true, render: (r) => html`<span class="nowrap">${f.ago(r.updated_at || r.started_at)}</span>`, sortValue: (r) => r.updated_at || r.started_at },
+    { key: "cost_usd", label: "Cost", num: true, render: (r) => f.money(r.cost_usd) },
+  ];
+  return html`<${Table} columns=${compactCols ? cols.filter((c) => c.key !== "evals") : cols} rows=${runs} rowKey=${(r) => r.id} />`;
+}
+
+function Head({ ctx, data }) {
+  const [about, setAbout] = useState(false);
+  const p = data.project;
+  const c = data.counts;
+  const inv = [["runs", "run", c.runs], ["evals", "benchmark", c.benchmarks], ["environments", "environment", c.environments],
+    ["environments", "task", c.tasks], ["datasets", "dataset", c.datasets], ["models", "model", c.models]].filter((x) => !ctx.writable || x[2]);
+  const empty = ctx.writable && !inv.length;
+  return html`<div class="page-head"><div class="grow">
+      <div class="crumb-line">${p.org_name}</div>
+      <h1>${p.name}</h1>
+      ${p.summary ? html`<p class="lede">${p.summary}</p>` : null}
+      ${empty ? null : html`<div class="facts" style="margin-top:10px">${inv.map(([to, label, n]) => html`<span class="f"><${ProjectLink} ctx=${ctx} to=${`/${to}`}>${f.plural(n, label)}</${ProjectLink}></span>`)}
+        ${data.spend ? html`<span class="f"><${ProjectLink} ctx=${ctx} to="/usage">${f.money(data.spend)} spent</${ProjectLink}></span>` : null}
+        ${ctx.writable ? null : html`<span class="f"><a href="#" onClick=${(e) => { e.preventDefault(); setAbout(!about); }}>About this data</a></span>`}</div>`}
+      ${about ? html`<div class="panel" style="margin-top:10px"><div class="panel-body small">
+        <p style="margin:0 0 8px">${p.data_note}</p>
+        <div>${(p.sources || []).map((s) => html`<div><a href=${s.url} target="_blank" rel="noopener">${s.title}</a></div>`)}</div></div></div>` : null}
+    </div></div>`;
+}
+
+function Lineage({ ctx, data, title = "Stages", note = "how each model was made, from its base to the latest checkpoint" }) {
+  return html`<div class="section">
+      <div class="section-head"><h2>${title}</h2><span class="muted small">${note}</span>
+        <span class="grow"></span><${ProjectLink} ctx=${ctx} to="/models">Models</${ProjectLink}></div>
+      <div class="panel"><div class="list-rows">${data.lineage.map((chain) => html`<div class="chain">
+        ${chain.map((n, i) => html`${i ? html`<span class="chain-arrow">→</span>` : null}<span class="chain-node">
+          <span class="chain-stage">${n.stage || (n.kind === "base" ? "Base" : n.kind)}</span>
+          ${n.run ? html`<${ProjectLink} ctx=${ctx} to=${`/runs/${n.run.id}`} title=${n.run.name}>${n.name}</${ProjectLink}>` : html`<span>${n.name}</span>`}
+          ${n.run && n.run.status !== "completed" ? html`<${Status} status=${n.run.status} />` : null}
+        </span>`)}
+      </div>`)}</div></div></div>`;
+}
+
+function RunsSection({ ctx, data }) {
+  const running = data.runs.filter((r) => r.status === "running");
+  const queued = data.runs.filter((r) => r.status === "queued");
+  const state = [running.length ? `${running.length} running` : null, queued.length ? `${queued.length} queued` : null].filter(Boolean).join(", ");
+  return html`<div class="section">
+      <div class="section-head"><h2>Runs</h2><span class="muted small">${state || "none running"}</span>
+        <span class="grow"></span><${ProjectLink} ctx=${ctx} to="/runs">All runs</${ProjectLink}></div>
+      <${RunsTable} ctx=${ctx} runs=${data.runs.slice(0, 8)} />
+    </div>`;
+}
+
+function AttentionActivity({ ctx, data }) {
+  return html`<div class="section grid cols-2">
+      <div class="panel">
+        <div class="panel-head"><h3>Needs attention</h3><span class="muted small">${data.attention.length}</span></div>
+        <div class="list-rows">
+          ${data.attention.length === 0 ? html`<div class="empty">Every check passes.</div>` : null}
+          ${data.attention.map((a) => html`<div class="finding">
+            <${Level} level=${a.level} label="" />
+            <div><div class="what"><span class="area">${a.area}</span>${a.message}</div>
+              <div class="src">${a.run_id ? html`<${ProjectLink} ctx=${ctx} to=${`/runs/${a.run_id}`}>${a.run_name}</${ProjectLink}>` :
+                a.env_id ? html`<${ProjectLink} ctx=${ctx} to=${`/environments/${a.env_id}?tab=tasks`}>${a.env_name}</${ProjectLink}>` : null}</div></div>
+          </div>`)}
+        </div>
+      </div>
+      <div class="panel">
+        <div class="panel-head"><h3>Activity</h3></div>
+        <div class="list-rows">
+          ${data.events.map((e) => html`<div class="event">
+            <span class="when">${f.shortDate(e.t)}</span>
+            <div><b>${EVENT_LABEL[e.kind] || e.kind}</b> <span class="muted">·</span> <${ProjectLink} ctx=${ctx} to=${`/runs/${e.run_id}?tab=events`}>${e.run_name}</${ProjectLink}>
+              ${e.body ? html`<div class="sec small">${e.body}</div>` : e.title && !EVENT_LABEL[e.kind] ? html`<div class="sec small">${e.title}</div>` : null}</div>
+          </div>`)}
+        </div>
+      </div>
+    </div>`;
+}
+
+function HeldOut({ ctx, data }) {
+  const cols = data.evals.columns.slice(0, 6);
+  const filled = (b) => cols.filter((c) => c.cells[b.id]).length;
+  const benchRows = data.evals.benchmarks.filter((b) => filled(b) >= 1).sort((a, b) => filled(b) - filled(a)).slice(0, 12);
+  return html`<div class="section">
+      <div class="section-head"><h2>Held-out results</h2><span class="muted small">${benchRows.length < data.evals.benchmarks.length ? `${benchRows.length} of ${data.evals.benchmarks.length} benchmarks, the most widely measured; ` : ""}latest checkpoint of each run; change since its first eval</span>
+        <span class="grow"></span><${ProjectLink} ctx=${ctx} to="/evals">All evals</${ProjectLink}></div>
+      <div class="table-wrap"><table class="t">
+        <thead><tr><th>Benchmark</th><th class="num">Tasks × attempts</th>${cols.map((col) => html`<th class="num col-name" title=${col.label}><span>${col.label}</span></th>`)}</tr></thead>
+        <tbody>${benchRows.map((b) => html`<tr>
+          <td class="bench-cell"><${ProjectLink} ctx=${ctx} to=${`/evals?benchmark=${b.id}`}>${b.name}</${ProjectLink}><span class="sub">${[b.category, b.harness].filter(Boolean).join(" · ")}</span></td>
+          <td class="num">${f.int(b.n_tasks)} × ${b.k}</td>
+          ${cols.map((col) => {
+            const cell = col.cells[b.id];
+            if (!cell) return html`<td class="num muted">—</td>`;
+            return html`<td class="num"><${ProjectLink} ctx=${ctx} to=${`/evals/${cell.eval_id}`}><b>${f.score(b.metric, cell.score)}</b></${ProjectLink}>
+              <span class="muted small"> ${f.scoreErr(b.metric, cell.stderr)}</span>
+              ${cell.first_step !== cell.step ? html`<span class="sub"><${Delta} a=${cell.first} b=${cell.score} /> since step ${cell.first_step}</span>` : cell.step !== null && cell.step !== undefined ? html`<span class="sub">step ${cell.step}</span>` : null}</td>`;
+          })}
+        </tr>`)}</tbody></table></div>
+    </div>`;
+}
+
+/** A project in your workspace: the stage walkthrough first (or the first-run steps), then whatever exists. */
+function WorkspaceOverview({ ctx }) {
+  const adding = ctx.query.get("add");
+  const st = useApi(`/p/${ctx.org}/${ctx.project}/stages`, undefined, [], { every: (d) => (adding || d.active ? 4000 : 0) });
+  const ov = useApi(`/p/${ctx.org}/${ctx.project}/overview`, undefined, [], { every: (d) => (d.runs.some((r) => LIVE.has(r.status)) ? 4000 : 0) });
+  const error = st.error || ov.error;
+  if (error && !(st.data && ov.data)) return html`<${Err} error=${error} />`;
+  if (!st.data || !ov.data) return html`<${Loading} />`;
+  const data = ov.data, stages = st.data;
+  const stageOf = (k) => stages.stages.find((s) => s.key === k);
+  const dialog = adding === "dataset" || adding === "environment" ? html`<${AddInputDialog} ctx=${ctx} kind=${adding}
+      count=${adding === "dataset" ? stages.counts.datasets : stages.counts.environments}
+      latest=${(stageOf(adding === "dataset" ? "data" : "environments").objects || [])[0]} onClose=${() => setQuery({ add: null })} />` : null;
+  if (stages.empty) {
+    return html`<${Head} ctx=${ctx} data=${data} /><${Stages} ctx=${ctx} data=${stages} /><${FirstRun} ctx=${ctx} data=${stages} />${dialog}`;
+  }
+  const hasActivity = data.attention.length || data.events.length;
+  return html`
+    <${Head} ctx=${ctx} data=${data} />
+    <${Stages} ctx=${ctx} data=${stages} />
+    ${data.lineage && data.lineage.length ? html`<${Lineage} ctx=${ctx} data=${data} title="Lineage" />` : null}
+    ${data.runs.length ? html`<${RunsSection} ctx=${ctx} data=${data} />` : null}
+    ${hasActivity ? html`<${AttentionActivity} ctx=${ctx} data=${data} />` : null}
+    ${data.evals.benchmarks.length ? html`<${HeldOut} ctx=${ctx} data=${data} />` : null}
+    ${dialog}`;
+}
+
+export function Overview({ ctx }) {
+  return ctx.writable ? html`<${WorkspaceOverview} ctx=${ctx} />` : html`<${ReadOnlyOverview} ctx=${ctx} />`;
+}
+
+function ReadOnlyOverview({ ctx }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/overview`);
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  return html`
+    <${Head} ctx=${ctx} data=${data} />
+    ${data.lineage && data.lineage.length ? html`<${Lineage} ctx=${ctx} data=${data} />` : null}
+    <${RunsSection} ctx=${ctx} data=${data} />
+    <${AttentionActivity} ctx=${ctx} data=${data} />
+    ${data.evals.benchmarks.length ? html`<${HeldOut} ctx=${ctx} data=${data} />` : null}
+  `;
+}
diff --git a/viewer/static/pages/runs.js b/viewer/static/pages/runs.js
new file mode 100644
index 0000000000000000000000000000000000000000..bddb5b64ae939fdec2a1925d0acd1096f35529b7
--- /dev/null
+++ b/viewer/static/pages/runs.js
@@ -0,0 +1,619 @@
+import { html, useApi, api, useState, useEffect, useMemo, useRef, setQuery, navigate, Link, setRolloutOrder } from "../lib.js";
+import { Status, Level, Loading, Err, Progress, Delta, Table, ProjectLink, Tabs, Facts, Provenance, Attempts, Outcome, Empty, Icon, hasVerdict } from "../ui/common.js";
+import { LineChart, Spark, SERIES, StackedArea } from "../ui/chart.js";
+import { RunsTable, metricText } from "./overview.js";
+import { StatusStrip, RunLogs, liveStatus, ACTIVE_JOB, LIVE_RUN } from "./live.js";
+import { Command } from "../ui/forms.js";
+import * as f from "../ui/fmt.js";
+
+const LIVE = LIVE_RUN;
+
+// ------------------------------------------------------------------ list
+export function Runs({ ctx }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/runs`, undefined, [], { every: (d) => (ctx.writable && d.some((r) => LIVE.has(r.status)) ? 4000 : 0) });
+  const q = ctx.query;
+  const [text, setText] = useState(q.get("q") || "");
+  const [sel, setSel] = useState([]);
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const kind = q.get("kind") || "";
+  const status = q.get("status") || "";
+  const group = q.get("group") || "";
+  const kinds = [...new Set(data.map((r) => r.kind))];
+  const statuses = [...new Set(data.map((r) => r.status))];
+  const groups = [...new Set(data.map((r) => r.group_name).filter(Boolean))];
+  const rows = data.filter((r) => (!kind || r.kind === kind) && (!status || r.status === status) && (!group || r.group_name === group) &&
+    (!text || `${r.name} ${r.stage} ${r.algorithm} ${r.base_model} ${r.output_model}`.toLowerCase().includes(text.toLowerCase())));
+  const KIND = { sft: "SFT", dpo: "Preference", rl: "RL", distill: "Distillation", rm: "Reward model" };
+  const sweeps = groups.map((name) => {
+    const rs = data.filter((r) => r.group_name === name);
+    const lasts = rs.map((r) => r.primary && r.primary.last).filter((v) => v !== null && v !== undefined);
+    const status = {};
+    rs.forEach((r) => { status[r.status] = (status[r.status] || 0) + 1; });
+    const ranked = rs.filter((r) => r.primary && r.primary.last !== null).sort((a, b) => b.primary.last - a.primary.last);
+    return { name, n: rs.length, status, min: lasts.length ? Math.min(...lasts) : null, max: lasts.length ? Math.max(...lasts) : null,
+      tag: rs[0] && rs[0].primary ? rs[0].primary.tag : "", top: (ranked.length ? ranked : rs).slice(0, 8).map((r) => r.id) };
+  }).filter((g) => g.n >= 3);
+  const head = html`<div class="page-head"><div class="grow"><h1>Runs</h1>
+      <p class="lede">Every training run in this project: supervised, preference and RL stages, sweeps and one-off experiments.</p></div>
+      ${ctx.writable ? html`<button class="btn primary" onClick=${() => navigate(`${ctx.base}/runs/new`)}><${Icon} name="plus" size=${14} />New run</button>` : null}</div>`;
+  if (ctx.writable && !data.length) {
+    return html`${head}<div class="panel"><div class="panel-body">
+      <div class="row wrap" style="gap:14px;align-items:flex-start"><div class="grow" style="min-width:260px"><b>No runs yet.</b>
+        <div class="sec small" style="margin-top:3px">Launch one with New run, or from a terminal. Runs you report with <span class="mono">posttrain wrap</span> appear here too.</div></div>
+        <button class="btn primary" onClick=${() => navigate(`${ctx.base}/runs/new`)}><${Icon} name="plus" size=${14} />New run</button></div>
+      <div style="margin-top:12px;max-width:640px"><${Command} cmd="posttrain train sft --base <model> --data <dataset> --on local" /></div>
+    </div></div>`;
+  }
+  return html`
+    ${head}
+    <div class="filters">
+      <input class="input search" placeholder="Filter by name, stage or model" value=${text} onInput=${(e) => { setText(e.target.value); setQuery({ q: e.target.value }); }} />
+      <div class="seg">${[["", "All"], ...kinds.map((k) => [k, KIND[k] || k])].map(([k, l]) => html`<button class=${kind === k ? "on" : ""} onClick=${() => setQuery({ kind: k })}>${l}</button>`)}</div>
+      <select class="input" value=${status} onChange=${(e) => setQuery({ status: e.target.value })}>
+        <option value="">Any status</option>${statuses.map((s) => html`<option value=${s}>${s}</option>`)}</select>
+      ${groups.length > 1 ? html`<select class="input" value=${group} onChange=${(e) => setQuery({ group: e.target.value })}>
+        <option value="">Any group</option>${groups.map((s) => html`<option value=${s}>${s}</option>`)}</select>` : null}
+      <span class="muted small">${rows.length} of ${data.length}</span>
+      <span class="grow"></span>
+      ${sel.length ? html`<button class="btn small ghost" onClick=${() => setSel([])}>Clear</button>` : null}
+      <button class="btn primary small" disabled=${sel.length < 2} onClick=${() => navigate(`${ctx.base}/runs/compare?ids=${sel.join(",")}`)}>
+        ${sel.length < 2 ? "Select runs to compare" : `Compare ${sel.length} runs`}</button>
+    </div>
+    ${!group && sweeps.length ? html`<div class="section" style="margin-top:0;margin-bottom:18px"><div class="section-head"><h2>Sweeps and groups</h2>
+      <span class="muted small">runs that share a group; the spread of their final training metric says how much the varied setting mattered</span></div>
+      <${Table} dense=${true} rows=${sweeps} rowKey=${(g) => g.name} columns=${[
+        { key: "name", label: "Group", render: (g) => html`<a href=${`?group=${encodeURIComponent(g.name)}`} onClick=${(e) => { e.preventDefault(); setQuery({ group: g.name }); }}>${g.name}</a>` },
+        { key: "n", label: "Runs", num: true },
+        { key: "status", label: "Status", sortable: false, render: (g) => html`<span class="small">${Object.entries(g.status).map(([k, v]) => `${v} ${k}`).join(" · ")}</span>` },
+        { key: "range", label: "Final training metric (min – max)", num: true, sortValue: (g) => g.max - g.min, render: (g) => g.min === null ? "—" : html`${metricText(g.min)} – <b>${metricText(g.max)}</b> <span class="muted small">${g.tag || ""}</span>` },
+        { key: "cmp", label: "", sortable: false, render: (g) => html`<${ProjectLink} ctx=${ctx} to=${`/runs/compare?ids=${g.top.join(",")}`}>Compare ${g.top.length}</${ProjectLink}>` },
+      ]} /></div>` : null}
+    <${RunsTable} ctx=${ctx} runs=${rows} selected=${sel} onSelect=${(id) => setSel(sel.includes(id) ? sel.filter((x) => x !== id) : [...sel, id].slice(-8))} />`;
+}
+
+// ------------------------------------------------------------------ detail
+const TABS = [["overview", "Overview"], ["logs", "Logs"], ["rollouts", "Rollouts"], ["metrics", "Metrics"], ["evals", "Evals"], ["data", "Data"], ["events", "Events"], ["config", "Config"]];
+
+export function Run({ ctx, id }) {
+  // a workspace run that is queued or running refreshes itself every 3 s; the page keeps its frame
+  const jobState = useApi(ctx.writable ? `/runs/${id}/jobs` : null, { source: "" }, [],
+    { every: (d) => (LIVE.has(d.run.status) || d.jobs.some((j) => ACTIVE_JOB.has(j.status)) ? 3000 : 0) });
+  const jobs = jobState.data;
+  const jobActive = !!(jobs && jobs.jobs.some((j) => ACTIVE_JOB.has(j.status)));
+  const { data: run, error } = useApi(`/p/${ctx.org}/${ctx.project}/runs/${id}`, undefined, [],
+    { every: (r) => (ctx.writable && (LIVE.has(r.status) || jobActive) ? 3000 : 0) });
+  const tab = ctx.query.get("tab") || "overview";
+  if (error && !run) return html`<${Err} error=${error} />`;
+  if (!run) return html`<${Loading} />`;
+  const live = ctx.writable && (LIVE.has(run.status) || jobActive);
+  const status = ctx.writable ? liveStatus(run, jobs) : run.status;
+  const elapsed = (run.ended_at || (live ? f.now() : run.updated_at || f.now())) - run.started_at;
+  const evalBenchmarks = [...new Set(run.eval_points.map((e) => e.benchmark_id))];
+  const tabs = TABS.filter(([t]) => !(t === "rollouts" && !run.rollouts_stored) && !(t === "evals" && !run.eval_points.length) && !(t === "logs" && !ctx.writable))
+    .map(([t, l]) => ({ id: t, label: l, count: t === "rollouts" ? f.compact(run.rollouts_stored) : t === "events" ? run.events.length : t === "evals" ? evalBenchmarks.length
+      : t === "logs" && jobs ? f.int(jobs.logs.lines) : null }));
+  const job = jobs && jobs.jobs.length ? jobs.jobs[jobs.jobs.length - 1] : null;
+  const envInputs = run.inputs.filter((i) => i.kind === "environment");
+  const dsInputs = run.inputs.filter((i) => i.kind === "dataset");
+  return html`
+    <div class="page-head"><div class="grow">
+      <div class="crumb-line"><${ProjectLink} ctx=${ctx} to="/runs">Runs</${ProjectLink}>${run.group_name ? ` / ${run.group_name}` : ""}</div>
+      <div class="row wrap" style="gap:12px"><h1>${run.name}</h1><${Status} status=${status} reason=${run.status_reason} />
+        <button class="btn small ghost" title="Copy a link to this run" onClick=${(e) => { navigator.clipboard && navigator.clipboard.writeText(location.href); e.currentTarget.textContent = "Link copied"; }}><${Icon} name="copy" size=${13} />Copy link</button>
+        <span class="chip">${[...new Set([run.stage, run.algorithm, run.framework].filter(Boolean))].join(" · ")}</span>
+        ${ctx.writable ? null : html`<${Provenance} value=${run.provenance} source=${run.source} />`}</div>
+      ${run.description ? html`<p class="lede">${run.description}</p>` : null}
+      <div style="margin-top:10px"><${Facts} items=${[
+        ["steps", html`${f.int(run.steps_done)} / ${f.int(run.steps_planned)}`],
+        [run.status === "queued" ? "queued" : "started", f.date(run.started_at)],
+        [run.ended_at ? "took" : run.status === "queued" ? "waiting for" : "running for", elapsed < 10 && !run.ended_at ? "just now" : f.duration(elapsed)],
+        job ? ["compute", job.target] : null,
+        run.cost_usd ? ["cost", html`${f.money(run.cost_usd)}${run.cost_rate ? html` <span class="muted">(${f.money(run.cost_rate)}/h)</span>` : ""}`] : null,
+        run.gpus ? ["compute", `${run.gpus} × ${run.gpu}`] : null,
+        run.owner ? ["owner", run.owner] : null,
+      ]} /></div>
+      <div class="facts" style="margin-top:6px">
+        <span class="f"><span class="k">model</span> <b>${run.base_model || "—"}</b> <span class="muted">→</span> <b>${run.output_model || (run.status === "running" ? "in training" : "—")}</b></span>
+        ${envInputs.length ? html`<span class="f"><span class="k">trains on</span> <b><a href="?tab=data" onClick=${(e) => { e.preventDefault(); setQuery({ tab: "data" }, { replace: false }); }}>${envInputs.length} environment${envInputs.length > 1 ? "s" : ""}</a></b></span>` : null}
+        ${dsInputs.length ? html`<span class="f"><span class="k">trains on</span> <b>${dsInputs.map((d, i) => html`${i ? ", " : ""}<${ProjectLink} ctx=${ctx} to=${`/datasets/${d.ref_id}`}>${d.ref ? d.ref.name : d.ref_id}</${ProjectLink}>`)}</b></span>` : null}
+        ${run.code_ref ? html`<span class="f"><span class="k">code</span> <b class="mono">${run.code_ref}</b></span>` : null}
+        ${run.source && /^https?:\/\//.test(run.source) ? html`<span class="f"><span class="k">source</span> <b><a href=${run.source} target="_blank" rel="noopener">${run.source.replace(/^https?:\/\//, "").slice(0, 48)}</a></b></span>` : null}
+      </div>
+    </div></div>
+    ${ctx.writable ? html`<${StatusStrip} ctx=${ctx} run=${run} jobs=${jobs} />` : null}
+    <${Tabs} tabs=${tabs} current=${tab} />
+    ${tab === "overview" ? html`<${RunOverview} ctx=${ctx} run=${run} />` : null}
+    ${tab === "logs" && ctx.writable ? html`<${RunLogs} run=${run} live=${live} queued=${status === "queued"} />` : null}
+    ${tab === "rollouts" ? html`<${RunRollouts} ctx=${ctx} run=${run} />` : null}
+    ${tab === "metrics" ? html`<${MetricsExplorer} ctx=${ctx} run=${run} />` : null}
+    ${tab === "evals" ? html`<${RunEvals} ctx=${ctx} run=${run} />` : null}
+    ${tab === "data" ? html`<${RunData} ctx=${ctx} run=${run} />` : null}
+    ${tab === "events" ? html`<${RunEvents} ctx=${ctx} run=${run} />` : null}
+    ${tab === "config" ? html`<${RunConfig} run=${run} spec=${job && job.spec} />` : null}
+  `;
+}
+
+function eventMarks(run) {
+  const out = [];
+  for (const e of run.events) {
+    if (!["restart", "notice", "incident", "data", "config", "alert"].includes(e.kind)) continue;
+    let step = e.step;
+    if (step === null || step === undefined) {
+      const s = run.steps.find((x) => x.ended_at && x.ended_at >= e.t);
+      step = s ? s.step : (run.steps.length ? run.steps[run.steps.length - 1].step : null);
+    }
+    if (step !== null) out.push({ x: step, kind: e.kind, label: `${e.kind === "restart" ? "Restart" : e.title}${e.body ? ": " + e.body : ""}` });
+  }
+  return out;
+}
+
+function vitalByName(run, sig) { return run.vitals.find((v) => v.signal === sig); }
+
+export function RunOverview({ ctx, run }) {
+  const [smoothing, setSmoothing] = useState(0);
+  const events = eventMarks(run);
+  const primary = vitalByName(run, "pass_rate") || vitalByName(run, "reward") || vitalByName(run, "loss") || vitalByName(run, "reward_margin");
+  const secondary = primary && primary.signal === "pass_rate" ? vitalByName(run, "reward") : (primary && primary.signal === "loss" ? vitalByName(run, "val_loss") : null);
+  const byBench = new Map();
+  for (const e of run.eval_points) {
+    if (!byBench.has(e.benchmark_id)) byBench.set(e.benchmark_id, { name: e.benchmark, metric: e.metric, points: [] });
+    if (e.score !== null) byBench.get(e.benchmark_id).points.push(e);
+  }
+  const findings = run.findings || [];
+  const flag = (sig) => { const x = findings.find((q) => q.signal === sig); return x && x.level !== "ok" ? x.level : null; };
+  const vitalOrder = ["entropy", "grad_norm", "train_infer_kl", "kl_ref", "clip_frac", "response_len", "truncation_rate", "turns",
+    "all_fail_share", "all_pass_share", "mixed_share", "infra_error_rate", "timeout_rate", "staleness", "step_time", "throughput", "active_sandboxes", "lr"];
+  const vitals = vitalOrder.map((s) => vitalByName(run, s)).filter(Boolean);
+  const pick = (step) => setQuery({ tab: "rollouts", step }, { replace: false });
+  return html`
+    <div class="split">
+      <div class="stack">
+        ${primary ? html`<div class="chart-card">
+          <div class="cc-head"><span class="cc-title">${primary.label} by step</span><span class="cc-unit mono">${primary.tag}</span>
+            <span class="grow"></span>
+            <div class="seg">${[[0, "Raw"], [0.6, "Smooth 60%"], [0.9, "90%"]].map(([v, l]) => html`<button class=${smoothing === v ? "on" : ""} onClick=${() => setSmoothing(v)}>${l}</button>`)}</div></div>
+          <${LineChart} height=${240} smoothing=${smoothing} events=${events} onPick=${run.rollouts_stored ? pick : null}
+            yFormat=${(v) => f.by(primary.format, v)}
+            series=${[{ key: "p", label: `train ${primary.label.toLowerCase()}`, color: "var(--train)", points: primary.points, format: (v) => f.by(primary.format, v) },
+              ...(secondary ? [{ key: "s", label: `${secondary.label.toLowerCase()}${secondary.unit ? ` (${secondary.unit})` : ""}`, color: "var(--s7)", points: secondary.points, width: 1.5,
+                format: (v) => f.by(secondary.format, v), axis: secondary.format !== primary.format || secondary.unit !== primary.unit ? "right" : undefined }] : [])]} />
+          <div class="cc-desc">${primary.description}${run.rollouts_stored ? " Click a step to read its rollouts." : ""}${events.length ? " Red markers are restarts; gray markers are notices and data changes (hover for the text)." : ""}</div>
+        </div>` : html`<${Empty}>${run.status === "queued" ? "Metrics appear here once the run starts and logs its first step." : run.status === "running" ? "No training metric logged yet; this page updates as steps arrive." : "This run logged no training metric."}</${Empty}>`}
+        ${byBench.size ? html`<div class="grid ${byBench.size > 2 ? "cols-3" : "cols-2"}">${[...byBench.values()].map((b) => {
+          const pts = b.points;
+          const first = pts[0], last = pts[pts.length - 1];
+          return html`<div class="chart-card">
+            <div class="cc-head"><span class="cc-title">${b.name}</span><span class="cc-unit">${b.metric}, held out</span>
+              <span class="cc-value">${f.score(b.metric, last.score)}</span></div>
+            <${LineChart} height=${120} compact=${true} legend=${false} yFormat=${(v) => f.score(b.metric, v, 0)}
+              series=${[{ key: "e", label: b.name, color: "var(--eval)", dots: pts.length < 40, points: pts.map((p) => [p.step, p.score]),
+                band: pts.map((p) => [p.step, p.score - (p.stderr || 0), p.score + (p.stderr || 0)]) }]} />
+            <div class="cc-desc">${pts.length} eval${pts.length > 1 ? "s" : ""} · step ${first.step} → ${last.step}: ${f.isRaw(b.metric) ? `${f.score(b.metric, first.score)} → ${f.score(b.metric, last.score)}` : html`<${Delta} a=${first.score} b=${last.score} />`} · band is ±1 SE</div>
+          </div>`;
+        })}</div>` : null}
+      </div>
+      <div class="panel">
+        <div class="panel-head"><h3>Checks</h3><span class="muted small">from this run's own metrics</span></div>
+        <div class="list-rows">
+          ${findings.length === 0 ? html`<div class="empty">No checks apply to this kind of run.</div>` : null}
+          ${findings.map((x) => html`<div style="padding:9px 14px"><${Level} level=${x.level} label=${x.area} /><div class="small sec" style="margin-top:3px">${x.message}
+            ${x.source ? html` <a href=${x.source} target="_blank" rel="noopener" class="muted">source</a>` : null}</div></div>`)}
+        </div>
+      </div>
+    </div>
+
+    ${vitals.length ? html`<div class="section"><div class="section-head"><h2>Training signals</h2>
+      <span class="muted small">the numbers that explain a curve: exploration, stability, lengths, learning signal, infrastructure, speed</span></div>
+      <div class="grid cols-4">${vitals.map((v) => {
+        const fl = flag(v.signal);
+        const last = v.points.length ? v.points[v.points.length - 1][1] : null;
+        return html`<div class=${`chart-card ${fl ? `flag-${fl}` : ""}`} title=${v.description}>
+          <div class="cc-head"><span class="cc-title">${v.label}</span>${v.unit ? html`<span class="cc-unit">${v.unit}</span>` : null}<span class="cc-value">${f.by(v.format, last)}</span></div>
+          <${LineChart} height=${92} compact=${true} legend=${false} yFormat=${(x) => f.by(v.format, x)}
+            series=${[{ key: v.tag, label: v.label, color: "var(--s1)", points: v.points }]} />
+          <div class="cc-desc mono ellipsis">${v.tag}</div>
+        </div>`;
+      })}</div></div>` : null}
+
+    ${run.breakdown.length ? html`<${Breakdown} ctx=${ctx} run=${run} />` : null}
+    ${(run.reports || []).length ? html`<div class="section"><div class="section-head"><h2>Findings about this run</h2></div>
+      <div class="panel"><div class="list-rows">${run.reports.map((r) => html`<div style="padding:10px 14px">
+        <${ProjectLink} ctx=${ctx} to="/reports"><b>${r.title}</b></${ProjectLink}> <span class="muted small">${r.author} · ${f.date(r.created_at, false)}</span>
+        ${(r.claims || []).slice(0, 4).map((c) => html`<div class="small sec" style="margin-top:3px">${{ upheld: "✓", rejected: "✗", open: "?" }[c.verdict] || "?"} ${c.claim}</div>`)}</div>`)}</div></div></div>` : null}
+    ${run.steps.length ? html`<${StepsTable} ctx=${ctx} run=${run} />` : null}
+  `;
+}
+
+function Breakdown({ ctx, run }) {
+  const rows = run.breakdown.map((b) => {
+    const pr = b.pass_rate || [];
+    const sh = b.share || b.accepted || [];
+    return { ...b, first: pr.length ? pr[0][1] : null, last: pr.length ? pr[pr.length - 1][1] : null,
+      shareLast: sh.length ? sh[sh.length - 1][1] : null, infraLast: b.infra && b.infra.length ? b.infra[b.infra.length - 1][1] : null };
+  });
+  const shareIsCount = run.breakdown.some((b) => b.accepted && !b.share);
+  return html`<div class="section"><div class="section-head"><h2>By environment</h2>
+    <span class="muted small">where the learning signal comes from; pass rates are this run's own training attempts</span></div>
+    <${Table} dense=${true} rowKey=${(r) => r.env_id} rows=${rows} initialSort=${{ key: "shareLast", dir: -1 }} columns=${[
+      { key: "name", label: "Environment", render: (r) => html`<${ProjectLink} ctx=${ctx} to=${`/environments/${r.env_id}`}>${r.name}</${ProjectLink}><span class="sub">${r.domain || ""}</span>` },
+      { key: "shareLast", label: shareIsCount ? "Prompts accepted (last step)" : "Share of batch (last step)", num: true,
+        render: (r) => html`<div class="row" style="justify-content:flex-end"><${Spark} points=${r.share || r.accepted || []} color="var(--s7)" width=${70} height=${20} />
+          <span>${shareIsCount ? f.int(r.shareLast) : f.pct(r.shareLast, 0)}</span></div>` },
+      { key: "first", label: "Pass rate, first step", num: true, render: (r) => f.pct(r.first, 1) },
+      { key: "last", label: "Last step", num: true, render: (r) => html`<div class="row" style="justify-content:flex-end"><${Spark} points=${r.pass_rate || []} color="var(--train)" width=${70} height=${20} /><b>${f.pct(r.last, 1)}</b></div>` },
+      { key: "delta", label: "Change", num: true, sortValue: (r) => (r.last ?? 0) - (r.first ?? 0), render: (r) => html`<${Delta} a=${r.first} b=${r.last} />` },
+      { key: "infraLast", label: "Infra errors", num: true, render: (r) => r.infraLast === null ? html`<span class="muted">—</span>` : f.pct(r.infraLast, 1) },
+    ]} /></div>`;
+}
+
+function StepsTable({ ctx, run }) {
+  const [open, setOpen] = useState({});
+  const [groups, setGroups] = useState({});
+  const toggle = (step) => {
+    const now = !open[step];
+    setOpen({ ...open, [step]: now });
+    if (now && !groups[step]) api(`/p/${ctx.org}/${ctx.project}/runs/${run.id}/steps/${step}`).then((g) => setGroups((s) => ({ ...s, [step]: g })));
+  };
+  const rl = run.kind === "rl";
+  const current = ctx.query.get("rollout");
+  setRolloutOrder(run.steps.slice().reverse().filter((s) => open[s.step] && groups[s.step])
+    .flatMap((s) => groups[s.step].flatMap((g) => g.attempts.map((a) => a.id))));
+  return html`<div class="section"><div class="section-head"><h2>Steps</h2>
+    <span class="muted small">${rl ? "expand a step to see its stored groups: one task, every attempt at it, and the rewards that made the advantages" : "logged steps"}</span></div>
+    <div class="table-wrap" style="max-height:640px"><table class="t dense">
+      <thead><tr><th>Step</th><th class="num">Prompts × attempts</th><th class="num">Pass rate</th>
+        ${rl ? html`<th class="num" title="Groups where every attempt passed / failed carry no gradient">No signal (all pass · all fail)</th><th class="num">Infra errors</th><th class="num">Truncated</th>` : null}
+        <th class="num">Tokens</th><th class="num">Took</th><th class="num">Stored</th></tr></thead>
+      <tbody>${run.steps.slice().reverse().map((s) => html`
+        <tr class=${s.rollouts_stored ? "click" : ""} onClick=${() => s.rollouts_stored && toggle(s.step)}>
+          <td class="nowrap">${s.rollouts_stored ? html`<button class="expander">${open[s.step] ? "▾" : "▸"}</button>` : html`<span style="display:inline-block;width:22px"></span>`}
+            <span class="mono">train@${s.step}</span></td>
+          <td class="num">${f.int(s.prompts)}${s.rollouts ? html` <span class="muted">→ ${f.int(s.rollouts)}</span>` : ""}</td>
+          <td class="num">${s.pass_rate === null ? "—" : f.pct(s.pass_rate, 1)}</td>
+          ${rl ? html`<td class="num">${s.groups_all_pass === null ? "—" : html`${f.int(s.groups_all_pass)} · ${f.int(s.groups_all_fail)} <span class="muted">of ${f.int((s.groups_all_pass || 0) + (s.groups_all_fail || 0) + (s.groups_mixed || 0))}</span>`}</td>
+            <td class="num">${f.int(s.infra_errors)}</td><td class="num">${f.int(s.truncated)}</td>` : null}
+          <td class="num">${f.compact(s.tokens)}</td>
+          <td class="num">${s.ended_at && s.started_at ? f.duration(s.ended_at - s.started_at) : "—"}</td>
+          <td class="num">${s.rollouts_stored ? f.int(s.rollouts_stored) : html`<span class="muted">0</span>`}</td>
+        </tr>
+        ${open[s.step] ? (groups[s.step] ? groups[s.step].map((g) => html`<tr class="child">
+          <td colspan=${rl ? 9 : 6}><div class="row">
+            <span class="grow ellipsis"><${ProjectLink} ctx=${ctx} to=${`/environments/${g.env_id}`} class="muted">${g.env}</${ProjectLink}> · ${g.task}</span>
+            <span class="small muted nowrap">${passLine(g.attempts, g.reward_kind)}</span>
+            <${Attempts} attempts=${g.attempts} kind=${g.reward_kind} current=${current} onPick=${(a) => setQuery({ rollout: a.id })} />
+          </div></td></tr>`) : html`<tr class="child"><td colspan="9" class="muted">Loading…</td></tr>`) : null}
+      `)}</tbody></table></div></div>`;
+}
+
+/** A group's result in words: passes out of scored attempts, or for scalar rewards their mean and range (no pass/fail). */
+export function passLine(atts, kind) {
+  const scored = atts.filter((a) => a.reward !== null && a.reward !== undefined);
+  const infra = atts.length - scored.length;
+  const mean = scored.length ? scored.reduce((s, a) => s + a.reward, 0) / scored.length : null;
+  if (scored.length && !scored.every((a) => hasVerdict(kind, a.reward))) {
+    const lo = Math.min(...scored.map((a) => a.reward)), hi = Math.max(...scored.map((a) => a.reward));
+    return `mean reward ${f.num(mean, 3)} · ${f.num(lo, 2)} to ${f.num(hi, 2)} over ${scored.length}${infra ? ` · ${infra} infra` : ""}`;
+  }
+  const passed = scored.filter((a) => a.reward >= 1 || a.outcome === "passed").length;
+  return `${passed}/${scored.length} passed${infra ? ` · ${infra} infra` : ""}${mean !== null ? ` · mean ${f.num(mean, 2)}` : ""}`;
+}
+
+// ------------------------------------------------------------------ rollouts tab
+function RunRollouts({ ctx, run }) {
+  const q = ctx.query;
+  const step = q.get("step") || "";
+  const env = q.get("env") || "";
+  const outcome = q.get("outcome") || "";
+  const [text, setText] = useState(q.get("q") || "");
+  const { data, error, loading } = useApi(`/p/${ctx.org}/${ctx.project}/runs/${run.id}/rollouts`, { step, env, outcome, q: q.get("q") || "", limit: 6000 });
+  const envs = run.inputs.filter((i) => i.kind === "environment" && i.ref);
+  const groupBy = q.get("by") || "step";
+  const groups = useMemo(() => {
+    const m = new Map();
+    for (const r of data || []) {
+      if (!m.has(r.group_id)) m.set(r.group_id, { id: r.group_id, step: r.step, task: r.task, task_id: r.task_id, env: r.env, env_id: r.env_id, kind: r.reward_kind, attempts: [] });
+      m.get(r.group_id).attempts.push(r);
+    }
+    return [...m.values()];
+  }, [data]);
+  const byTask = useMemo(() => {
+    const m = new Map();
+    for (const g of groups) {
+      if (!m.has(g.task_id)) m.set(g.task_id, { task: g.task, task_id: g.task_id, env: g.env, env_id: g.env_id, groups: [] });
+      m.get(g.task_id).groups.push(g);
+    }
+    return [...m.values()].sort((a, b) => b.groups.length - a.groups.length);
+  }, [groups]);
+  const current = q.get("rollout");
+  const stepsWith = run.steps.filter((s) => s.rollouts_stored).map((s) => s.step);
+  setRolloutOrder(groupBy === "task" ? byTask.slice(0, 300).flatMap((t) => t.groups.slice().sort((a, b) => a.step - b.step).flatMap((g) => g.attempts.map((a) => a.id)))
+    : groups.slice(0, 400).flatMap((g) => g.attempts.map((a) => a.id)));
+  return html`
+    <div class="filters">
+      <select class="input" value=${step} onChange=${(e) => setQuery({ step: e.target.value })}>
+        <option value="">All steps</option>${stepsWith.map((s) => html`<option value=${s}>step ${s}</option>`)}</select>
+      <select class="input" value=${env} onChange=${(e) => setQuery({ env: e.target.value })}>
+        <option value="">All environments</option>${envs.map((e) => html`<option value=${e.ref_id}>${e.ref.name}</option>`)}</select>
+      <select class="input" value=${outcome} onChange=${(e) => setQuery({ outcome: e.target.value })}>
+        <option value="">Any outcome</option>${["passed", "failed", "partial", "timeout", "truncated", "max_turns", "infra_error"].map((o) => html`<option value=${o}>${o.replace("_", " ")}</option>`)}</select>
+      <input class="input search" placeholder="Task name or instruction" value=${text} onInput=${(e) => setText(e.target.value)}
+        onKeyDown=${(e) => e.key === "Enter" && setQuery({ q: text })} />
+      <div class="seg">${[["step", "By step"], ["task", "By task"]].map(([k, l]) => html`<button class=${groupBy === k ? "on" : ""} onClick=${() => setQuery({ by: k === "step" ? null : k })}>${l}</button>`)}</div>
+      <span class="muted small">${loading ? "Loading…" : `${groups.length} groups · ${(data || []).length} attempts`}${run.steps.length ? ` · stored ${f.int(run.rollouts_stored)} of ${f.compact(run.steps.reduce((s, x) => s + (x.rollouts || 0), 0))} rollouts` : ""}</span>
+    </div>
+    ${error ? html`<${Err} error=${error} />` : null}
+    ${groupBy === "task" ? html`<div class="table-wrap"><table class="t dense">
+      <thead><tr><th>Task</th><th>Environment</th><th>Each time it was sampled (step: attempts)</th></tr></thead>
+      <tbody>${byTask.slice(0, 300).map((t) => html`<tr>
+        <td class="ellipsis" style="max-width:320px"><${ProjectLink} ctx=${ctx} to=${`/tasks/${t.task_id}`}>${t.task}</${ProjectLink}></td>
+        <td class="ellipsis" style="max-width:200px" title=${t.env}><${ProjectLink} ctx=${ctx} to=${`/environments/${t.env_id}`}>${t.env}</${ProjectLink}></td>
+        <td><div class="row wrap" style="gap:10px">${t.groups.sort((a, b) => a.step - b.step).map((g) => html`<span class="row" style="gap:4px"><span class="mono small muted">${g.step}</span>
+          <${Attempts} attempts=${g.attempts} kind=${g.kind} current=${current} onPick=${(a) => setQuery({ rollout: a.id })} /></span>`)}</div></td></tr>`)}</tbody></table></div>
+      <p class="muted small">Tasks sampled more than once show how the policy's attempts at the same task changed over training.</p>` : html`
+    <div class="table-wrap"><table class="t dense">
+      <thead><tr><th>Step</th><th>Task</th><th>Environment</th><th>Attempts</th><th class="num">Result</th><th class="num">Turns</th><th class="num">Tokens out</th><th class="num">Time</th></tr></thead>
+      <tbody>${groups.slice(0, 400).map((g) => {
+        const turns = g.attempts.reduce((s, a) => s + (a.turns || 0), 0) / g.attempts.length;
+        const toks = g.attempts.reduce((s, a) => s + (a.tokens_out || 0), 0) / g.attempts.length;
+        const secs = g.attempts.reduce((s, a) => s + (a.duration_s || 0), 0) / g.attempts.length;
+        return html`<tr class="click" onClick=${() => setQuery({ rollout: g.attempts[0].id })}>
+          <td class="mono">${g.step}</td><td class="ellipsis" style="max-width:360px" title=${g.task}>${g.task}</td>
+          <td class="ellipsis" style="max-width:200px" title=${g.env}><${ProjectLink} ctx=${ctx} to=${`/environments/${g.env_id}`}>${g.env}</${ProjectLink}></td>
+          <td><${Attempts} attempts=${g.attempts} kind=${g.kind} current=${current} onPick=${(a) => setQuery({ rollout: a.id })} /></td>
+          <td class="num small nowrap">${passLine(g.attempts, g.kind)}</td><td class="num">${f.num(turns, 1)}</td><td class="num">${f.compact(toks)}</td><td class="num">${f.duration(secs)}</td></tr>`;
+      })}</tbody></table></div>`}`;
+}
+
+// ------------------------------------------------------------------ metrics explorer
+export function MetricsExplorer({ ctx, run }) {
+  const { data: tags, error } = useApi(`/p/${ctx.org}/${ctx.project}/runs/${run.id}/tags`);
+  const { data: allRuns } = useApi(`/p/${ctx.org}/${ctx.project}/runs`);
+  const q = ctx.query;
+  const [search, setSearch] = useState(q.get("m") || "");
+  const [ns, setNs] = useState(q.get("ns") || "pinned");
+  const [smoothing, setSmoothing] = useState(0);
+  const [others, setOthers] = useState([]);
+  const [series, setSeries] = useState({});
+  const namespaces = new Map();
+  for (const t of tags || []) {
+    const n = t.tag.includes("/") ? t.tag.split("/")[0] : "(root)";
+    namespaces.set(n, (namespaces.get(n) || 0) + 1);
+  }
+  const all = tags || [];
+  const pinned = all.filter((t) => t.pinned || (t.signal && !t.signal.includes("@")));
+  let shown = ns === "pinned" ? pinned : ns === "all" ? all : all.filter((t) => (t.tag.includes("/") ? t.tag.split("/")[0] : "(root)") === ns);
+  if (search) shown = all.filter((t) => t.tag.toLowerCase().includes(search.toLowerCase()) || (t.label || "").toLowerCase().includes(search.toLowerCase()));
+  shown = shown.slice(0, 48);
+  const runIds = [run.id, ...others];
+  const need = shown.map((t) => t.tag);
+  const key = `${runIds.join(",")}|${need.join(",")}`;
+  useEffect(() => {
+    if (!need.length) return;
+    api(`/p/${ctx.org}/${ctx.project}/metrics`, { runs: runIds.join(","), tags: need.join(","), points: 300 }).then((d) => setSeries((s) => ({ ...s, [key]: d })));
+  }, [key]);
+  if (error) return html`<${Err} error=${error} />`;
+  if (!tags) return html`<${Loading} />`;
+  const data = series[key];
+  const runName = (id) => ((allRuns || []).find((r) => r.id === id) || {}).name || id;
+  return html`<div class="explorer">
+    <div class="panel explorer-nav">
+      <div class="panel-body" style="padding:10px"><input class="input search" style="width:100%" placeholder=${`Search ${tags.length} metrics`} value=${search} onInput=${(e) => setSearch(e.target.value)} /></div>
+      <div class="nav" style="padding:0 6px 8px;max-height:60vh;overflow:auto">
+        ${[["pinned", "Key signals", pinned.length], ["all", "Everything", tags.length], ...[...namespaces.entries()].sort()].map(([n, l, c]) => html`
+          <a href="#" class=${ns === n && !search ? "on" : ""} onClick=${(e) => { e.preventDefault(); setSearch(""); setNs(n); setQuery({ ns: n }); }}>
+            <span class=${c === undefined ? "mono small" : ""}>${c === undefined ? n : l}</span><span class="count">${c === undefined ? l : c}</span></a>`)}
+      </div>
+    </div>
+    <div>
+      <div class="filters">
+        <div class="seg">${[[0, "Raw"], [0.6, "Smooth 60%"], [0.9, "90%"]].map(([v, l]) => html`<button class=${smoothing === v ? "on" : ""} onClick=${() => setSmoothing(v)}>${l}</button>`)}</div>
+        ${allRuns && allRuns.length > 1 ? html`<select class="input" value="" onChange=${(e) => e.target.value && setOthers([...others, e.target.value].slice(0, 5))}>
+          <option value="">Compare with another run…</option>
+          ${allRuns.filter((r) => r.id !== run.id && !others.includes(r.id)).map((r) => html`<option value=${r.id}>${r.name}</option>`)}</select>` : null}
+        ${others.map((o, i) => html`<span class="chip"><i class="key" style=${`display:inline-block;width:10px;height:2px;background:${SERIES[(i + 1) % 8]}`}></i>${runName(o)}
+          <button class="icon-btn" style="width:18px;height:18px" onClick=${() => setOthers(others.filter((x) => x !== o))}>×</button></span>`)}
+        <span class="muted small">${shown.length}${shown.length === 48 ? "+" : ""} charts</span>
+        <span class="grow"></span>
+        <button class="btn small" disabled=${!data} onClick=${() => {
+          const tagsShown = shown.map((t) => t.tag);
+          const rowsCsv = [["run", "tag", "step", "value"].join(",")];
+          for (const rid of runIds) for (const t of tagsShown) for (const [st, v] of ((data && data[rid] && data[rid][t]) || [])) rowsCsv.push([runName(rid), t, st, v].map((x) => /[",]/.test(String(x)) ? `"${String(x).replace(/"/g, '""')}"` : x).join(","));
+          const a = document.createElement("a");
+          a.href = URL.createObjectURL(new Blob([rowsCsv.join("\n")], { type: "text/csv" }));
+          a.download = `${run.name}-metrics.csv`; a.click();
+        }}><${Icon} name="download" size=${13} />Download CSV</button>
+      </div>
+      <div class="grid cols-3">${shown.map((t) => {
+        const ser = runIds.map((rid, i) => ({ key: rid, label: runName(rid), color: i === 0 ? "var(--s2)" : SERIES[i % 8], points: (data && data[rid] && data[rid][t.tag]) || [] }))
+          .filter((s) => s.points.length);
+        const last = ser.length && ser[0].key === run.id && ser[0].points.length ? ser[0].points[ser[0].points.length - 1][1] : null;
+        return html`<div class="chart-card" title=${t.description || ""}>
+          <div class="cc-head"><span class="cc-title ellipsis">${t.label && t.label !== t.tag ? t.label : t.tag}</span><span class="cc-value">${f.by(t.format, last)}</span></div>
+          ${data ? html`<${LineChart} height=${110} compact=${true} smoothing=${smoothing} legend=${false} yFormat=${(x) => f.by(t.format, x)} series=${ser} />` : html`<div style="height:110px"></div>`}
+          <div class="cc-desc mono ellipsis">${t.tag}</div>
+          ${t.description ? html`<div class="cc-desc">${t.description.slice(0, 160)}${t.description.length > 160 ? "…" : ""}</div>` : null}
+        </div>`;
+      })}</div>
+    </div>
+  </div>`;
+}
+
+// ------------------------------------------------------------------ evals, data, events, config
+function CheckpointMatrix({ ctx, run, benches }) {
+  // rows are checkpoints the run saved and then evaluated; an eval at a step that saved nothing is no checkpoint to keep
+  const saved = new Set((run.checkpoints || []).map((k) => k.step));
+  const evaluated = new Set(run.eval_points.filter((e) => e.score !== null).map((e) => e.step));
+  const steps = [...saved].filter((st) => evaluated.has(st)).sort((a, b) => b - a);
+  if (benches.length < 1 || evaluated.size < 2) return null;
+  if (steps.length < 2) {
+    return html`<p class="muted small" style="margin-top:0">${saved.size
+      ? `${f.plural(saved.size, "saved checkpoint")}, ${steps.length ? "only one of them evaluated" : "none of them evaluated"}: there is no checkpoint to choose between. The evals by step are below.`
+      : "This run recorded no saved checkpoints, so there is no checkpoint to choose between. The evals by step are below."}</p>`;
+  }
+  const cell = (b, st) => b.rows.find((r) => r.step === st && r.score !== null);
+  const best = new Map(benches.map((b) => {
+    const vals = steps.map((st) => cell(b, st)).filter(Boolean).map((e) => e.score);
+    return [b.id, vals.length ? Math.max(...vals) : null];
+  }));
+  const complete = steps.filter((st) => benches.every((b) => cell(b, st)));
+  const rank = new Map(complete.map((st) => [st, benches.reduce((s, b) => s + cell(b, st).score / (best.get(b.id) || 1), 0) / benches.length]));
+  const top = complete.length ? complete.reduce((a, b) => (rank.get(b) > rank.get(a) ? b : a)) : null;
+  return html`<div class="section" style="margin-top:0"><div class="section-head"><h2>Which checkpoint to keep</h2>
+    <span class="muted small">${steps.length} of ${f.plural(saved.size, "saved checkpoint")} evaluated; ± is one standard error; bold is each benchmark's best, and differences within about 2 SE are noise; a blank cell was not evaluated at that checkpoint</span></div>
+    <div class="table-wrap" style="max-height:360px"><table class="t dense"><thead><tr><th>Checkpoint</th>${benches.map((b) => html`<th class="num">${b.name}</th>`)}<th class="num" title="Mean of score / best score over the benchmarks evaluated at every checkpoint listed">Relative to best</th></tr></thead>
+    <tbody>${steps.map((st) => html`<tr class=${st === top ? "sel" : ""}><td class="mono nowrap">step ${st}${st === top ? html` <span class="tag">best overall</span>` : ""}</td>
+      ${benches.map((b) => { const e = cell(b, st); return e ? html`<td class="num nowrap"><${ProjectLink} ctx=${ctx} to=${`/evals/${e.id}`}>${e.score === best.get(b.id) ? html`<b>${f.score(b.metric, e.score)}</b>` : f.score(b.metric, e.score)}</${ProjectLink}>
+          <span class="muted small"> ${f.scoreErr(b.metric, e.stderr)}</span></td>` : html`<td class="num" title="Not evaluated at this checkpoint"></td>`; })}
+      <td class="num">${rank.has(st) ? f.pct(rank.get(st), 1) : html`<span class="muted" title="Not every benchmark was evaluated at this checkpoint">—</span>`}</td></tr>`)}</tbody></table></div></div>`;
+}
+
+function RunEvals({ ctx, run }) {
+  const byBench = new Map();
+  for (const e of run.eval_points) {
+    if (!byBench.has(e.benchmark_id)) byBench.set(e.benchmark_id, { id: e.benchmark_id, name: e.benchmark, metric: e.metric, rows: [] });
+    byBench.get(e.benchmark_id).rows.push(e);
+  }
+  return html`<${CheckpointMatrix} ctx=${ctx} run=${run} benches=${[...byBench.values()]} />
+  ${[...byBench.values()].map((b) => {
+    const pts = b.rows.filter((r) => r.score !== null);
+    return html`<div class="section"><div class="section-head"><h2>${b.name}</h2><span class="muted small">${b.metric} · ${pts.length ? `${f.int(pts[0].n_tasks)} tasks × ${pts[0].k}` : ""}</span></div>
+      <div class="split split-wide">
+        <div class="chart-card"><${LineChart} height=${200} yFormat=${(v) => f.score(b.metric, v, 0)} events=${eventMarks(run)}
+          series=${[{ key: b.id, label: b.name, color: "var(--eval)", dots: true, points: pts.map((p) => [p.step, p.score]), band: pts.map((p) => [p.step, p.score - (p.stderr || 0), p.score + (p.stderr || 0)]) }]}
+          onPick=${(step) => { const e = pts.find((p) => p.step === step); if (e) navigate(`${ctx.base}/evals/${e.id}`); }} />
+          <div class="cc-desc">Band is ±1 standard error over tasks. Click a point to open that eval.</div></div>
+        <${Table} dense=${true} maxHeight="280px" rows=${pts.slice().reverse()} rowKey=${(r) => r.id} onRow=${(r) => navigate(`${ctx.base}/evals/${r.id}`)} columns=${[
+          { key: "step", label: "Step", num: true },
+          { key: "score", label: "Score", num: true, render: (r) => html`<b>${f.score(b.metric, r.score, 2)}</b> <span class="muted small">${f.scoreErr(b.metric, r.stderr)}</span>` },
+          { key: "d", label: "vs first", num: true, sortValue: (r) => r.score - pts[0].score, render: (r) => html`<${Delta} a=${pts[0].score} b=${r.score} />` },
+        ]} />
+      </div></div>`;
+  })}`;
+}
+
+function RunData({ ctx, run }) {
+  const rows = run.inputs.map((i) => ({ ...i, name: i.ref ? i.ref.name : i.ref_id }));
+  const total = rows.reduce((s, r) => s + (r.weight || 0), 0);
+  const bd = new Map(run.breakdown.map((b) => [b.env_id, b]));
+  // composition over the run, grouped by domain (fixed colour order)
+  const byDomain = new Map();
+  for (const b of run.breakdown) {
+    const pts = b.share || b.accepted || [];
+    if (!pts.length) continue;
+    const d = b.domain || "other";
+    if (!byDomain.has(d)) byDomain.set(d, new Map());
+    const m = byDomain.get(d);
+    for (const [x, v] of pts) m.set(x, (m.get(x) || 0) + (v || 0));
+  }
+  const domains = [...byDomain.keys()].sort();
+  const layers = domains.map((d, i) => ({ key: d, label: d, color: SERIES[i % 8], points: [...byDomain.get(d).entries()].sort((a, b) => a[0] - b[0]) }));
+  return html`<div class="section" style="margin-top:0">
+    ${layers.length ? html`<div class="chart-card" style="margin-bottom:16px"><div class="cc-head"><span class="cc-title">What each step trained on</span><span class="cc-unit">share of the step's prompts, by domain</span></div>
+      <${StackedArea} layers=${layers} height=${190} />
+      <div class="cc-desc">A band that thins or disappears is a source that was filtered, exhausted or removed; the Events tab says why.</div></div>` : null}
+    <${Table} rows=${rows} rowKey=${(r) => r.ref_id} initialSort=${{ key: "weight", dir: -1 }} columns=${[
+      { key: "name", label: "Input", render: (r) => html`<${ProjectLink} ctx=${ctx} to=${`/${r.kind === "environment" ? "environments" : "datasets"}/${r.ref_id}`}>${r.name}</${ProjectLink}>
+        <span class="sub">${r.kind}${r.ref && r.ref.domain ? ` · ${r.ref.domain}` : ""}${r.ref && r.ref.kind ? ` · ${r.ref.kind}` : ""}</span>` },
+      { key: "weight", label: "Weight in the mix", num: true, render: (r) => html`<div class="bar-cell" style="justify-content:flex-end"><span class="bar" style="max-width:120px"><i style=${`width:${(r.weight / (total || 1)) * 100}%`}></i></span><span>${f.pct((r.weight || 0) / (total || 1), 1)}</span></div>` },
+      { key: "tasks", label: "Tasks / rows", num: true, sortValue: (r) => r.ref ? (r.ref.task_count || r.ref.rows) : null, render: (r) => r.ref ? f.int(r.ref.task_count ?? r.ref.rows) : "—" },
+      { key: "trend", label: "Batch share over the run", sortable: false, render: (r) => { const b = bd.get(r.ref_id); return b ? html`<${Spark} points=${b.share || b.accepted || []} color="var(--s7)" width=${140} height=${22} />` : html`<span class="muted">—</span>`; } },
+    ]} />
+    <p class="muted small">Weights are the average number of prompts drawn from each input per step (RL) or the mixture weight (SFT).</p>
+  </div>`;
+}
+
+function RunEvents({ ctx, run }) {
+  const KIND = { restart: "Restart", notice: "Notice", start: "Started", end: "Finished", checkpoint: "Checkpoint", alert: "Alert", data: "Data change", config: "Config change", incident: "Incident", eval: "Eval" };
+  const lv = { restart: "warn", incident: "bad", alert: "warn" };
+  const focus = ctx.query.get("event");   // set by a search result: that event is highlighted and scrolled into view
+  const box = useRef(null);
+  useEffect(() => {
+    const el = box.current && box.current.querySelector(".event.sel");
+    if (el) el.scrollIntoView({ block: "center" });
+  }, [focus, run.id]);
+  return html`<div class="panel" ref=${box}><div class="list-rows">${run.events.slice().reverse().map((e) => html`<div class=${`event ${focus && String(e.eid) === focus ? "sel" : ""}`} style="grid-template-columns:150px 110px 1fr">
+    <span class="when">${f.date(e.t)}</span>
+    <span>${lv[e.kind] ? html`<${Level} level=${lv[e.kind]} label=${KIND[e.kind] || e.kind} />` : html`<b>${KIND[e.kind] || e.kind}</b>`}${e.step !== null && e.step !== undefined ? html`<span class="sub muted">step ${e.step}</span>` : null}</span>
+    <div>${e.title && !KIND[e.kind] ? html`<div>${e.title}</div>` : null}${e.body ? html`<div class="sec">${e.body}</div>` : (e.title && KIND[e.kind] && e.title !== KIND[e.kind] ? html`<div class="sec">${e.title}</div>` : null)}</div>
+  </div>`)}</div></div>`;
+}
+
+function RunConfig({ run, spec }) {
+  const hp = run.hyperparams || {};
+  const copy = () => navigator.clipboard && navigator.clipboard.writeText(run.config || "");
+  const hasSpec = spec && Object.keys(spec).length;
+  return html`${hasSpec ? html`<div class="panel" style="margin-bottom:14px"><div class="panel-head"><h3>Launch spec</h3>
+      <span class="muted small">what was queued for the runner${spec.command ? "" : "; it builds the job with posttrain.recipes.build from stage, recipe and params"}</span></div>
+      <div class="panel-body"><pre class="code">${JSON.stringify(spec, null, 2)}</pre></div></div>` : null}
+    <div class="grid cols-2" style="align-items:start">
+    <div class="panel"><div class="panel-head"><h3>Hyperparameters</h3></div><div class="panel-body"><div class="kv">
+      ${Object.entries(hp).map(([k, v]) => html`<span class="k mono">${k}</span><span class="mono">${typeof v === "object" ? JSON.stringify(v) : String(v)}</span>`)}
+    </div></div></div>
+    <div class="panel"><div class="panel-head"><h3>Config</h3><span class="muted small">${run.config_format || ""}</span><span class="grow"></span>
+      ${run.config ? html`<button class="btn small" onClick=${copy}><${Icon} name="copy" size=${13} />Copy</button>` : null}</div>
+      <div class="panel-body">${run.config ? html`<pre class="code">${run.config}</pre>` : html`<span class="muted">No config recorded.</span>`}</div></div>
+  </div>`;
+}
+
+// ------------------------------------------------------------------ compare runs
+const COMPARE_SIGNALS = ["pass_rate", "reward", "loss", "val_loss", "reward_margin", "pref_accuracy", "entropy", "grad_norm", "train_infer_kl",
+  "response_len", "truncation_rate", "all_fail_share", "all_pass_share", "infra_error_rate", "staleness", "step_time", "throughput", "lr"];
+
+export function CompareRuns({ ctx }) {
+  const ids = (ctx.query.get("ids") || "").split(",").filter(Boolean);
+  const [runs, setRuns] = useState(null);
+  const [onlyDiff, setOnlyDiff] = useState(true);
+  const [smoothing, setSmoothing] = useState(0);
+  useEffect(() => {
+    Promise.all(ids.map((id) => api(`/p/${ctx.org}/${ctx.project}/runs/${id}`))).then(setRuns, () => setRuns([]));
+  }, [ids.join(",")]);
+  if (!ids.length) return html`<${Empty}>Select runs on the Runs page to compare them.</${Empty}>`;
+  if (!runs) return html`<${Loading} />`;
+  const color = (i) => SERIES[i % 8];
+  const signals = COMPARE_SIGNALS.filter((sg) => runs.some((r) => r.vitals.some((v) => v.signal === sg)));
+  const keys = [...new Set(runs.flatMap((r) => Object.keys(r.hyperparams || {})))].sort();
+  const val = (r, k) => { const v = (r.hyperparams || {})[k]; return v === undefined ? "—" : typeof v === "object" ? JSON.stringify(v) : String(v); };
+  const rowsHp = keys.map((k) => ({ k, vals: runs.map((r) => val(r, k)) })).filter((x) => !onlyDiff || new Set(x.vals).size > 1);
+  const benches = new Map();
+  runs.forEach((r, i) => r.eval_points.forEach((e) => {
+    if (!benches.has(e.benchmark_id)) benches.set(e.benchmark_id, { name: e.benchmark, metric: e.metric, by: {} });
+    const b = benches.get(e.benchmark_id);
+    if (e.score !== null && (!b.by[r.id] || e.step >= b.by[r.id].step)) b.by[r.id] = e;
+  }));
+  const remove = (id) => navigate(`${ctx.base}/runs/compare?ids=${ids.filter((x) => x !== id).join(",")}`);
+  return html`
+    <div class="page-head"><div class="grow">
+      <div class="crumb-line"><${ProjectLink} ctx=${ctx} to="/runs">Runs</${ProjectLink}> / compare</div>
+      <h1>Compare ${runs.length} runs</h1>
+      <div class="row wrap" style="margin-top:10px">${runs.map((r, i) => html`<span class="chip outline"><i style=${`display:inline-block;width:12px;height:2px;background:${color(i)}`}></i>
+        <${ProjectLink} ctx=${ctx} to=${`/runs/${r.id}`}>${r.name}</${ProjectLink}><span class="muted">${r.steps_done} steps</span>
+        <button class="icon-btn" style="width:18px;height:18px" title="Remove" onClick=${() => remove(r.id)}>×</button></span>`)}</div>
+    </div></div>
+    <div class="filters"><div class="seg">${[[0, "Raw"], [0.6, "Smooth 60%"], [0.9, "90%"]].map(([v, l]) => html`<button class=${smoothing === v ? "on" : ""} onClick=${() => setSmoothing(v)}>${l}</button>`)}</div>
+      <span class="muted small">x-axis is each run's own step</span></div>
+    <div class="grid cols-3">${signals.map((sg) => {
+      const ser = runs.map((r, i) => { const v = r.vitals.find((x) => x.signal === sg); return v ? { key: r.id, label: r.name, color: color(i), points: v.points, fmt: v.format, lab: v.label } : null; }).filter(Boolean);
+      const first = ser[0];
+      return html`<div class="chart-card"><div class="cc-head"><span class="cc-title">${first.lab}</span></div>
+        <${LineChart} height=${140} compact=${true} smoothing=${smoothing} legend=${false} yFormat=${(x) => f.by(first.fmt, x)} series=${ser} /></div>`;
+    })}</div>
+    ${benches.size ? html`<div class="section"><div class="section-head"><h2>Held-out results</h2><span class="muted small">latest eval of each run</span></div>
+      <div class="table-wrap"><table class="t"><thead><tr><th>Benchmark</th>${runs.map((r, i) => html`<th class="num"><i style=${`display:inline-block;width:10px;height:2px;margin-right:6px;vertical-align:middle;background:${color(i)}`}></i>${r.name}</th>`)}</tr></thead>
+        <tbody>${[...benches.values()].map((b) => {
+          const vals = runs.map((r) => b.by[r.id] ? b.by[r.id].score : null);
+          const best = Math.max(...vals.filter((v) => v !== null));
+          return html`<tr><td>${b.name}</td>${runs.map((r) => { const e = b.by[r.id]; return html`<td class="num">${e ? html`<${ProjectLink} ctx=${ctx} to=${`/evals/${e.id}`}>${e.score === best ? html`<b>${f.score(b.metric, e.score)}</b>` : f.score(b.metric, e.score)}</${ProjectLink}>
+            <span class="muted small"> ${f.scoreErr(b.metric, e.stderr)}</span><span class="sub">step ${e.step}</span>` : html`<span class="muted">—</span>`}</td>`; })}</tr>`;
+        })}</tbody></table></div></div>` : null}
+    <div class="section"><div class="section-head"><h2>Configuration</h2>
+      <label class="small"><input type="checkbox" checked=${onlyDiff} onChange=${(e) => setOnlyDiff(e.target.checked)} /> only what differs</label></div>
+      <div class="table-wrap"><table class="t dense"><thead><tr><th>Setting</th>${runs.map((r) => html`<th>${r.name}</th>`)}</tr></thead>
+        <tbody>
+          <tr><td class="mono small">base model</td>${runs.map((r) => html`<td>${r.base_model || "—"}</td>`)}</tr>
+          <tr><td class="mono small">algorithm</td>${runs.map((r) => html`<td>${[r.algorithm, r.framework].filter(Boolean).join(" · ")}</td>`)}</tr>
+          <tr><td class="mono small">inputs</td>${runs.map((r) => html`<td class="small">${r.inputs.map((x) => x.ref ? x.ref.name : x.ref_id).slice(0, 4).join(", ")}${r.inputs.length > 4 ? ` +${r.inputs.length - 4}` : ""}</td>`)}</tr>
+          ${rowsHp.map((x) => html`<tr><td class="mono small">${x.k}</td>${x.vals.map((v) => html`<td class="mono small">${v}</td>`)}</tr>`)}
+          ${rowsHp.length === 0 ? html`<tr><td colspan=${runs.length + 1} class="muted">No differences in recorded hyperparameters.</td></tr>` : null}
+        </tbody></table></div></div>`;
+}
diff --git a/viewer/static/pages/settings.js b/viewer/static/pages/settings.js
new file mode 100644
index 0000000000000000000000000000000000000000..83dcdd97d43b10fc93680c43df766c0789b99325
--- /dev/null
+++ b/viewer/static/pages/settings.js
@@ -0,0 +1,121 @@
+import { html, useState, useApi, apiPost, invalidate, getToken, setToken, shq } from "../lib.js";
+import { Loading, Table, Presence, Icon } from "../ui/common.js";
+import { Field, Command, useSubmit, SubmitProblem, TokenPrompt } from "../ui/forms.js";
+import * as f from "../ui/fmt.js";
+
+const ABOUT = {
+  workspace: ["Your workspace", "Your own projects. The website, the posttrain CLI, the SDK and runners all write here: datasets, environments, runs with their metrics and logs, evals and compute targets."],
+  demo: ["Examples from public recipes", "Read-only projects rebuilt from published post-training programs (MiMo, Nemotron, Marin, OLMo, INTELLECT and others). Published numbers are used as published and keep their source; rollouts and anything else not published are simulated to agree with them. The clock is frozen at build time."],
+  live: ["BenchFlow runs", "Read-only record of BenchFlow's own training runs, rebuilt from their run records."],
+};
+
+function Sources({ ctx }) {
+  const meta = ctx.meta;
+  const count = (src) => (meta.orgs || []).filter((o) => o.source === src).reduce((n, o) => n + o.projects.length, 0);
+  return html`<div class="panel"><div class="panel-head"><h3>Where projects come from</h3></div>
+    <div class="list-rows">${Object.entries(ABOUT).map(([k, [label, about]]) => {
+      const m = (meta.metas || {})[k] || {};
+      const avail = (meta.sources || {})[k];
+      const n = count(k);
+      return html`<div class="setting-row">
+        <div><b>${label}</b>${ctx.source === k ? html` <span class="tag">this project</span>` : null}
+          <div class="small sec" style="margin-top:2px">${about}</div></div>
+        <div class="small nowrap right-col">${!avail && k !== "workspace" ? html`<span class="muted">Not on this server</span>`
+          : html`<div>${f.plural(n, "project")}</div>${m.built_at ? html`<div class="muted">built ${f.date(+m.built_at, false)}</div>` : null}`}</div>
+      </div>`;
+    })}</div>
+    <div class="panel-body small muted">Every project opens from the source that holds it, so links always land on the same data. Your workspace is listed first; an example with the same address as one of your projects is hidden behind it.</div>
+  </div>`;
+}
+
+function Revoke({ t }) {
+  const [sure, setSure] = useState(false);
+  const [submit, state] = useSubmit(async () => { await apiPost("/tokens/revoke", { prefix: t.prefix }); invalidate(); });
+  if (t.revoked) return null;
+  if (!sure) return html`<button class="btn small ghost" onClick=${() => setSure(true)}>Revoke</button>`;
+  return html`<span class="row" style="gap:6px;justify-content:flex-end"><span class="small">Stops working at once.</span>
+    <button class="btn small" onClick=${() => setSure(false)}>Keep</button>
+    <button class="btn small danger" disabled=${state.busy} onClick=${() => submit()}>Revoke</button></span>`;
+}
+
+function Tokens({ ctx }) {
+  const list = useApi("/tokens", { source: "" });
+  const [name, setName] = useState("");
+  const [user, setUser] = useState("");
+  const [forever, setForever] = useState(false);
+  const [made, setMade] = useState(null);
+  const url = location.origin;
+  const [submit, state] = useSubmit(async () => {
+    const res = await apiPost("/tokens", { name: name.trim() || "browser", user: user.trim() || undefined, expires: forever ? "never" : undefined });
+    setMade(res.token);
+    setName("");
+    invalidate();
+  });
+  const real = Date.now() / 1000;
+  const denied = list.error && list.error.status === 401;
+  return html`<div class="panel"><div class="panel-head"><h3>API tokens</h3><span class="muted small">for the CLI, the SDK, trainers and runners</span></div>
+    <div class="panel-body">
+      ${denied ? html`<${TokenPrompt} reason="Listing tokens needs an API token." />` : !list.data ? html`<${Loading} />` : html`
+        <${Table} dense=${true} rows=${list.data} rowKey=${(t) => t.prefix + t.created_at} empty="No tokens yet." columns=${[
+          { key: "name", label: "Name", render: (t) => html`<b>${t.name}</b>` },
+          { key: "user", label: "User" },
+          { key: "prefix", label: "Token", render: (t) => html`<span class="mono">${t.prefix}…</span><span class="sub">${(t.scope || "").startsWith("runner:") ? `runner · ${t.scope.slice(7)}` : "user"}</span>` },
+          { key: "created_at", label: "Created", num: true, render: (t) => f.ago(t.created_at, real) },
+          { key: "last_used", label: "Last used", num: true, render: (t) => t.last_used ? f.ago(t.last_used, real) : html`<span class="muted">never</span>` },
+          { key: "expires", label: "Expires", num: true, render: (t) => t.expires ? (t.expires < real ? html`<span class="muted">expired</span>` : f.date(t.expires, false)) : html`<span class="warn-ink">never</span>` },
+          { key: "revoked", label: "Status", render: (t) => t.revoked ? html`<span class="status stopped">Revoked</span>` : t.expires && t.expires < real ? html`<span class="status stopped">Expired</span>` : html`<${Presence} online=${true} label="Active" />` },
+          { key: "act", label: "", sortable: false, render: (t) => html`<${Revoke} t=${t} />` },
+        ]} />`}
+      ${made ? html`<div class="made-token" role="status">
+          <div><b>Token created.</b> <span class="sec">Copy it now: it is shown once and the server keeps only a hash.</span></div>
+          <${Command} cmd=${made} />
+          <div class="field-label" style="margin-top:10px">Log in from a terminal</div>
+          <${Command} cmd=${`posttrain login --url ${shq(url)} --token ${made}`} />
+          <div class="row" style="margin-top:10px">
+            ${getToken() === made ? html`<span class="small sec">This browser uses it.</span>` : html`<button class="btn small" onClick=${() => setToken(made)}>Use it in this browser</button>`}
+            <span class="grow"></span><button class="btn small ghost" onClick=${() => setMade(null)}>Done</button></div>
+        </div>` : html`
+        <form class="form inline-form" onSubmit=${(e) => { e.preventDefault(); submit(); }}>
+          <h4>Create a token</h4>
+          <p class="dialog-purpose" style="margin:0 0 10px">Lets a machine or a person write to every project in this workspace.</p>
+          <div class="form-grid">
+            <${Field} label="Name" help="Where it will be used, so you can tell tokens apart."><input class="input" value=${name} placeholder="laptop" onInput=${(e) => setName(e.target.value)} /><//>
+            <${Field} label="User" help="Runs and projects record this name as their owner."><input class="input" value=${user} placeholder="admin" onInput=${(e) => setUser(e.target.value)} /><//>
+          </div>
+          <label class="check small"><input type="checkbox" checked=${forever} onChange=${(e) => setForever(e.target.checked)} />Never expires <span class="muted">(otherwise it lasts 90 days)</span></label>
+          <p class="consequence">Anyone holding the token can do what its user can in every project here, until it ${forever ? "is revoked" : "expires or is revoked"}.</p>
+          <${SubmitProblem} state=${state} onRetry=${submit.retry} />
+          <div class="form-actions"><button type="submit" class="btn primary" disabled=${state.busy}>${state.busy ? "Creating…" : "Create token"}</button></div>
+        </form>`}
+      <div class="small muted" style="margin-top:12px">On the server machine: <code>posttrain token create --name laptop</code>.</div>
+    </div></div>`;
+}
+
+function Browser({ ctx }) {
+  const who = useApi("/whoami", { source: "" });
+  const tok = getToken();
+  const [editing, setEditing] = useState(false);
+  return html`<div class="panel"><div class="panel-head"><h3>This browser</h3></div>
+    <div class="list-rows">
+      <div class="setting-row"><div><b>Server</b><div class="small sec">${ctx.open
+        ? "Open: it takes changes from this machine without a token (a single-user local server)."
+        : "Changes need an API token; reading projects doesn't."}</div></div>
+        <div class="small right-col">${who.data ? html`signed in as <b>${who.data.user.name}</b>` : who.error && who.error.status === 401 ? html`<span class="muted">not signed in</span>` : null}</div></div>
+      <div class="setting-row"><div><b>Token</b><div class="small sec">Sent with every change this browser makes. It stays in this browser's storage.</div></div>
+        <div class="small right-col">${tok ? html`<span class="mono">${tok.slice(0, 9)}…</span>` : html`<span class="muted">none</span>`}</div></div>
+    </div>
+    <div class="panel-body" style="padding-top:4px">
+      ${editing ? html`<${TokenPrompt} reason="Use a token in this browser." onSaved=${() => setEditing(false)} />` : html`<div class="row">
+        <button class="btn small" onClick=${() => setEditing(true)}><${Icon} name="key" size=${13} />${tok ? "Use another token" : "Use a token"}</button>
+        ${tok ? html`<button class="btn small ghost" onClick=${() => setToken("")}>Forget it</button>` : null}</div>`}
+    </div></div>`;
+}
+
+export function Settings({ ctx }) {
+  return html`
+    <div class="page-head"><div class="grow"><h1>Settings</h1></div></div>
+    <div class="stack settings">
+      <${Sources} ctx=${ctx} />
+      ${ctx.meta && ctx.meta.readonly ? null : html`<${Tokens} ctx=${ctx} /><${Browser} ctx=${ctx} />`}
+    </div>`;
+}
diff --git a/viewer/static/pages/stages.js b/viewer/static/pages/stages.js
new file mode 100644
index 0000000000000000000000000000000000000000..b185324a1e109a6f03d32db2cb6e6840e4476de0
--- /dev/null
+++ b/viewer/static/pages/stages.js
@@ -0,0 +1,173 @@
+// Where a workspace project stands on data → environments → SFT → preference → RL → eval → deploy,
+// with the next step of each stage as a button and as the CLI line that does the same.
+import { html, useState, setQuery, navigate, shq, slugify } from "../lib.js";
+import { Icon, ProjectLink, Status } from "../ui/common.js";
+import { Command, Dialog, Field } from "../ui/forms.js";
+import * as f from "../ui/fmt.js";
+
+export const STAGE = {
+  data: { label: "Data", done: "Every dataset a planned stage needs is ready, and the quick and release suites exist." },
+  environments: { label: "Environments", done: "Every environment planned for RL is ready." },
+  sft: { label: "SFT", done: "A model promoted from an SFT run has a quick eval." },
+  preference: { label: "Preference", done: "A model promoted from a preference run has a quick eval." },
+  rl: { label: "RL", done: "A model promoted from an RL run has a quick eval." },
+  eval: { label: "Eval", done: "A promoted model has a complete release eval, compared with the baseline and the production model, and every regression beyond noise is acknowledged." },
+  deploy: { label: "Deploy", done: "The model is served and passes its smoke test (or is pushed to the Hub), and production points at it." },
+};
+// until promotion, suites and acknowledgements exist, the server counts these instead
+const APPROX = {
+  sft: "For now: the model an SFT run produced, with any completed eval.", preference: "For now: the model a preference run produced, with any completed eval.",
+  rl: "For now: the model an RL run produced, with any completed eval.", eval: "For now: a trained model and the model it started from, both evaluated on a common benchmark.",
+  data: "For now: the project has a dataset.",
+};
+const STATE_LABEL = { done: "Done", in_progress: "In progress", not_started: "Not started", skipped: "Skipped", blocked: "Blocked" };
+const STATE_ICON = {
+  done: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="6" fill="currentColor" opacity=".14"/><path d="M4.2 7.2l1.9 1.9 3.8-4" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"/></svg>`,
+  in_progress: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="5.5" fill="none" stroke="currentColor" stroke-width="1.5" opacity=".3"/><path d="M7 1.5a5.5 5.5 0 0 1 5.5 5.5" fill="none" stroke="currentColor" stroke-width="1.5"><animateTransform attributeName="transform" type="rotate" from="0 7 7" to="360 7 7" dur="1.4s" repeatCount="indefinite"/></path></svg>`,
+  not_started: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="5.2" fill="none" stroke="currentColor" stroke-width="1.5"/></svg>`,
+  skipped: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="5.2" fill="none" stroke="currentColor" stroke-width="1.4" stroke-dasharray="2 1.8"/><path d="M4.6 7h4.4M7.6 5.2 9.4 7 7.6 8.8" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round"/></svg>`,
+  blocked: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="6" fill="currentColor" opacity=".16"/><path d="M4.3 9.7l5.4-5.4" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/></svg>`,
+};
+export function StageState({ state }) {
+  return html`<span class=${`stage-state ${state}`}>${STATE_ICON[state]}${STATE_LABEL[state] || state}</span>`;
+}
+
+function Obj({ ctx, o }) {
+  if (o.type === "dataset") return html`<span class="obj"><${ProjectLink} ctx=${ctx} to=${`/datasets/${o.id}`}>${o.name}</${ProjectLink}>
+    <span class="muted">${o.kind || "dataset"}${o.rows ? ` · ${f.int(o.rows)} rows` : ""}</span></span>`;
+  if (o.type === "environment") return html`<span class="obj"><${ProjectLink} ctx=${ctx} to=${`/environments/${o.id}`}>${o.name}</${ProjectLink}>
+    <span class=${o.ready ? "muted" : "warn-ink"}>${o.ready ? `ready (${f.int(o.usable)} usable tasks, ${f.int(o.learnable)} learnable)` : o.reason}</span></span>`;
+  if (o.type === "run") {
+    if (o.status === "completed" && o.output_model) return html`<span class="obj"><span>${o.output_model}, from <${ProjectLink} ctx=${ctx} to=${`/runs/${o.id}`}>${o.name}</${ProjectLink}></span>
+      ${o.evaluated ? null : html`<span class="muted">no eval yet</span>`}</span>`;
+    return html`<span class="obj"><${ProjectLink} ctx=${ctx} to=${`/runs/${o.id}`}>${o.name}</${ProjectLink}>
+      <${Status} status=${o.status} reason=${o.reason} />${o.status === "running" && o.steps_planned ? html`<span class="muted">step ${f.int(o.steps_done)} of ${f.int(o.steps_planned)}</span>` : null}
+      ${o.status === "failed" && o.reason ? html`<span class="muted ellipsis" style="max-width:260px" title=${o.reason}>${o.reason}</span>` : null}</span>`;
+  }
+  if (o.type === "eval") return html`<span class="obj"><${ProjectLink} ctx=${ctx} to=${`/evals/${o.id}`}>${o.name}</${ProjectLink}>
+    ${o.status === "completed" ? html`<span><b>${f.score(o.metric, o.score)}</b> <span class="muted">${f.scoreErr(o.metric, o.stderr)}${o.model ? ` · ${o.model}` : ""}</span></span>`
+      : html`<${Status} status=${o.status} />`}</span>`;
+  if (o.type === "deployment") return html`<span class="obj"><b>${o.name}</b> <span class="muted">${o.status || ""}${o.model ? ` · ${o.model}` : ""}</span></span>`;
+  return null;
+}
+
+/** Where a Next button goes: a dialog, the launch form, a run, an environment's validation, a page. */
+function go(ctx, n) {
+  if (n.kind === "add") return () => setQuery({ add: n.arg }, { replace: false });
+  if (n.kind === "launch") return () => navigate(`${ctx.base}/runs/new?stage=${n.arg}`);
+  if (n.kind === "eval") return () => navigate(`${ctx.base}/runs/new?stage=eval${n.arg ? `&model=${encodeURIComponent(n.arg)}` : ""}`);
+  if (n.kind === "run") return () => navigate(`${ctx.base}/runs/${n.arg}`);
+  if (n.kind === "env") return () => navigate(`${ctx.base}/environments/${n.arg}?tab=validation`);
+  return () => navigate(ctx.base + n.arg);
+}
+
+function Next({ ctx, n, primary }) {
+  if (!n) return html`<span class="muted">—</span>`;
+  return html`<div class="stage-action">
+    ${n.needs ? html`<span class="sec small">${n.needs[0].toUpperCase() + n.needs.slice(1)}</span>` : null}
+    ${n.label ? html`<button class=${`btn small ${primary ? "primary" : ""}`} onClick=${go(ctx, n)}>${n.label}</button>` : null}
+    ${n.cli ? html`<${Command} cmd=${n.cli} compact=${true} />` : null}
+  </div>`;
+}
+
+export function Stages({ ctx, data, title = "Stages" }) {
+  const waiting = new Map();
+  for (const w of data.waiting || []) {
+    if (!waiting.has(w.target)) waiting.set(w.target, []);
+    waiting.get(w.target).push(w);
+  }
+  return html`<div class="section">
+    <div class="section-head"><h2>${title}</h2><span class="muted small">a checklist, not a wizard: any stage can be skipped; each next step works here or from a terminal</span></div>
+    ${[...waiting.entries()].map(([target, ws]) => html`<div class="stage-notice">
+        <span class="lvl warn">${html`<svg viewBox="0 0 14 14"><path d="M7 1.8 12.8 12H1.2L7 1.8Z" fill="currentColor" opacity=".16"/><path d="M7 5.5v3M7 10.2v.1" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/></svg>`}</span>
+        <div class="grow"><div>${ws.map((w, i) => html`${i ? ", " : ""}<${ProjectLink} ctx=${ctx} to=${`/runs/${w.run_id}`}>${w.run_name}</${ProjectLink}>`)}
+          ${ws.length === 1 ? " waits" : " wait"} in the queue: no runner is online for <b>${target}</b>. Start one on a machine that can reach it:</div>
+          <div style="margin-top:6px;max-width:560px"><${Command} cmd=${`posttrain agent --targets ${shq(target)}`} compact=${true} /></div></div>
+      </div>`)}
+    <div class="panel stages-box"><table class="t stages-table">
+      <thead><tr><th style="width:24%">Stage</th><th style="width:118px">Status</th><th>Now</th><th style="width:34%">Next</th></tr></thead>
+      <tbody>${data.stages.map((s) => {
+        const d = STAGE[s.key];
+        const next = data.next === s.key;
+        return html`<tr class=${next ? "next" : ""}>
+          <td><b>${d.label}</b>${next ? html` <span class="tag next-tag">Next</span>` : null}<span class="sub" title=${APPROX[s.key] || ""}>${d.done}</span></td>
+          <td><${StageState} state=${s.status} /></td>
+          <td class=${s.objects.length || s.status === "skipped" ? "" : "no-now"}>${s.objects.length ? html`<div class="objs">${s.objects.map((o) => html`<${Obj} ctx=${ctx} o=${o} />`)}
+              ${s.total > s.objects.length ? html`<span class="muted small">+${f.int(s.total - s.objects.length)} more</span>` : null}</div>`
+            : s.status === "skipped" ? html`<span class="muted small">skipped: a later stage went ahead without it</span>` : html`<span class="muted">—</span>`}</td>
+          <td class=${s.next ? "" : "no-next"}><${Next} ctx=${ctx} n=${s.next} primary=${next} /></td>
+        </tr>`;
+      })}</tbody></table>
+    <div class="stage-foot small">
+      <span class="muted">Runs launched here execute on</span>
+      ${data.compute.map((t, i) => html`${i ? html`<span class="muted">·</span>` : null}<span class="nowrap"><b>${t.name}</b>${" "}<span class="muted">${t.runners.length ? `${t.runners.join(", ")} online` : "no runner online"}</span></span>`)}
+      <span class="grow"></span><${ProjectLink} ctx=${ctx} to="/compute">Compute</${ProjectLink}>
+    </div></div></div>`;
+}
+
+/** For a project with nothing in it yet: connect a terminal and compute, next to the stages table. */
+export function FirstRun({ ctx, data }) {
+  const name = ctx.info ? ctx.info.name : ctx.project;
+  const initName = slugify(name) === ctx.project ? name : ctx.project;
+  const served = data.compute.filter((t) => t.runners.length);
+  return html`<div class="section">
+    <div class="section-head"><h2>Connect</h2><span class="muted small">so the CLI can write here, and runs launched here have somewhere to run</span></div>
+    <div class="panel firstrun">
+      <div class="fr-step"><span class="fr-num">1</span>
+        <div class="fr-body"><div><b>A terminal</b> <span class="muted small">(optional)</span></div>
+          <div class="small sec" style="margin-top:2px">Lets the CLI, the SDK and your trainers write to this project. Run init in your repository: it writes posttrain.toml so later commands know the project.</div>
+          <div class="fr-cmds"><${Command} cmd=${`posttrain login --url ${shq(location.origin)}${ctx.open ? "" : " --token <token>"}`} compact=${true} />
+            <${Command} cmd=${`posttrain init --org ${shq(ctx.org)} --name ${shq(initName)}`} compact=${true} /></div></div>
+        <div class="fr-actions">${ctx.open ? null : html`<button class="btn small" onClick=${() => navigate(`${ctx.base}/settings`)}>Create a token</button>`}</div></div>
+      <div class="fr-step"><span class=${`fr-num ${served.length ? "done" : ""}`}>${served.length ? STATE_ICON.done : "2"}</span>
+        <div class="fr-body"><div><b>Compute</b></div>
+          <div class="small sec" style="margin-top:2px">${served.length
+            ? html`${served.map((t, i) => html`${i ? ", " : ""}<b>${t.name}</b>`)} ${served.length === 1 ? "has" : "have"} a runner online, so runs launched here start right away.`
+            : "Runs launched here wait for a runner: posttrain agent, started on a machine with GPUs or with access to your cluster. Serving local means running jobs on that machine itself."}</div>
+          <div class="fr-cmds"><${Command} cmd="posttrain agent --targets local" compact=${true} /></div></div>
+        <div class="fr-actions"><button class="btn small" onClick=${() => navigate(`${ctx.base}/compute`)}>Set up compute</button></div></div>
+    </div></div>`;
+}
+
+// ------------------------------------------------------------------ add a dataset or an environment
+const DATA_KINDS = [["sft", "SFT conversations"], ["preference", "Preference pairs"], ["rl", "RL prompts"], ["eval", "Eval set"]];
+
+/** Builds the CLI line that adds a dataset or an environment; the files never pass through the browser. */
+export function AddInputDialog({ kind, count, latest, ctx, onClose }) {
+  const [start] = useState(count);
+  const [src, setSrc] = useState("");
+  const [dkind, setDkind] = useState("sft");
+  const [name, setName] = useState("");
+  const [domain, setDomain] = useState("");
+  const [check, setCheck] = useState(false);
+  const isData = kind === "dataset";
+  const arrived = count > start && latest;
+  // The command names this server and project, so it works on a machine that never ran `posttrain init` here
+  const where = ` --project ${ctx.org}/${ctx.project} --url ${location.origin}`;
+  const cmd = isData
+    ? `posttrain data add ${shq(src || (dkind === "preference" ? "pairs.jsonl" : dkind === "rl" ? "prompts.jsonl" : "train.jsonl"))} --kind ${dkind}${name.trim() ? ` --name ${shq(name.trim())}` : ""}${where}`
+    : `posttrain env add ${shq(src || "./my-env")}${name.trim() ? ` --name ${shq(name.trim())}` : ""}${domain.trim() ? ` --domain ${shq(domain.trim())}` : ""}${check ? " --check" : ""}${where}`;
+  return html`<${Dialog} title=${isData ? "Add a dataset" : "Add an environment"} onClose=${onClose}
+      purpose=${isData ? "Datasets are read where they live: the CLI checks the file and uploads a summary with up to 200 sample rows. The file itself stays with you."
+        : "An environment is a set of tasks plus the grader that turns an attempt into a reward. The CLI loads it from a directory and uploads its tasks and grader."}>
+    <div class="form">
+      <${Field} label=${isData ? "File or dataset" : "Directory"} help=${isData ? html`A .jsonl or .parquet file, a directory, or <span class="mono">hf://org/name:split</span> for a Hugging Face dataset.`
+          : html`A directory with <span class="mono">env.toml</span> and its tasks, or a <span class="mono">tasks.jsonl</span>.`}>
+        <input class="input mono" value=${src} placeholder=${isData ? "data/train.jsonl" : "./envs/math"} spellcheck="false" onInput=${(e) => setSrc(e.target.value)} />
+      <//>
+      <div class="form-grid">
+        ${isData ? html`<${Field} label="Kind" help="What the rows hold; it decides which checks run and which runs can use it.">
+            <select class="input" value=${dkind} onChange=${(e) => setDkind(e.target.value)}>${DATA_KINDS.map(([k, l]) => html`<option value=${k}>${l}</option>`)}</select><//>`
+          : html`<${Field} label="Domain" optional=${true} help="math, code, agent, …; groups environments in lists."><input class="input" value=${domain} placeholder="math" onInput=${(e) => setDomain(e.target.value)} /><//>`}
+        <${Field} label="Name" optional=${true} help="Defaults to the file or directory name."><input class="input" value=${name} onInput=${(e) => setName(e.target.value)} /><//>
+      </div>
+      ${isData ? null : html`<label class="check"><input type="checkbox" checked=${check} onChange=${(e) => setCheck(e.target.checked)} />
+        <span>Run the oracle and no-op checks <span class="muted">(needs the tasks' commands to run on that machine)</span></span></label>`}
+      <div class="field wide"><span class="field-label">Run this where the ${isData ? "file is" : "directory is"}</span><${Command} cmd=${cmd} />
+        <span class="help">No <span class="mono">posttrain</span> yet? <span class="mono">pip install posttrain</span> (or from the repo), and if this server asks for tokens, <span class="mono">posttrain login --url ${location.origin}</span> with a token from Settings → API tokens.</span></div>
+      ${arrived ? html`<div class="notice good" role="status"><b>${latest.name}</b> arrived in this project.</div>`
+        : html`<p class="consequence">It prints what the checks found and uploads only if nothing fails. This page picks the ${isData ? "dataset" : "environment"} up by itself.</p>`}
+      <div class="form-actions"><button class="btn primary" onClick=${onClose}>${arrived ? "Done" : "Close"}</button></div>
+    </div>
+  <//>`;
+}
diff --git a/viewer/static/pages/task.js b/viewer/static/pages/task.js
new file mode 100644
index 0000000000000000000000000000000000000000..91c286957476df8e1fc286d77e6dc1b16d2583aa
--- /dev/null
+++ b/viewer/static/pages/task.js
@@ -0,0 +1,35 @@
+import { html, useApi, setQuery, setRolloutOrder } from "../lib.js";
+import { Loading, Err, ProjectLink, Facts, Attempts, Level } from "../ui/common.js";
+import { passLine } from "./runs.js";
+import * as f from "../ui/fmt.js";
+
+const STATUS_LABEL = { ok: "OK", flaky: "Flaky", invalid: "Invalid", leaky: "Leaky", hackable: "Hackable", too_easy: "Too easy", too_hard: "Too hard", excluded: "Excluded" };
+
+export function Task({ ctx, id }) {
+  const { data, error } = useApi(`/p/${ctx.org}/${ctx.project}/tasks/${id}`);
+  if (error) return html`<${Err} error=${error} />`;
+  if (!data) return html`<${Loading} />`;
+  const t = data.task, e = data.environment;
+  const current = ctx.query.get("rollout");
+  setRolloutOrder(data.groups.flatMap((g) => g.attempts.map((a) => a.id)));
+  return html`
+    <div class="page-head"><div class="grow">
+      <div class="crumb-line"><${ProjectLink} ctx=${ctx} to="/environments">Environments</${ProjectLink}> / <${ProjectLink} ctx=${ctx} to=${`/environments/${e.id}?tab=tasks`}>${e.name}</${ProjectLink}></div>
+      <div class="row wrap" style="gap:12px"><h1 class="mono" style="font-size:19px">${t.name}</h1>
+        ${t.status === "ok" ? html`<${Level} level="ok" label="Valid" />` : html`<${Level} level="warn" label=${STATUS_LABEL[t.status] || t.status} />`}</div>
+      ${t.status_reason ? html`<p class="lede small">${t.status_reason}</p>` : null}
+      <div class="panel" style="margin-top:12px"><div class="panel-body" style="white-space:pre-wrap">${t.instruction || html`<span class="muted">No instruction stored.</span>`}</div></div>
+      <div style="margin-top:10px"><${Facts} items=${[["pass rate, base model", f.pct(t.base_pass, 0)], ["latest policy", f.pct(t.latest_pass, 0)],
+        ["oracle score", f.num(t.oracle_score, 2)], ["no-op score", f.num(t.noop_score, 2)], ["rerun agreement", `${f.pct(t.rerun_agree, 0)} of ${t.reruns}`],
+        data.grader ? ["grader", data.grader.name] : null]} /></div>
+    </div></div>
+    <div class="section"><div class="section-head"><h2>Every stored attempt at this task</h2><span class="muted small">${data.groups.length} groups</span></div>
+      ${data.groups.length === 0 ? html`<div class="empty panel">No stored attempts. Large runs keep a sample of groups per step.</div>` : html`
+      <div class="table-wrap"><table class="t dense"><thead><tr><th>Where</th><th>Step</th><th>Attempts</th><th class="num">Result</th></tr></thead>
+        <tbody>${data.groups.map((g) => html`<tr>
+          <td>${g.run_id ? html`<${ProjectLink} ctx=${ctx} to=${`/runs/${g.run_id}`}>${g.run_name}</${ProjectLink}>` : g.eval_id ? html`<${ProjectLink} ctx=${ctx} to=${`/evals/${g.eval_id}`}>eval</${ProjectLink}>` : "—"}<span class="sub">${g.phase}</span></td>
+          <td class="mono">${g.step ?? "—"}</td>
+          <td><${Attempts} attempts=${g.attempts} kind=${e.reward_kind} current=${current} onPick=${(a) => setQuery({ rollout: a.id })} /></td>
+          <td class="num small">${passLine(g.attempts, e.reward_kind)}</td></tr>`)}</tbody></table></div>`}
+    </div>`;
+}
diff --git a/viewer/static/style.css b/viewer/static/style.css
new file mode 100644
index 0000000000000000000000000000000000000000..8ba94cd73b9f59e43ae8621672151f590aa1604d
--- /dev/null
+++ b/viewer/static/style.css
@@ -0,0 +1,636 @@
+@font-face {
+  font-family: "Inter";
+  src: url("/dashboard/static/vendor/InterVariable.woff2") format("woff2");
+  font-weight: 100 900;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Instrument Serif";
+  src: url("/dashboard/static/vendor/InstrumentSerif-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Instrument Serif";
+  src: url("/dashboard/static/vendor/InstrumentSerif-Italic.woff2") format("woff2");
+  font-weight: 400;
+  font-style: italic;
+  font-display: swap;
+}
+
+:root {
+  color-scheme: light;
+  /* PostTrain brand (posttrain.com, web/.impeccable.md): white paper, near-black ink, one electric
+     blue, hairlines over fills, square panels. Status colors and the series palette stay functional. */
+  --page: #ffffff;
+  --surface: #ffffff;
+  --surface-2: #f4f5f6;
+  --surface-3: #e9ecee;
+  --hover: #f1f3f4;
+  --ink: #080808;
+  --ink-2: #5b666b;
+  --ink-3: #778388;
+  --line: #dfe3e4;
+  --line-2: #c9cfd1;
+  --blue: #0006fc;
+  --blue-wash: #e6e7ff;
+  --link: var(--blue);
+  --focus: var(--blue);
+  --grid: #eceff0;
+  --axis: #b9c1c4;
+  /* categorical series, fixed order (validated reference palette; slot 1 is the brand blue) */
+  --s1: #0006fc; --s2: #eb6834; --s3: #1baf7a; --s4: #eda100;
+  --s5: #e87ba4; --s6: #008300; --s7: #4a3aa7; --s8: #e34948;
+  --train: var(--s1);
+  --eval: var(--ink);
+  /* status, never used for series */
+  --good: #0ca30c; --good-ink: #006300; --good-bg: #eaf6ea;
+  --warn: #fab219; --warn-ink: #8a5a00; --warn-bg: #fdf4e0;
+  --serious: #ec835a; --serious-ink: #9a3f16; --serious-bg: #fcede6;
+  --bad: #d03b3b; --bad-ink: #a12626; --bad-bg: #fbeaea;
+  --info-bg: var(--blue-wash); --info-ink: #0003f9;
+  --mono: ui-monospace, "SF Mono", SFMono-Regular, Menlo, Consolas, monospace;
+  --sans: "Inter", system-ui, -apple-system, "Segoe UI", sans-serif;
+  --display: "Instrument Serif", Georgia, serif;
+  --r: 2px;
+  --r-lg: 0px;
+  --sidebar: 224px;
+  --topbar: 48px;
+}
+
+* { box-sizing: border-box; }
+html, body { margin: 0; height: 100%; }
+body {
+  font-family: var(--sans);
+  font-size: 13.5px;
+  line-height: 1.45;
+  color: var(--ink);
+  background: var(--page);
+  -webkit-font-smoothing: antialiased;
+  font-feature-settings: "cv11", "ss01";
+}
+a { color: var(--link); text-decoration: none; }
+a:hover { text-decoration: underline; }
+button, input, select, textarea { font: inherit; color: inherit; }
+code, .mono { font-family: var(--mono); font-size: 0.92em; }
+.num, td.num, th.num { font-variant-numeric: tabular-nums; text-align: right; }
+.muted { color: var(--ink-3); }
+.sec { color: var(--ink-2); }
+.small { font-size: 12px; }
+.nowrap { white-space: nowrap; }
+.ellipsis { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+h1, h2, h3, h4 { margin: 0; font-weight: 600; letter-spacing: -0.01em; }
+h1 { font-family: var(--display); font-weight: 400; font-size: 32px; line-height: 1.1; letter-spacing: -0.005em; }
+h2 { font-size: 15px; }
+h3 { font-size: 13.5px; }
+:focus-visible { outline: 2px solid var(--focus); outline-offset: 1px; border-radius: 3px; }
+
+/* ---------------------------------------------------------------- shell */
+.topbar {
+  position: fixed; inset: 0 0 auto 0; height: var(--topbar); z-index: 30;
+  display: flex; align-items: center; gap: 12px; padding: 0 14px;
+  background: var(--surface); border-bottom: 1px solid var(--line);
+}
+.brand { display: flex; align-items: center; gap: 9px; color: var(--ink); width: calc(var(--sidebar) - 14px); }
+.brand:hover { text-decoration: none; }
+.brand-mark { width: 20px; height: 20px; display: block; flex: none; }
+.brand-name { font-size: 13px; font-weight: 500; text-transform: uppercase; letter-spacing: .06em; }
+.crumbs { display: flex; align-items: center; gap: 6px; min-width: 0; }
+.crumbs .sep { color: var(--line-2); }
+.switcher { position: relative; }
+.switcher > button {
+  display: flex; align-items: center; gap: 6px; height: 30px; padding: 0 8px; border: 1px solid transparent;
+  background: none; border-radius: var(--r); cursor: pointer; font-weight: 550;
+}
+.switcher > button:hover { background: var(--hover); }
+.switcher .caret { color: var(--ink-3); font-size: 10px; }
+.menu {
+  position: absolute; top: 34px; left: 0; min-width: 300px; max-height: 70vh; overflow: auto; z-index: 40;
+  background: var(--surface); border: 1px solid var(--line); border-radius: var(--r-lg);
+  box-shadow: 0 8px 28px rgba(0,0,0,.10), 0 1px 3px rgba(0,0,0,.06); padding: 6px;
+}
+.menu .group-label { padding: 8px 8px 4px; font-size: 11px; color: var(--ink-3); font-weight: 600; text-transform: uppercase; letter-spacing: .04em; }
+.menu a, .menu button.item {
+  display: flex; flex-direction: column; gap: 1px; width: 100%; text-align: left; padding: 7px 8px; border-radius: var(--r);
+  color: var(--ink); background: none; border: 0; cursor: pointer;
+}
+.menu a:hover, .menu button.item:hover, .menu .active { background: var(--hover); text-decoration: none; }
+.menu .item-sub { color: var(--ink-3); font-size: 12px; }
+.topbar .spacer { flex: 1; }
+.search-btn {
+  display: flex; align-items: center; gap: 8px; height: 30px; width: 300px; padding: 0 10px;
+  border: 1px solid var(--line); border-radius: var(--r); background: var(--surface-2); color: var(--ink-3); cursor: text;
+}
+.search-btn kbd, kbd { font-family: var(--sans); font-size: 11px; border: 1px solid var(--line); border-bottom-width: 2px; border-radius: 4px; padding: 0 4px; color: var(--ink-3); background: var(--surface); }
+.search-btn kbd { margin-left: auto; }
+.source-pill { display: inline-flex; align-items: center; gap: 6px; height: 26px; padding: 0 9px; border-radius: 13px; border: 1px solid var(--line); color: var(--ink-2); font-size: 12px; }
+.source-pill:hover { background: var(--hover); text-decoration: none; }
+.source-pill .dot { width: 7px; height: 7px; border-radius: 50%; background: var(--s4); }
+.source-pill.live .dot { background: var(--good); }
+
+.sidebar {
+  position: fixed; top: var(--topbar); bottom: 0; left: 0; width: var(--sidebar); z-index: 20;
+  background: var(--page); border-right: 1px solid var(--line); padding: 12px 10px; overflow: auto;
+  display: flex; flex-direction: column;
+}
+.nav-group { margin-bottom: 14px; }
+.nav-label { font-size: 11px; font-weight: 600; color: var(--ink-3); padding: 0 8px 4px; text-transform: uppercase; letter-spacing: .04em; }
+.nav a {
+  display: flex; align-items: center; gap: 9px; height: 30px; padding: 0 8px; border-radius: var(--r);
+  color: var(--ink-2); font-weight: 500;
+}
+.nav a:hover { background: var(--hover); color: var(--ink); text-decoration: none; }
+.nav a.on { background: var(--surface-2); color: var(--ink); }
+.nav a.on svg { stroke: var(--blue); }
+.nav a .count { margin-left: auto; font-size: 11.5px; color: var(--ink-3); font-variant-numeric: tabular-nums; }
+.nav svg { width: 16px; height: 16px; flex: none; stroke: currentColor; fill: none; stroke-width: 1.6; stroke-linecap: round; stroke-linejoin: round; }
+.sidebar .foot { margin-top: auto; font-size: 12px; color: var(--ink-3); padding: 8px; }
+
+.main { margin-left: var(--sidebar); padding: calc(var(--topbar) + 20px) 32px 64px; min-height: 100vh; }
+.main.with-drawer { margin-right: min(46vw, 760px); }
+.page-head { display: flex; align-items: flex-start; gap: 16px; margin-bottom: 18px; }
+.page-head .grow { flex: 1; min-width: 0; }
+.crumb-line { font-size: 12.5px; color: var(--ink-3); margin-bottom: 6px; }
+.crumb-line a { color: var(--ink-3); }
+.lede { color: var(--ink-2); margin-top: 6px; max-width: 980px; }
+
+/* ---------------------------------------------------------------- building blocks */
+.panel { background: var(--surface); border: 1px solid var(--line); border-radius: var(--r-lg); }
+.panel-head { display: flex; align-items: center; gap: 10px; padding: 12px 14px; border-bottom: 1px solid var(--line); }
+.panel-head h2, .panel-head h3 { font-size: 13.5px; }
+.panel-head .grow { flex: 1; }
+.panel-body { padding: 14px; }
+.section { margin-top: 22px; }
+.section > .section-head { display: flex; align-items: baseline; gap: 12px; margin-bottom: 10px; }
+.section > .section-head h2 { font-size: 14.5px; }
+.section > .section-head .grow { flex: 1; }
+.grid { display: grid; gap: 14px; }
+.cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+.cols-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
+.cols-4 { grid-template-columns: repeat(4, minmax(0, 1fr)); }
+@media (max-width: 1280px) { .cols-4 { grid-template-columns: repeat(3, minmax(0, 1fr)); } }
+@media (max-width: 1100px) { .cols-3, .cols-4 { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
+
+.facts { display: flex; flex-wrap: wrap; gap: 4px 18px; font-size: 13px; color: var(--ink-2); }
+.facts .f { white-space: nowrap; }
+.facts .f b { color: var(--ink); font-weight: 550; margin-left: 4px; }
+.facts .f .k { color: var(--ink-3); }
+
+.btn {
+  display: inline-flex; align-items: center; gap: 6px; height: 30px; padding: 0 11px; border-radius: var(--r);
+  border: 1px solid var(--line-2); background: var(--surface); cursor: pointer; font-weight: 500; white-space: nowrap; color: var(--ink);
+}
+.btn:hover { background: var(--hover); text-decoration: none; }
+.btn.primary { background: var(--ink); color: #fff; border-color: var(--ink); }
+.btn.primary:hover { background: var(--blue); border-color: var(--blue); }
+.btn.ghost { border-color: transparent; background: none; }
+.btn.small { height: 26px; padding: 0 8px; font-size: 12.5px; }
+.btn[disabled] { opacity: .45; cursor: default; }
+.icon-btn { width: 28px; height: 28px; display: inline-grid; place-items: center; border-radius: var(--r); border: 1px solid transparent; background: none; cursor: pointer; color: var(--ink-2); }
+.icon-btn:hover { background: var(--hover); color: var(--ink); }
+.icon-btn[disabled] { opacity: .35; cursor: default; background: none; }
+.icon-btn svg { width: 16px; height: 16px; stroke: currentColor; fill: none; stroke-width: 1.7; stroke-linecap: round; stroke-linejoin: round; }
+
+.tabs { display: flex; gap: 2px; border-bottom: 1px solid var(--line); margin: 18px 0 16px; }
+.tabs a { padding: 8px 12px; color: var(--ink-2); font-weight: 500; border-bottom: 2px solid transparent; margin-bottom: -1px; }
+.tabs a:hover { color: var(--ink); text-decoration: none; }
+.tabs a.on { color: var(--ink); border-bottom-color: var(--ink); }
+.tabs a .count { color: var(--ink-3); font-size: 12px; margin-left: 4px; }
+
+.seg { display: inline-flex; border: 1px solid var(--line-2); border-radius: var(--r); overflow: hidden; }
+.seg button { border: 0; background: var(--surface); padding: 0 10px; height: 28px; cursor: pointer; color: var(--ink-2); font-size: 12.5px; }
+.seg button + button { border-left: 1px solid var(--line); }
+.seg button.on { background: var(--surface-3); color: var(--ink); font-weight: 550; }
+
+.filters { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin-bottom: 12px; }
+.input, select.input {
+  height: 30px; padding: 0 10px; border: 1px solid var(--line-2); border-radius: var(--r); background: var(--surface); min-width: 0;
+}
+.input.search { width: 280px; padding-left: 30px; background: var(--surface) url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='14' height='14' viewBox='0 0 24 24' fill='none' stroke='%23898781' stroke-width='2' stroke-linecap='round'%3E%3Ccircle cx='11' cy='11' r='7'/%3E%3Cpath d='m20 20-3.5-3.5'/%3E%3C/svg%3E") no-repeat 9px center; }
+.chip { display: inline-flex; align-items: center; gap: 5px; height: 22px; padding: 0 8px; border-radius: 11px; font-size: 12px; background: var(--surface-3); color: var(--ink-2); white-space: nowrap; }
+.chip.outline { background: none; border: 1px solid var(--line-2); }
+.chip.info { background: var(--info-bg); color: var(--info-ink); }
+.tag { display: inline-block; font-size: 11.5px; padding: 1px 6px; border-radius: 4px; background: var(--surface-3); color: var(--ink-2); white-space: nowrap; }
+
+/* status and outcomes: icon + label, never color alone */
+.status { display: inline-flex; align-items: center; gap: 6px; white-space: nowrap; font-weight: 500; }
+.status svg { width: 14px; height: 14px; flex: none; }
+.status.running { color: var(--info-ink); }
+.status.completed { color: var(--good-ink); }
+.status.failed { color: var(--bad-ink); }
+.status.stopped, .status.queued { color: var(--ink-2); }
+.lvl { display: inline-flex; align-items: center; gap: 6px; font-weight: 550; white-space: nowrap; }
+.lvl svg { width: 14px; height: 14px; }
+.lvl.ok { color: var(--good-ink); }
+.lvl.warn { color: var(--warn-ink); }
+.lvl.bad { color: var(--bad-ink); }
+.oc { display: inline-flex; align-items: center; gap: 5px; white-space: nowrap; }
+.oc i { width: 8px; height: 8px; border-radius: 2px; display: inline-block; flex: none; }
+.oc.passed i { background: var(--good); }
+.oc.failed i { background: var(--bad); }
+.oc.partial i { background: var(--warn); }
+.oc.timeout i, .oc.truncated i, .oc.max_turns i { background: var(--serious); }
+.oc.infra_error i { background: transparent; border: 1.5px dashed var(--ink-3); width: 8px; height: 8px; }
+.oc.scored i { background: color-mix(in oklab, var(--link) 45%, var(--surface-3)); }
+
+/* ---------------------------------------------------------------- tables */
+.table-wrap { background: var(--surface); border: 1px solid var(--line); border-radius: var(--r-lg); overflow: auto; }
+table.t { width: 100%; border-collapse: collapse; font-size: 13px; }
+table.t th {
+  position: sticky; top: 0; z-index: 1; background: var(--surface-2); text-align: left; font-weight: 550; color: var(--ink-2);
+  font-size: 12px; padding: 8px 12px; border-bottom: 1px solid var(--line); white-space: nowrap;
+}
+table.t th.sortable { cursor: pointer; user-select: none; }
+table.t th.sortable:hover { color: var(--ink); }
+table.t td { padding: 8px 12px; border-bottom: 1px solid var(--line); vertical-align: middle; }
+table.t tr:last-child td { border-bottom: 0; }
+table.t tbody tr.click { cursor: pointer; }
+table.t tbody tr.click:hover td { background: var(--hover); }
+table.t tr.sel td { background: color-mix(in srgb, var(--blue) 5%, #fff); }
+table.t td .sub { display: block; color: var(--ink-3); font-size: 12px; margin-top: 1px; }
+body.readonly .write-only { display: none !important; }
+.clamp2, table.t td .sub.clamp2 { display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden; }
+table.t td.proj-cell { min-width: 360px; max-width: 520px; }
+table.t td.released { max-width: 240px; }
+table.t tr.child td { background: var(--surface-2); }
+table.t tr.child td:first-child { padding-left: 34px; }
+table.t tr.grandchild td:first-child { padding-left: 56px; }
+table.dense td { padding: 6px 10px; }
+table.dense th { padding: 7px 10px; }
+.expander { display: inline-grid; place-items: center; width: 18px; height: 18px; margin-right: 4px; color: var(--ink-3); border: 0; background: none; cursor: pointer; border-radius: 4px; vertical-align: -3px; }
+.expander:hover { background: var(--surface-3); }
+.bar-cell { display: flex; align-items: center; gap: 8px; }
+.bar { height: 6px; border-radius: 0; background: var(--surface-3); flex: 1; min-width: 40px; position: relative; overflow: hidden; }
+.bar > i { position: absolute; inset: 0 auto 0 0; background: var(--s1); }
+.progress .bar > i { background: var(--ink-2); }
+.bar.train > i { background: var(--train); }
+.progress { display: flex; align-items: center; gap: 8px; }
+.progress .bar { max-width: 90px; }
+
+/* attempt cells: one per attempt in a group */
+.attempts { display: inline-flex; gap: 2px; vertical-align: middle; }
+.attempts button {
+  width: 13px; height: 13px; border-radius: 3px; border: 0; padding: 0; cursor: pointer; background: var(--surface-3);
+}
+.attempts button.passed { background: var(--good); }
+.attempts button.failed { background: #e9b3b3; }
+.attempts button.partial { background: var(--warn); }
+.attempts button.timeout, .attempts button.truncated, .attempts button.max_turns { background: var(--serious); }
+.attempts button.infra_error { background: none; box-shadow: inset 0 0 0 1.5px var(--ink-3); }
+.attempts button.on { box-shadow: 0 0 0 2px var(--surface), 0 0 0 3.5px var(--ink); }
+.attempts.big button { width: 22px; height: 22px; border-radius: 4px; }
+
+/* ---------------------------------------------------------------- charts */
+.chart { position: relative; }
+.chart svg { display: block; overflow: visible; }
+.chart .grid-line { stroke: var(--grid); stroke-width: 1; shape-rendering: crispEdges; }
+.chart .axis-label { fill: var(--ink-3); font-size: 11px; font-variant-numeric: tabular-nums; }
+.chart .line { fill: none; stroke-width: 2; stroke-linejoin: round; stroke-linecap: round; }
+.chart .raw { fill: none; stroke-width: 1; opacity: .28; }
+.chart .band { opacity: .12; }
+.chart .event-line { stroke-width: 1; }
+.chart .crosshair { stroke: var(--ink-3); stroke-width: 1; }
+.chart .dot { stroke: var(--surface); stroke-width: 2; }
+.tooltip {
+  position: absolute; pointer-events: none; z-index: 5; background: var(--surface); border: 1px solid var(--line);
+  border-radius: var(--r); box-shadow: 0 6px 20px rgba(0,0,0,.10); padding: 7px 9px; font-size: 12px; min-width: 120px; white-space: normal; max-width: min(380px, calc(100vw - 24px)); width: max-content;
+}
+.tooltip .tt-head { color: var(--ink-3); margin-bottom: 4px; }
+.tooltip .tt-row { display: flex; align-items: center; gap: 7px; }
+.tooltip .tt-row b { font-variant-numeric: tabular-nums; font-weight: 600; }
+.tooltip .tt-row { align-items: baseline; }
+.tooltip .tt-row b { white-space: nowrap; }
+.tooltip .tt-name { overflow-wrap: anywhere; }
+.tooltip .tt-row .key { flex: none; align-self: center; }
+.tooltip .tt-note { color: var(--ink-2); display: block; }
+.tooltip .key { width: 10px; height: 2px; border-radius: 1px; display: inline-block; }
+.legend { display: flex; flex-wrap: wrap; gap: 4px 14px; font-size: 12px; color: var(--ink-2); }
+.legend span { display: inline-flex; align-items: center; gap: 6px; }
+.legend .key { width: 12px; height: 2px; border-radius: 1px; display: inline-block; }
+.legend .key.box { height: 8px; width: 8px; border-radius: 2px; }
+.chart-card { background: var(--surface); border: 1px solid var(--line); border-radius: var(--r-lg); padding: 12px 14px 10px; min-width: 0; }
+.chart-card .cc-head { display: flex; align-items: baseline; gap: 8px; margin-bottom: 6px; }
+.chart-card .cc-title { font-weight: 550; font-size: 12.5px; }
+.chart-card .cc-unit { color: var(--ink-3); font-size: 12px; }
+.chart-card .cc-value { margin-left: auto; font-variant-numeric: tabular-nums; font-weight: 600; font-size: 13px; }
+.chart-card .cc-desc { color: var(--ink-3); font-size: 11.5px; line-height: 1.35; margin-top: 4px; }
+.chart-card.flag-warn { box-shadow: inset 3px 0 0 var(--warn); }
+.chart-card.flag-bad { box-shadow: inset 3px 0 0 var(--bad); }
+
+/* ---------------------------------------------------------------- drawer */
+.drawer {
+  position: fixed; top: var(--topbar); right: 0; bottom: 0; width: min(46vw, 760px); z-index: 25;
+  background: var(--surface); border-left: 1px solid var(--line); display: flex; flex-direction: column;
+  box-shadow: -8px 0 28px rgba(0,0,0,.06);
+}
+.drawer.full { width: calc(100vw - var(--sidebar)); }
+.drawer-head { display: flex; align-items: center; gap: 8px; padding: 10px 14px; border-bottom: 1px solid var(--line); }
+.drawer-head .where { font-size: 13px; color: var(--ink-2); min-width: 0; }
+.drawer-head .where b { color: var(--ink); font-weight: 600; }
+.drawer-body { overflow: auto; flex: 1; padding: 14px 16px 40px; }
+.idblock { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 8px 16px; padding: 10px 12px; border: 1px solid var(--line); border-radius: var(--r-lg); background: var(--surface-2); font-size: 12.5px; }
+.idblock .k { color: var(--ink-3); font-size: 11px; text-transform: uppercase; letter-spacing: .04em; display: block; }
+.idblock .v { font-weight: 500; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; display: block; }
+.scores { margin-top: 12px; }
+.score-row { display: grid; grid-template-columns: 64px 1fr; gap: 10px; padding: 7px 0; border-bottom: 1px solid var(--line); }
+.score-row .val { font-variant-numeric: tabular-nums; font-weight: 650; }
+.score-row .val.pass { color: var(--good-ink); }
+.score-row .val.fail { color: var(--bad-ink); }
+.msg { border: 1px solid var(--line); border-radius: var(--r-lg); margin-top: 10px; overflow: hidden; }
+.msg-head { display: flex; align-items: center; gap: 8px; padding: 6px 10px; background: var(--surface-2); font-size: 12px; color: var(--ink-2); border-bottom: 1px solid var(--line); }
+.msg-head .role { font-weight: 600; color: var(--ink); text-transform: capitalize; }
+.msg-body { padding: 9px 11px; white-space: pre-wrap; word-break: break-word; font-size: 13px; }
+.msg.note { background: var(--surface-2); border-style: dashed; }
+.msg.note .msg-body { color: var(--ink-2); font-style: italic; }
+.toolchip { display: flex; align-items: center; gap: 8px; padding: 6px 10px; border-top: 1px solid var(--line); font-size: 12.5px; cursor: pointer; }
+.toolchip:hover { background: var(--hover); }
+.toolchip .nm { font-family: var(--mono); font-weight: 600; font-size: 12px; }
+.toolchip .args { font-family: var(--mono); font-size: 12px; color: var(--ink-2); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; min-width: 0; flex: 1; }
+.toolout { font-family: var(--mono); font-size: 12px; white-space: pre-wrap; padding: 8px 11px; background: var(--surface-2); border-top: 1px solid var(--line); color: var(--ink-2); max-height: 320px; overflow: auto; }
+.reasoning { margin: 0 0 6px; padding: 6px 9px; border-left: 2px solid var(--line-2); color: var(--ink-2); font-size: 12.5px; white-space: pre-wrap; }
+mark { background: #fff1b8; color: inherit; border-radius: 2px; }
+
+/* ---------------------------------------------------------------- misc */
+.empty { padding: 28px; text-align: center; color: var(--ink-3); }
+.loading { padding: 40px; color: var(--ink-3); }
+.err { padding: 16px; border: 1px solid var(--bad-bg); background: var(--bad-bg); color: var(--bad-ink); border-radius: var(--r-lg); }
+.list-rows > * + * { border-top: 1px solid var(--line); }
+.finding { display: grid; grid-template-columns: 18px 1fr; gap: 8px; padding: 9px 14px; align-items: start; }
+.finding .lvl { padding-top: 1px; }
+.finding .area { font-weight: 600; margin-right: 6px; }
+.finding .what { color: var(--ink); }
+.finding .src { color: var(--ink-3); font-size: 12px; }
+.event { display: grid; grid-template-columns: 120px 1fr; gap: 10px; padding: 8px 14px; font-size: 13px; }
+.event .when { color: var(--ink-3); font-variant-numeric: tabular-nums; font-size: 12px; }
+.event .sub { display: block; font-size: 12px; font-weight: 400; }
+.kv { display: grid; grid-template-columns: 180px 1fr; gap: 6px 14px; font-size: 13px; }
+.kv .k { color: var(--ink-3); }
+pre.code { margin: 0; padding: 12px 14px; font-family: var(--mono); font-size: 12px; line-height: 1.5; background: var(--surface-2); border: 1px solid var(--line); border-radius: var(--r-lg); overflow: auto; white-space: pre; }
+.hist { display: flex; align-items: flex-end; gap: 2px; height: 26px; }
+.hist i { display: block; width: 6px; background: var(--s1); border-radius: 1.5px 1.5px 0 0; min-height: 1px; }
+.hist.warm i { background: var(--train); }
+.delta-up { color: var(--good-ink); }
+.delta-down { color: var(--bad-ink); }
+.provenance { font-size: 12px; color: var(--ink-3); }
+.kbd-hint { font-size: 11.5px; color: var(--ink-3); }
+.palette-overlay { position: fixed; inset: 0; background: rgba(20,20,18,.18); z-index: 60; display: flex; justify-content: center; padding-top: 12vh; }
+.palette { width: 620px; max-height: 60vh; background: var(--surface); border-radius: 10px; border: 1px solid var(--line); box-shadow: 0 18px 60px rgba(0,0,0,.2); display: flex; flex-direction: column; overflow: hidden; }
+.palette input { border: 0; border-bottom: 1px solid var(--line); padding: 14px 16px; font-size: 15px; outline: none; }
+.palette .results { overflow: auto; padding: 6px; }
+.palette .res { display: flex; align-items: center; gap: 10px; padding: 8px 10px; border-radius: var(--r); cursor: pointer; }
+.palette .res.on, .palette .res:hover { background: var(--hover); }
+.palette .res .type { width: 80px; font-size: 11.5px; color: var(--ink-3); text-transform: uppercase; letter-spacing: .04em; }
+.split { display: grid; grid-template-columns: minmax(0, 1fr) 360px; gap: 16px; align-items: start; }
+.split.split-wide { grid-template-columns: minmax(0, 1fr) 420px; }
+.split.split-list { grid-template-columns: 320px minmax(0, 1fr); }
+.explorer { display: grid; grid-template-columns: 230px minmax(0, 1fr); gap: 16px; align-items: start; }
+.explorer-nav { position: sticky; top: calc(var(--topbar) + 12px); }
+@media (max-width: 1250px) { .split { grid-template-columns: minmax(0, 1fr); } }
+.stack > * + * { margin-top: 14px; }
+.row { display: flex; align-items: center; gap: 8px; }
+.row.wrap { flex-wrap: wrap; }
+.grow { flex: 1; min-width: 0; }
+.right { margin-left: auto; }
+.spark { display: block; }
+
+/* ---------------------------------------------------------------- narrow screens */
+.menu-btn { display: none; }
+@media (max-width: 900px) {
+  .menu-btn { display: inline-grid; }
+  .brand { width: auto; }
+  .brand .brand-name { display: none; }
+  .sidebar { transform: translateX(-100%); transition: transform .15s ease; box-shadow: 8px 0 24px rgba(0,0,0,.08); }
+  body.nav-open .sidebar { transform: none; }
+  .main, .main.with-drawer { margin-left: 0; margin-right: 0; padding: calc(var(--topbar) + 14px) 14px 48px; }
+  .search-btn { width: auto; }
+  .search-btn .label, .search-btn kbd { display: none; }
+  .crumbs .switcher > button span:first-child, .crumbs .sep { display: none; }
+  .drawer, .drawer.full { width: 100vw; }
+  .grid.cols-2, .grid.cols-3, .grid.cols-4, .split { grid-template-columns: minmax(0, 1fr); }
+  .idblock { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+  h1 { font-size: 26px; }
+  .source-pill { display: none; }
+  .finding { grid-template-columns: 18px 1fr !important; }
+  .tabs { overflow-x: auto; scrollbar-width: none; }
+  .tabs a { white-space: nowrap; }
+  .facts .f { white-space: normal; overflow-wrap: anywhere; }
+  .page-head { flex-wrap: wrap; }
+  .event { grid-template-columns: 1fr !important; gap: 2px; }
+  .kv { grid-template-columns: 1fr; }
+  .seg { flex-wrap: wrap; }
+  .split.split-wide, .split.split-list, .explorer { grid-template-columns: minmax(0, 1fr); }
+  .explorer-nav { position: static; }
+}
+
+.chain { display: flex; flex-wrap: wrap; align-items: center; gap: 6px 8px; padding: 10px 14px; }
+.chain-node { display: inline-flex; flex-direction: column; gap: 1px; padding: 5px 9px; border: 1px solid var(--line); border-radius: var(--r); background: var(--surface); font-size: 12.5px; max-width: 240px; }
+.chain-node a, .chain-node span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.chain-stage { font-size: 11px; color: var(--ink-3); text-transform: uppercase; letter-spacing: .04em; }
+.chain-arrow { color: var(--ink-3); }
+
+/* ---------------------------------------------------------------- pages without a project */
+.main.bare { margin: 0 auto; max-width: 1400px; }
+.main.bare.narrow { max-width: 1040px; }
+.menu .item-sub { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; max-width: 420px; }
+.menu-sep { height: 1px; background: var(--line); margin: 6px 2px; }
+.menu-empty { padding: 4px 8px 6px; color: var(--ink-3); font-size: 12.5px; }
+.source-pill.workspace .dot { background: var(--s1); }
+.source-pill.live .dot { background: var(--good); }
+.status.online { color: var(--good-ink); }
+.status.offline { color: var(--ink-3); }
+.status.starting { color: var(--info-ink); }
+.status.stopping { color: var(--ink-2); }
+.status.stalled { color: var(--warn-ink); }
+.block { display: block; }
+
+/* ---------------------------------------------------------------- forms */
+.form { display: flex; flex-direction: column; gap: 14px; }
+.form-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 14px 16px; }
+.field { display: flex; flex-direction: column; gap: 5px; min-width: 0; }
+.field-label { font-size: 12.5px; font-weight: 550; color: var(--ink); }
+.field-help { font-size: 12px; color: var(--ink-3); line-height: 1.4; }
+.field-error, .form-error { font-size: 12.5px; color: var(--bad-ink); }
+.form-error { padding: 8px 10px; background: var(--bad-bg); border-radius: var(--r); }
+.field .input { width: 100%; }
+textarea.input { height: auto; padding: 7px 10px; resize: vertical; line-height: 1.45; }
+.input:focus, select.input:focus, textarea.input:focus { outline: none; border-color: var(--focus); box-shadow: 0 0 0 3px color-mix(in srgb, var(--focus) 15%, transparent); }
+.input.changed { border-color: var(--ink-2); background: var(--surface-2); }
+.form-actions { display: flex; justify-content: flex-end; gap: 8px; }
+.consequence { margin: 0; font-size: 13px; color: var(--ink-2); }
+.check { display: inline-flex; align-items: flex-start; gap: 7px; cursor: pointer; }
+.check input { margin: 2px 0 0; }
+.notice { padding: 9px 11px; border-radius: var(--r); background: var(--surface-2); border: 1px solid var(--line); font-size: 12.5px; color: var(--ink-2); }
+.notice.warn { background: var(--warn-bg); border-color: color-mix(in srgb, var(--warn) 35%, var(--line)); color: var(--warn-ink); }
+.notice.good { background: var(--good-bg); border-color: color-mix(in srgb, var(--good) 30%, var(--line)); color: var(--good-ink); }
+.token-prompt { padding: 11px 12px; border: 1px solid color-mix(in srgb, var(--warn) 35%, var(--line)); background: var(--warn-bg); border-radius: var(--r-lg); font-size: 13px; }
+.made-token { margin-top: 14px; padding: 12px; border: 1px solid color-mix(in srgb, var(--good) 30%, var(--line)); background: var(--good-bg); border-radius: var(--r-lg); font-size: 13px; }
+.made-token .cmd { margin-top: 8px; background: var(--surface); }
+.inline-form { margin-top: 16px; padding-top: 14px; border-top: 1px solid var(--line); }
+.inline-form h4 { margin: 0; font-size: 13.5px; font-weight: 600; }
+.btn.danger { background: var(--bad-ink); border-color: var(--bad-ink); color: #fff; }
+.btn.danger:hover { background: color-mix(in srgb, var(--bad-ink) 85%, black); }
+.seg button[disabled] { opacity: .45; cursor: default; }
+.seg.wrap-seg { flex-wrap: wrap; }
+
+/* a copyable command; the prompt is drawn here so it is never copied */
+.cmd { display: flex; align-items: flex-start; gap: 6px; min-width: 0; padding: 7px 8px 7px 10px; background: var(--surface-2); border: 1px solid var(--line); border-radius: var(--r); }
+.cmd code { flex: 1; min-width: 0; font-size: 12px; line-height: 1.5; white-space: pre-wrap; overflow-wrap: anywhere; color: var(--ink); overflow-x: auto; }
+.cmd code::before { content: "$ "; color: var(--ink-3); }
+.cmd code .w { white-space: pre; }
+.field .seg { align-self: flex-start; }
+.cmd.compact { padding: 4px 6px 4px 8px; }
+.cmd.compact code { font-size: 11.5px; }
+.cmd-copy { flex: none; display: inline-grid; place-items: center; min-width: 22px; height: 22px; padding: 0 4px; border: 0; border-radius: var(--r); background: none; color: var(--ink-3); cursor: pointer; }
+.cmd-copy:hover { background: var(--surface-3); color: var(--ink); }
+.cmd-list { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px 18px; }
+.cmd-list > div { display: flex; flex-direction: column; gap: 4px; min-width: 0; }
+.cell-cmd { margin-top: 5px; max-width: 320px; }
+
+/* dialogs */
+.dialog-overlay { position: fixed; inset: 0; z-index: 60; background: rgba(20,20,18,.2); display: flex; justify-content: center; align-items: flex-start; padding: 8vh 12px 24px; overflow: auto; }
+.dialog { background: var(--surface); border: 1px solid var(--line); border-radius: var(--r-lg); box-shadow: 0 18px 60px rgba(0,0,0,.18); padding: 18px 20px 20px; }
+.dialog-head { display: flex; align-items: center; gap: 8px; }
+.dialog-head h2 { font-size: 17px; }
+.dialog-purpose { margin: 4px 0 16px; color: var(--ink-2); font-size: 13px; }
+
+/* ---------------------------------------------------------------- stages */
+.stages { overflow: hidden; }
+.tag.next-tag { background: var(--ink); color: #fff; }
+.stage-state { display: inline-flex; align-items: center; gap: 5px; font-size: 12.5px; font-weight: 500; white-space: nowrap; }
+.stage-state svg { width: 13px; height: 13px; flex: none; }
+.stage-state.done { color: var(--good-ink); }
+.stage-state.in_progress { color: var(--info-ink); }
+.stage-state.not_started, .stage-state.skipped { color: var(--ink-3); }
+.stage-state.blocked { color: var(--bad-ink); }
+.stages-box { overflow: hidden; }
+.stages-box .stage-foot { border-top: 1px solid var(--line); }
+.stages-table td { vertical-align: top; }
+.stages-table tr.next td { background: var(--surface-2); }
+.stages-table tr.next td:first-child { box-shadow: inset 3px 0 0 var(--ink); }
+.stages-table .objs { margin-top: 0; flex-direction: column; gap: 3px; }
+.stages-table .sub { max-width: 320px; }
+.warn-ink { color: var(--warn-ink); }
+.stage-notice { border: 1px solid color-mix(in srgb, var(--warn) 35%, var(--line)); border-radius: var(--r-lg); margin-bottom: 10px; }
+.objs { display: flex; flex-wrap: wrap; gap: 4px 14px; margin-top: 6px; font-size: 12.5px; }
+.obj { display: inline-flex; align-items: center; gap: 6px; min-width: 0; }
+.obj .status { font-size: 12px; font-weight: 450; }
+.obj .status svg { width: 12px; height: 12px; }
+.stage-action { display: flex; flex-direction: column; align-items: flex-start; gap: 6px; min-width: 0; }
+.stage-action .cmd { align-self: stretch; }
+.stage-notice { display: flex; gap: 10px; padding: 11px 14px; background: var(--warn-bg); border-bottom: 1px solid color-mix(in srgb, var(--warn) 35%, var(--line)); font-size: 13px; }
+.stage-notice .lvl svg { width: 14px; height: 14px; }
+.stage-foot { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 8px; padding: 9px 14px; border-top: 1px solid var(--line); background: var(--surface-2); }
+.firstrun .fr-step { display: grid; grid-template-columns: 26px minmax(0, 1fr) auto; gap: 12px; padding: 14px; border-top: 1px solid var(--line); align-items: start; }
+.firstrun .fr-step:first-child { border-top: 0; }
+.fr-num { width: 22px; height: 22px; border-radius: var(--r); border: 1px solid var(--line-2); display: grid; place-items: center; font-size: 12px; font-weight: 600; color: var(--ink-2); }
+.fr-num.done { border: 0; color: var(--good-ink); }
+.fr-num.done svg { width: 22px; height: 22px; }
+.fr-cmds { display: flex; flex-direction: column; gap: 5px; margin-top: 8px; max-width: 640px; }
+.fr-actions { display: flex; flex-direction: column; align-items: stretch; gap: 6px; }
+
+/* ---------------------------------------------------------------- launch a run */
+.launch { display: grid; grid-template-columns: minmax(0, 1fr) 380px; gap: 20px; align-items: start; }
+.launch-form { display: flex; flex-direction: column; gap: 14px; min-width: 0; }
+.lf-sec { background: var(--surface); border: 1px solid var(--line); border-radius: var(--r-lg); padding: 14px 16px 16px; }
+.lf-sec h3 { display: flex; align-items: center; gap: 8px; margin-bottom: 12px; font-size: 13.5px; }
+.lf-num { width: 20px; height: 20px; border-radius: var(--r); background: var(--surface-3); display: grid; place-items: center; font-size: 11.5px; color: var(--ink-2); }
+.choices { display: flex; flex-direction: column; gap: 6px; }
+.choices.four { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 8px; }
+.choice { display: flex; flex-direction: column; align-items: flex-start; gap: 2px; text-align: left; padding: 9px 11px; border: 1px solid var(--line-2); border-radius: var(--r-lg); background: var(--surface); cursor: pointer; min-width: 0; }
+.choice:hover { background: var(--hover); }
+.choice.on { border-color: var(--ink); box-shadow: inset 0 0 0 1px var(--ink); background: var(--surface); }
+.choice.row-choice { flex-direction: row; align-items: center; gap: 10px; }
+.radio-dot { width: 14px; height: 14px; flex: none; border-radius: 50%; border: 1.5px solid var(--line-2); background: var(--surface); }
+.choice.on .radio-dot { border: 4.5px solid var(--ink); }
+.param-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 14px 16px; margin-top: 14px; }
+.pick-list { border: 1px solid var(--line); border-radius: var(--r-lg); overflow: hidden; }
+.pick { display: flex; align-items: center; gap: 10px; padding: 8px 11px; border-top: 1px solid var(--line); cursor: pointer; font-size: 13px; }
+.pick:first-child { border-top: 0; }
+.pick:hover { background: var(--hover); }
+.chip-btn { height: 24px; padding: 0 9px; border-radius: var(--r); border: 1px solid var(--line-2); background: var(--surface); font-family: var(--mono); font-size: 11.5px; cursor: pointer; color: var(--ink-2); }
+.chip-btn.on { background: var(--ink); border-color: var(--ink); color: #fff; }
+details.more { margin-top: 12px; }
+details.more summary { cursor: pointer; font-size: 12.5px; color: var(--ink-2); margin-bottom: 8px; }
+.rail { position: sticky; top: calc(var(--topbar) + 14px); display: flex; flex-direction: column; gap: 12px; min-width: 0; max-height: calc(100vh - var(--topbar) - 28px); overflow: auto; }
+.rail-panel { background: var(--surface); border: 1px solid var(--line); border-radius: var(--r-lg); padding: 13px 14px 14px; display: flex; flex-direction: column; gap: 8px; min-width: 0; }
+.rail-panel h3 { font-size: 13.5px; }
+.checks { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 5px; font-size: 12.5px; }
+.checks li { display: grid; grid-template-columns: 34px minmax(0, 1fr); gap: 0 8px; align-items: baseline; }
+.checks .ck { grid-row: span 2; font-family: var(--mono); font-size: 11px; font-weight: 600; }
+.checks .ck-id { font-size: 11px; color: var(--ink-3); }
+.checks .ck-text { overflow-wrap: anywhere; }
+.checks li.ok .ck { color: var(--good-ink); }
+.checks li.warn .ck { color: var(--warn-ink); }
+.checks li.fail .ck { color: var(--bad-ink); }
+.pick.other { opacity: .6; }
+.launch-btn { justify-content: center; height: 34px; }
+pre.small-code { font-size: 11px; max-height: 320px; margin-top: 6px; }
+
+/* ---------------------------------------------------------------- live runs and logs */
+.status-strip { display: flex; align-items: flex-start; gap: 12px; margin: 4px 0 2px; padding: 10px 14px; border: 1px solid var(--line); border-radius: var(--r-lg); background: var(--surface); font-size: 13px; }
+.status-strip.running, .status-strip.starting { border-color: color-mix(in srgb, var(--link) 22%, var(--line)); background: var(--info-bg); }
+.status-strip.queued, .status-strip.stopping { background: var(--surface-2); }
+.status-strip.stalled { border-color: color-mix(in srgb, var(--warn) 35%, var(--line)); background: var(--warn-bg); }
+.status-strip.failed { border-color: color-mix(in srgb, var(--bad) 30%, var(--line)); background: var(--bad-bg); }
+.status-strip > .status { padding-top: 1px; }
+.strip-actions { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; justify-content: flex-end; }
+.confirm { max-width: 360px; padding: 10px 12px; border: 1px solid var(--line-2); border-radius: var(--r-lg); background: var(--surface); box-shadow: 0 6px 20px rgba(0,0,0,.08); }
+.logs { height: 62vh; min-height: 260px; overflow: auto; background: var(--surface-2); border: 1px solid var(--line); border-radius: var(--r-lg); padding: 8px 0; font-family: var(--mono); font-size: 12px; line-height: 1.55; }
+.ll { display: grid; grid-template-columns: 66px minmax(0, 1fr); gap: 10px; padding: 0 12px; }
+.ll:hover { background: var(--hover); }
+.lt { color: var(--ink-3); user-select: none; }
+.lx { white-space: pre; }
+.logs.wrap .lx { white-space: pre-wrap; overflow-wrap: anywhere; }
+.ll.stderr .lx { color: var(--serious-ink); }
+.log-empty { padding: 28px; text-align: center; color: var(--ink-3); font-family: var(--sans); font-size: 13px; }
+
+/* ---------------------------------------------------------------- settings */
+.settings { max-width: 900px; }
+.setting-row { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 16px; padding: 11px 14px; align-items: start; }
+.right-col { text-align: right; }
+
+@media (max-width: 1250px) {
+  .launch { grid-template-columns: minmax(0, 1fr) 330px; }
+  .param-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+}
+@media (max-width: 900px) {
+  .form-grid, .param-grid, .cmd-list { grid-template-columns: minmax(0, 1fr); }
+  .choices.four { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+  .launch { grid-template-columns: minmax(0, 1fr); }
+  .rail { position: static; max-height: none; }
+  .stages-table thead { display: none; }
+  .stages-table tr { display: grid; grid-template-columns: minmax(0, 1fr) auto; border-bottom: 1px solid var(--line); padding: 4px 0; }
+  .stages-table td { border: 0; padding: 4px 12px; }
+  .stages-table td:nth-child(3), .stages-table td:nth-child(4) { grid-column: 1 / -1; }
+  .stages-table tr.next td:first-child { box-shadow: none; }
+  .stages-table tr.next { border-left: 3px solid var(--ink); }
+  .stages-table td.no-now, .stages-table td.no-next { display: none; }
+  .firstrun .fr-step { grid-template-columns: 26px minmax(0, 1fr); }
+  .fr-actions { grid-column: 2; flex-direction: row; flex-wrap: wrap; }
+  .status-strip { flex-wrap: wrap; }
+  .strip-actions { width: 100%; justify-content: flex-start; }
+  .setting-row { grid-template-columns: minmax(0, 1fr); }
+  .right-col { text-align: left; }
+  .ll { grid-template-columns: 58px minmax(0, 1fr); gap: 6px; padding: 0 8px; }
+  .dialog { padding: 16px 14px; }
+  .dialog-overlay { padding-top: 12px; }
+}
+.example-banner { margin: -6px 0 16px; padding: 7px 12px; border: 1px solid color-mix(in srgb, var(--warn) 35%, var(--line)); background: var(--warn-bg); border-radius: var(--r); font-size: 12.5px; color: var(--ink-2); }
+.example-banner a { margin-left: 6px; white-space: nowrap; }
+.compare-facts { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 10px 20px; margin-top: 12px; font-size: 13px; }
+.compare-facts .k { display: block; color: var(--ink-3); font-size: 12px; margin-bottom: 2px; overflow-wrap: anywhere; }
+@media (max-width: 900px) { .compare-facts { grid-template-columns: minmax(0, 1fr); } }
+.event.sel { background: var(--info-bg); box-shadow: inset 3px 0 0 var(--link); }
+/* runs tables: long names ellipsize (the full name is in the title) so the table fits without scrolling */
+.cell-name { display: block; max-width: 200px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+table.t td .sub.cell-clip, .cell-clip { display: block; max-width: 200px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+table.t td .sub.tag-clip { max-width: 150px; }
+.held { display: flex; align-items: baseline; gap: 6px; min-width: 0; }
+.held-name { max-width: 110px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; flex: 0 1 auto; }
+table.t .progress { flex-direction: column; align-items: flex-start; gap: 3px; }
+table.t .progress .bar { width: 100%; max-width: none; min-width: 48px; flex: none; }
+/* matrices whose columns are runs or models: long names wrap in the header (full name in the title) */
+table.t th.col-name { white-space: normal; vertical-align: bottom; }
+table.t th.col-name > span { display: inline-block; max-width: 128px; overflow-wrap: anywhere; }
+table.t td.bench-cell { max-width: 280px; }
diff --git a/viewer/static/ui/chart.js b/viewer/static/ui/chart.js
new file mode 100644
index 0000000000000000000000000000000000000000..bc9654928d2ab6ea056977439decaacf33cd2fd8
--- /dev/null
+++ b/viewer/static/ui/chart.js
@@ -0,0 +1,313 @@
+import { html, useRef, useState, useMemo, useSize, useLayoutEffect } from "../lib.js";
+import * as f from "./fmt.js";
+
+export const SERIES = ["var(--s1)", "var(--s2)", "var(--s3)", "var(--s4)", "var(--s5)", "var(--s6)", "var(--s7)", "var(--s8)"];
+
+function niceTicks(lo, hi, n = 4) {
+  if (!(isFinite(lo) && isFinite(hi))) return [];
+  if (lo === hi) { lo -= 1; hi += 1; }
+  const span = hi - lo;
+  const step0 = span / n;
+  const mag = Math.pow(10, Math.floor(Math.log10(step0)));
+  const err = step0 / mag;
+  const step = (err >= 7.5 ? 10 : err >= 3.5 ? 5 : err >= 1.5 ? 2 : 1) * mag;
+  const out = [];
+  for (let v = Math.ceil(lo / step) * step; v <= hi + step * 1e-9; v += step) out.push(+v.toPrecision(12));
+  return out;
+}
+
+export function smooth(points, alpha) {
+  if (!alpha) return points;
+  let prev = null;
+  // debiased EMA, like TensorBoard's smoothing slider
+  let num = 0, den = 0;
+  return points.map(([x, y]) => {
+    if (y === null || y === undefined) return [x, null];
+    num = alpha * num + (1 - alpha) * y;
+    den = alpha * den + (1 - alpha);
+    prev = num / den;
+    return [x, prev];
+  });
+}
+
+/**
+ * A chart's hover box. It sits right of the crosshair at x, flips to the left when that would leave
+ * the window, and never leaves the window; long names wrap instead of being cut.
+ */
+export function Tip({ x, W, top = 0, children }) {
+  const ref = useRef(null);
+  useLayoutEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.style.transform = "";
+    let r = el.getBoundingClientRect();
+    if (r.right > window.innerWidth - 8) {
+      el.style.left = "auto";
+      el.style.right = `${Math.max(0, W - x + 12)}px`;
+      r = el.getBoundingClientRect();
+    }
+    if (r.left < 8) el.style.transform = `translateX(${8 - r.left}px)`;
+  });
+  return html`<div class="tooltip" ref=${ref} style=${`left:${x + 12}px;right:auto;top:${top}px`}>${children}</div>`;
+}
+
+/**
+ * series: [{key, label, color, points: [[x, y]], band: [[x, lo, hi]], dots, width, dashed, format, axis}]
+ * `format` formats that series' values in the tooltip (default: yFormat, the axis format).
+ * `axis: "right"` puts a series in another unit on its own scale, labelled on the right with its format.
+ * events: [{x, label, kind}]   (vertical markers)
+ */
+export function LineChart({ series, height = 220, yFormat = (v) => f.by("", v), xLabel = "step", events = [],
+  smoothing = 0, yDomain, xDomain, onPick, legend = true, compact = false, showRaw = true, xFormat }) {
+  const ref = useRef(null);
+  const width = useSize(ref);
+  const [hover, setHover] = useState(null);
+  const hasRight = series.some((s) => s.axis === "right" && s.points.length);
+  const pad = compact ? { l: 36, r: hasRight ? 40 : 8, t: events.length ? 10 : 6, b: 16 } : { l: 48, r: hasRight ? 52 : 14, t: events.length ? 14 : 10, b: 24 };
+  const plotted = useMemo(() => series.map((s) => ({ ...s, sm: smoothing ? smooth(s.points, smoothing) : s.points })), [series, smoothing]);
+  const xs = plotted.flatMap((s) => s.points.map((p) => p[0]));
+  const valuesOf = (ss) => ss.flatMap((s) => [...s.points.map((p) => p[1]), ...(s.band || []).flatMap((b) => [b[1], b[2]])]).filter((v) => v !== null && v !== undefined && isFinite(v));
+  const ys = valuesOf(plotted.filter((s) => s.axis !== "right"));
+  const ysR = valuesOf(plotted.filter((s) => s.axis === "right"));
+  if (!xs.length || !(ys.length || ysR.length)) return html`<div ref=${ref} class="chart"><div class="empty" style=${`height:${height}px`}>No data</div></div>`;
+  let [x0, x1] = xDomain || [Math.min(...xs), Math.max(...xs)];
+  if (x0 === x1) { x0 -= 1; x1 += 1; }
+  const range = (vals) => {
+    let [lo, hi] = [Math.min(...vals), Math.max(...vals)];
+    const span = (hi - lo) || Math.abs(hi) || 1;
+    return [lo - span * 0.08, hi + span * 0.08];
+  };
+  let [y0, y1] = yDomain || range(ys.length ? ys : ysR);
+  const [r0, r1] = ysR.length ? range(ysR) : [0, 1];
+  const ticks = niceTicks(y0, y1, compact ? 3 : 4);
+  const rightSeries = plotted.find((s) => s.axis === "right");
+  const ticksR = hasRight ? niceTicks(r0, r1, compact ? 3 : 4) : [];
+  const intX = xs.every((x) => Number.isInteger(x));
+  let xticks = niceTicks(x0, x1, compact ? 3 : 6).filter((v) => v >= x0 && v <= x1);
+  if (intX) {
+    xticks = xticks.filter((v) => Number.isInteger(v));
+    if (xticks.length < 2) xticks = [...new Set(xs)].sort((a, b) => a - b);
+  }
+  const W = Math.max(80, width), H = height;
+  const sx = (x) => pad.l + ((x - x0) / (x1 - x0)) * (W - pad.l - pad.r);
+  const sy = (y) => pad.t + (1 - (y - y0) / (y1 - y0)) * (H - pad.t - pad.b);
+  const syR = (y) => pad.t + (1 - (y - r0) / (r1 - r0)) * (H - pad.t - pad.b);
+  const scaleOf = (s) => (s.axis === "right" ? syR : sy);
+  const path = (pts, yOf = sy) => {
+    let d = "", pen = false;
+    for (const [x, y] of pts) {
+      if (y === null || y === undefined || !isFinite(y)) { pen = false; continue; }
+      d += `${pen ? "L" : "M"}${sx(x).toFixed(1)},${yOf(y).toFixed(1)}`;
+      pen = true;
+    }
+    return d;
+  };
+  const bandPath = (band) => {
+    if (!band || !band.length) return "";
+    const top = band.map(([x, lo, hi]) => `${sx(x).toFixed(1)},${sy(hi).toFixed(1)}`);
+    const bot = band.slice().reverse().map(([x, lo]) => `${sx(x).toFixed(1)},${sy(lo).toFixed(1)}`);
+    return `M${top.join("L")}L${bot.join("L")}Z`;
+  };
+  const allX = [...new Set(xs)].sort((a, b) => a - b);
+  const evByX = new Map();
+  for (const ev of events) {
+    if (ev.x < x0 || ev.x > x1) continue;
+    if (!evByX.has(ev.x)) evByX.set(ev.x, []);
+    evByX.get(ev.x).push(ev);
+  }
+  const evMarks = [...evByX.entries()].map(([x, evs]) => ({ x, labels: evs.map((e) => e.label),
+    color: evs.some((e) => e.kind === "restart" || e.kind === "incident") ? "var(--bad)" : "var(--ink-3)" }));
+  const move = (e) => {
+    const r = ref.current.getBoundingClientRect();
+    const px = e.clientX - r.left;
+    const xv = x0 + ((px - pad.l) / (W - pad.l - pad.r)) * (x1 - x0);
+    let best = allX[0], bd = Infinity;
+    for (const x of allX) { const d = Math.abs(x - xv); if (d < bd) { bd = d; best = x; } }
+    setHover(best);
+  };
+  const hoverRows = hover === null ? [] : plotted.map((s) => {
+    const p = s.sm.find((q) => q[0] === hover);
+    const raw = s.points.find((q) => q[0] === hover);
+    return p ? { s, v: p[1], raw: raw ? raw[1] : null } : null;
+  }).filter(Boolean);
+  const hx = hover === null ? 0 : sx(hover);
+  return html`<div ref=${ref} class="chart" onMouseLeave=${() => setHover(null)}>
+    <svg width=${W} height=${H} onMouseMove=${move} onClick=${() => onPick && hover !== null && onPick(hover)} style=${onPick ? "cursor:pointer" : ""}>
+      ${ticks.map((t) => html`<line class="grid-line" x1=${pad.l} x2=${W - pad.r} y1=${sy(t)} y2=${sy(t)} />
+        <text class="axis-label" x=${pad.l - 6} y=${sy(t) + 3.5} text-anchor="end">${yFormat(t)}</text>`)}
+      ${ticksR.map((t) => html`<text class="axis-label" x=${W - pad.r + 6} y=${syR(t) + 3.5} text-anchor="start" fill=${rightSeries.color}>${(rightSeries.format || yFormat)(t)}</text>`)}
+      ${xticks.map((t) => html`<text class="axis-label" x=${sx(t)} y=${H - 6} text-anchor="middle">${xFormat ? xFormat(t) : f.compact(t)}</text>`)}
+      ${evMarks.map((m) => html`<g>
+          <line x1=${sx(m.x)} x2=${sx(m.x)} y1=${pad.t} y2=${H - pad.b} stroke=${m.color} stroke-width="1" opacity="0.28" />
+          <path d=${`M${sx(m.x) - 4},${pad.t - 1}h8l-4,6z`} fill=${m.color}><title>${m.labels.join("\n")}</title></path>
+        </g>`)}
+      ${plotted.map((s) => s.band ? html`<path class="band" d=${bandPath(s.band)} fill=${s.color} />` : null)}
+      ${showRaw && smoothing ? plotted.map((s) => html`<path class="raw" d=${path(s.points, scaleOf(s))} stroke=${s.color} />`) : null}
+      ${plotted.map((s) => html`<path class="line" d=${path(s.sm, scaleOf(s))} stroke=${s.color} stroke-width=${s.width || 2} stroke-dasharray=${s.dashed ? "4 3" : ""} />`)}
+      ${plotted.map((s) => s.dots ? s.points.filter((p) => p[1] !== null).map((p) => html`<circle class="dot" cx=${sx(p[0])} cy=${scaleOf(s)(p[1])} r="3.5" fill=${s.color} />`) : null)}
+      ${hover !== null ? html`<line class="crosshair" x1=${hx} x2=${hx} y1=${pad.t} y2=${H - pad.b} />
+        ${hoverRows.map((r) => r.v !== null && r.v !== undefined ? html`<circle class="dot" cx=${hx} cy=${scaleOf(r.s)(r.v)} r="4" fill=${r.s.color} />` : null)}` : null}
+    </svg>
+    ${hover !== null && hoverRows.length ? html`<${Tip} x=${hx} W=${W} top=${pad.t}>
+      <div class="tt-head">${xLabel} ${f.compact(hover)}</div>
+      ${(evByX.get(hover) || []).map((e) => html`<div class="tt-row tt-note small">${e.label}</div>`)}
+      ${hoverRows.map((r) => { const fmt = r.s.format || yFormat; return html`<div class="tt-row"><span class="key" style=${`background:${r.s.color}`}></span><b>${fmt(r.v)}</b>
+        <span class="muted tt-name">${r.s.label}${smoothing && r.raw !== null && r.raw !== undefined ? ` (raw ${fmt(r.raw)})` : ""}</span></div>`; })}
+    </${Tip}>` : null}
+    ${legend && series.length > 1 ? html`<div class="legend" style="margin-top:6px">${series.map((s) => html`<span><i class="key" style=${`background:${s.color}`}></i>${s.label}${hasRight ? (s.axis === "right" ? ", right axis" : ", left axis") : ""}</span>`)}</div>` : null}
+  </div>`;
+}
+
+export function Spark({ points, width = 120, height = 28, color = "var(--s1)", band }) {
+  const pts = (points || []).filter((p) => p[1] !== null && p[1] !== undefined && isFinite(p[1]));
+  if (pts.length < 2) return html`<svg class="spark" width=${width} height=${height}></svg>`;
+  const xs = pts.map((p) => p[0]), ys = pts.map((p) => p[1]);
+  const x0 = Math.min(...xs), x1 = Math.max(...xs);
+  let y0 = Math.min(...ys), y1 = Math.max(...ys);
+  if (y0 === y1) { y0 -= 1; y1 += 1; }
+  const sx = (x) => 1 + ((x - x0) / (x1 - x0 || 1)) * (width - 6);
+  const sy = (y) => 2 + (1 - (y - y0) / (y1 - y0)) * (height - 4);
+  const d = pts.map((p, i) => `${i ? "L" : "M"}${sx(p[0]).toFixed(1)},${sy(p[1]).toFixed(1)}`).join("");
+  const last = pts[pts.length - 1];
+  return html`<svg class="spark" width=${width} height=${height} aria-hidden="true">
+    <path d=${d} fill="none" stroke=${color} stroke-width="1.5" stroke-linejoin="round" />
+    <circle cx=${sx(last[0])} cy=${sy(last[1])} r="2.5" fill=${color} />
+  </svg>`;
+}
+
+/** bars: [{label, value, color}] vertical columns with the value on hover */
+export function Columns({ bars, height = 120, format = (v) => f.int(v), xTitle, yTitle }) {
+  const ref = useRef(null);
+  const width = useSize(ref);
+  const [hover, setHover] = useState(null);
+  const max = Math.max(1, ...bars.map((b) => b.value || 0));
+  const W = Math.max(120, width), H = height, padB = 18, padT = 4;
+  const n = bars.length;
+  const slot = (W - 4) / Math.max(1, n);
+  const bw = Math.max(1, Math.min(24, slot - 2));
+  return html`<div ref=${ref} class="chart" onMouseLeave=${() => setHover(null)}>
+    <svg width=${W} height=${H}>
+      <line class="grid-line" x1="0" x2=${W} y1=${H - padB} y2=${H - padB} />
+      ${bars.map((b, i) => {
+        const hh = ((b.value || 0) / max) * (H - padB - padT);
+        const x = 2 + i * slot + (slot - bw) / 2;
+        return html`<g onMouseEnter=${() => setHover(i)}>
+          <rect x=${2 + i * slot} y=${padT} width=${slot} height=${H - padB - padT} fill="transparent" />
+          <path d=${`M${x},${H - padB}V${H - padB - hh + Math.min(4, hh)}Q${x},${H - padB - hh} ${x + Math.min(4, bw / 2)},${H - padB - hh}H${x + bw - Math.min(4, bw / 2)}Q${x + bw},${H - padB - hh} ${x + bw},${H - padB - hh + Math.min(4, hh)}V${H - padB}Z`}
+            fill=${b.color || "var(--s1)"} opacity=${hover === null || hover === i ? 1 : 0.55} />
+          ${n <= 12 ? html`<text class="axis-label" x=${x + bw / 2} y=${H - 4} text-anchor="middle">${b.label}</text>` : null}
+        </g>`;
+      })}
+    </svg>
+    ${hover !== null ? html`<${Tip} x=${2 + hover * slot + slot / 2} W=${W}>
+      <div class="tt-head">${bars[hover].title || bars[hover].label}</div><div class="tt-row"><b>${format(bars[hover].value)}</b></div></${Tip}>` : null}
+  </div>`;
+}
+
+/** stacked daily bars: days [{day, parts: {cat: value}}], cats [{key,label,color}] */
+// More than 90 bars stop being readable: sum days into weeks, or months past 18 months of history.
+function bucketDays(rows) {
+  const sorted = [...rows].sort((a, b) => a.day.localeCompare(b.day));
+  if (sorted.length <= 90) return { days: sorted, unit: "day" };
+  const span = (Date.parse(sorted[sorted.length - 1].day) - Date.parse(sorted[0].day)) / 864e5;
+  const unit = span > 540 ? "month" : "week";
+  const key = (day) => {
+    if (unit === "month") return day.slice(0, 7);
+    const t = Date.parse(day + "T00:00:00Z");
+    return new Date(t - ((new Date(t).getUTCDay() + 6) % 7) * 864e5).toISOString().slice(0, 10);
+  };
+  const m = new Map();
+  for (const d of sorted) {
+    const k = key(d.day);
+    const cur = m.get(k) || { day: k, parts: {} };
+    for (const [c, v] of Object.entries(d.parts)) cur.parts[c] = (cur.parts[c] || 0) + (v || 0);
+    m.set(k, cur);
+  }
+  return { days: [...m.values()], unit };
+}
+
+export function StackedColumns({ days: rows, cats, height = 160, format = f.money }) {
+  const ref = useRef(null);
+  const width = useSize(ref);
+  const [hover, setHover] = useState(null);
+  const { days, unit } = bucketDays(rows);
+  const when = (d) => unit === "week" ? `Week of ${d.day}` : d.day;
+  const totals = days.map((d) => cats.reduce((s, c) => s + (d.parts[c.key] || 0), 0));
+  const max = Math.max(1, ...totals);
+  const W = Math.max(160, width), H = height, padB = 18, padL = 52;
+  const slot = (W - padL) / Math.max(1, days.length);
+  const bw = Math.max(1, Math.min(24, slot - 2));
+  const ticks = niceTicks(0, max, 3);
+  return html`<div ref=${ref} class="chart" onMouseLeave=${() => setHover(null)}>
+    ${unit !== "day" ? html`<div class="muted small">${unit === "week" ? "Weekly" : "Monthly"} totals</div>` : null}
+    <svg width=${W} height=${H}>
+      ${ticks.map((t) => html`<line class="grid-line" x1=${padL} x2=${W} y1=${H - padB - (t / max) * (H - padB - 6)} y2=${H - padB - (t / max) * (H - padB - 6)} />
+        <text class="axis-label" x=${padL - 6} y=${H - padB - (t / max) * (H - padB - 6) + 3.5} text-anchor="end">${format(t)}</text>`)}
+      ${days.map((d, i) => {
+        let y = H - padB;
+        const x = padL + i * slot + (slot - bw) / 2;
+        return html`<g onMouseEnter=${() => setHover(i)}>
+          <rect x=${padL + i * slot} y="0" width=${slot} height=${H - padB} fill="transparent" />
+          ${cats.map((c) => {
+            const v = d.parts[c.key] || 0;
+            const hh = (v / max) * (H - padB - 6);
+            y -= hh;
+            return hh > 0 ? html`<rect x=${x} y=${y + 1} width=${bw} height=${Math.max(0, hh - 2)} fill=${c.color} rx="1.5" opacity=${hover === null || hover === i ? 1 : 0.6} />` : null;
+          })}
+          ${days.length <= 16 || i % Math.ceil(days.length / 10) === 0 ? html`<text class="axis-label" x=${x + bw / 2} y=${H - 4} text-anchor="middle">${unit === "month" ? d.day : d.day.slice(5)}</text>` : null}
+        </g>`;
+      })}
+    </svg>
+    ${hover !== null ? html`<${Tip} x=${padL + hover * slot + slot / 2} W=${W}>
+      <div class="tt-head">${when(days[hover])} · ${format(totals[hover])}</div>
+      ${cats.map((c) => days[hover].parts[c.key] ? html`<div class="tt-row"><span class="key" style=${`background:${c.color};height:8px;width:8px`}></span><b>${format(days[hover].parts[c.key])}</b><span class="muted tt-name">${c.label}</span></div>` : null)}
+    </${Tip}>` : null}
+    <div class="legend" style="margin-top:6px">${cats.map((c) => html`<span><i class="key box" style=${`background:${c.color}`}></i>${c.label}</span>`)}</div>
+  </div>`;
+}
+
+/** Stacked area of shares over x. layers: [{key, label, color, points: [[x, value]]}]; values are normalized per x. */
+export function StackedArea({ layers, height = 200, xLabel = "step" }) {
+  const ref = useRef(null);
+  const width = useSize(ref);
+  const [hover, setHover] = useState(null);
+  const xs = [...new Set(layers.flatMap((l) => l.points.map((p) => p[0])))].sort((a, b) => a - b);
+  if (!xs.length) return html`<div ref=${ref} class="empty">No data</div>`;
+  const W = Math.max(160, width), H = height, pad = { l: 40, r: 10, t: 6, b: 22 };
+  const val = (l, x) => { const p = l.points.find((q) => q[0] === x); return p ? p[1] || 0 : 0; };
+  const totals = xs.map((x) => layers.reduce((s, l) => s + val(l, x), 0) || 1);
+  const x0 = xs[0], x1 = xs[xs.length - 1] === x0 ? x0 + 1 : xs[xs.length - 1];
+  const sx = (x) => pad.l + ((x - x0) / (x1 - x0)) * (W - pad.l - pad.r);
+  const sy = (v) => pad.t + (1 - v) * (H - pad.t - pad.b);
+  let acc = xs.map(() => 0);
+  const paths = layers.map((l) => {
+    const lo = acc.slice();
+    const hi = xs.map((x, i) => lo[i] + val(l, x) / totals[i]);
+    acc = hi;
+    const top = xs.map((x, i) => `${sx(x).toFixed(1)},${sy(hi[i]).toFixed(1)}`);
+    const bot = xs.slice().reverse().map((x, j) => { const i = xs.length - 1 - j; return `${sx(x).toFixed(1)},${sy(lo[i]).toFixed(1)}`; });
+    return { l, d: `M${top.join("L")}L${bot.join("L")}Z` };
+  });
+  const move = (e) => {
+    const r = ref.current.getBoundingClientRect();
+    const xv = x0 + ((e.clientX - r.left - pad.l) / (W - pad.l - pad.r)) * (x1 - x0);
+    let best = xs[0], bd = Infinity;
+    for (const x of xs) { const d = Math.abs(x - xv); if (d < bd) { bd = d; best = x; } }
+    setHover(best);
+  };
+  const hi = hover === null ? -1 : xs.indexOf(hover);
+  return html`<div ref=${ref} class="chart" onMouseLeave=${() => setHover(null)}>
+    <svg width=${W} height=${H} onMouseMove=${move}>
+      ${[0, 0.25, 0.5, 0.75, 1].map((t) => html`<line class="grid-line" x1=${pad.l} x2=${W - pad.r} y1=${sy(t)} y2=${sy(t)} />
+        <text class="axis-label" x=${pad.l - 6} y=${sy(t) + 3.5} text-anchor="end">${Math.round(t * 100)}%</text>`)}
+      ${paths.map((p) => html`<path d=${p.d} fill=${p.l.color} opacity="0.85" stroke="var(--surface)" stroke-width="1" />`)}
+      ${xs.filter((x, i) => xs.length <= 12 || i % Math.ceil(xs.length / 8) === 0).map((x) => html`<text class="axis-label" x=${sx(x)} y=${H - 6} text-anchor="middle">${x}</text>`)}
+      ${hover !== null ? html`<line class="crosshair" x1=${sx(hover)} x2=${sx(hover)} y1=${pad.t} y2=${H - pad.b} />` : null}
+    </svg>
+    ${hover !== null ? html`<${Tip} x=${sx(hover)} W=${W}>
+      <div class="tt-head">${xLabel} ${hover}</div>
+      ${layers.slice().reverse().map((l) => { const v = val(l, hover); return v ? html`<div class="tt-row"><span class="key" style=${`background:${l.color};height:8px;width:8px`}></span><b>${f.pct(v / totals[hi], 1)}</b><span class="muted tt-name">${l.label}</span></div>` : null; })}
+    </${Tip}>` : null}
+    <div class="legend" style="margin-top:6px">${layers.map((l) => html`<span><i class="key box" style=${`background:${l.color}`}></i>${l.label}</span>`)}</div>
+  </div>`;
+}
diff --git a/viewer/static/ui/common.js b/viewer/static/ui/common.js
new file mode 100644
index 0000000000000000000000000000000000000000..09bbd71cc3040e9c2c59cd8c261ca056cc8ec3dc
--- /dev/null
+++ b/viewer/static/ui/common.js
@@ -0,0 +1,200 @@
+import { html, useState, Link, setQuery } from "../lib.js";
+import * as f from "./fmt.js";
+
+// ------------------------------------------------------------------ icons (16px, stroke)
+const P = {
+  overview: "M3 12 12 4l9 8M5 10v10h14V10",
+  runs: "M3 17l5-6 4 3 5-7 4 4M3 21h18",
+  evals: "M12 3a9 9 0 1 0 0 18 9 9 0 0 0 0-18Zm0 4a5 5 0 1 0 0 10 5 5 0 0 0 0-10Zm0 4a1 1 0 1 0 0 2 1 1 0 0 0 0-2Z",
+  environments: "M4 7l8-4 8 4-8 4-8-4Zm0 5 8 4 8-4M4 17l8 4 8-4",
+  datasets: "M4 6c0-1.7 3.6-3 8-3s8 1.3 8 3-3.6 3-8 3-8-1.3-8-3Zm0 0v6c0 1.7 3.6 3 8 3s8-1.3 8-3V6M4 12v6c0 1.7 3.6 3 8 3s8-1.3 8-3v-6",
+  models: "M12 3 4 7.5v9L12 21l8-4.5v-9L12 3Zm0 0v9m8-4.5-8 4.5-8-4.5",
+  jobs: "M4 5h16v14H4zM4 9h16M8 13h3M8 16h6",
+  usage: "M12 3v18M16.5 7.5c0-1.7-2-3-4.5-3s-4.5 1.3-4.5 3 2 2.7 4.5 3.2 4.5 1.5 4.5 3.3-2 3-4.5 3-4.5-1.3-4.5-3",
+  reports: "M6 3h9l4 4v14H6zM14 3v5h5M9 12h7M9 16h7",
+  settings: "M12 9a3 3 0 1 0 0 6 3 3 0 0 0 0-6Zm7.4 3a7.4 7.4 0 0 0-.1-1.3l2-1.6-2-3.4-2.4 1a7.3 7.3 0 0 0-2.2-1.3L14.4 3h-4l-.4 2.4a7.3 7.3 0 0 0-2.2 1.3l-2.4-1-2 3.4 2 1.6a7.4 7.4 0 0 0 0 2.6l-2 1.6 2 3.4 2.4-1c.7.6 1.4 1 2.2 1.3l.4 2.4h4l.4-2.4c.8-.3 1.5-.7 2.2-1.3l2.4 1 2-3.4-2-1.6c.1-.4.1-.9.1-1.3Z",
+  close: "M6 6l12 12M18 6 6 18",
+  expand: "M4 14v6h6M20 10V4h-6M4 20l7-7M20 4l-7 7",
+  pin: "M9 4h6l-1 6 3 3H7l3-3-1-6ZM12 13v7",
+  up: "M6 15l6-6 6 6",
+  down: "M6 9l6 6 6-6",
+  right: "M9 6l6 6-6 6",
+  search: "M11 4a7 7 0 1 0 0 14 7 7 0 0 0 0-14Zm9 16-4-4",
+  copy: "M8 8h12v12H8zM4 16V4h12",
+  download: "M12 4v12m0 0-5-5m5 5 5-5M4 20h16",
+  external: "M14 4h6v6M20 4l-9 9M18 14v6H4V6h6",
+  compute: "M5 4h14v6H5zM5 14h14v6H5zM8 7h.01M8 17h.01",
+  plus: "M12 5v14M5 12h14",
+  terminal: "M4 5h16v14H4zM7 9l3 3-3 3M12 15h5",
+  logs: "M5 6h14M5 10h14M5 14h10M5 18h7",
+  stop: "M7 7h10v10H7z",
+  key: "M11 13.5 19.5 5M16.5 8l2.5 2.5M8 12a4 4 0 1 0 0 8 4 4 0 0 0 0-8Z",
+};
+export function Icon({ name, size = 16 }) {
+  return html`<svg viewBox="0 0 24 24" width=${size} height=${size} aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"><path d=${P[name] || ""} /></svg>`;
+}
+
+// ------------------------------------------------------------------ status vocabulary
+const STATUS = {
+  running: { label: "Running", svg: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="5.5" fill="none" stroke="currentColor" stroke-width="1.5" opacity=".3"/><path d="M7 1.5a5.5 5.5 0 0 1 5.5 5.5" fill="none" stroke="currentColor" stroke-width="1.5"><animateTransform attributeName="transform" type="rotate" from="0 7 7" to="360 7 7" dur="1.4s" repeatCount="indefinite"/></path></svg>` },
+  completed: { label: "Completed", svg: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="6" fill="currentColor" opacity=".14"/><path d="M4.2 7.2l1.9 1.9 3.8-4" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"/></svg>` },
+  failed: { label: "Failed", svg: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="6" fill="currentColor" opacity=".14"/><path d="M4.8 4.8l4.4 4.4M9.2 4.8l-4.4 4.4" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/></svg>` },
+  stopped: { label: "Stopped", svg: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="6" fill="currentColor" opacity=".12"/><rect x="4.6" y="4.6" width="4.8" height="4.8" rx="1" fill="currentColor"/></svg>` },
+  queued: { label: "Queued", svg: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="5.5" fill="none" stroke="currentColor" stroke-width="1.5" stroke-dasharray="2.2 2"/></svg>` },
+  starting: { label: "Starting", svg: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="5.5" fill="none" stroke="currentColor" stroke-width="1.5" stroke-dasharray="2.2 2" opacity=".45"/><path d="M7 1.5a5.5 5.5 0 0 1 5.5 5.5" fill="none" stroke="currentColor" stroke-width="1.5"><animateTransform attributeName="transform" type="rotate" from="0 7 7" to="360 7 7" dur="1.4s" repeatCount="indefinite"/></path></svg>` },
+  stalled: { label: "Stalled", svg: html`<svg viewBox="0 0 14 14"><path d="M7 1.8 12.8 12H1.2L7 1.8Z" fill="currentColor" opacity=".16"/><path d="M7 5.5v3M7 10.2v.1" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/></svg>` },
+  stopping: { label: "Stopping", svg: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="5.5" fill="none" stroke="currentColor" stroke-width="1.5" stroke-dasharray="2.2 2" opacity=".45"/><rect x="4.9" y="4.9" width="4.2" height="4.2" rx=".8" fill="currentColor"/></svg>` },
+};
+export function Status({ status, reason }) {
+  const s = STATUS[status] || { label: status || "—", svg: null };
+  return html`<span class=${`status ${status}`} title=${reason || ""}>${s.svg}${s.label}</span>`;
+}
+/** A runner's presence: online (heard from in the last 90 s) or offline, with icon and label. */
+export function Presence({ online, label }) {
+  return html`<span class=${`status ${online ? "online" : "offline"}`}><svg viewBox="0 0 14 14">${online
+    ? html`<circle cx="7" cy="7" r="6" fill="currentColor" opacity=".16"/><circle cx="7" cy="7" r="3" fill="currentColor"/>`
+    : html`<circle cx="7" cy="7" r="3.2" fill="none" stroke="currentColor" stroke-width="1.5"/>`}</svg>${label ?? (online ? "Online" : "Offline")}</span>`;
+}
+const LVL = {
+  ok: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="6" fill="currentColor" opacity=".14"/><path d="M4.2 7.2l1.9 1.9 3.8-4" fill="none" stroke="currentColor" stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"/></svg>`,
+  warn: html`<svg viewBox="0 0 14 14"><path d="M7 1.8 12.8 12H1.2L7 1.8Z" fill="currentColor" opacity=".16"/><path d="M7 5.5v3M7 10.2v.1" stroke="currentColor" stroke-width="1.6" stroke-linecap="round"/></svg>`,
+  bad: html`<svg viewBox="0 0 14 14"><circle cx="7" cy="7" r="6" fill="currentColor" opacity=".16"/><path d="M7 4v3.6M7 9.6v.1" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"/></svg>`,
+};
+const LVL_LABEL = { ok: "OK", warn: "Check", bad: "Problem" };
+export function Level({ level, label }) {
+  return html`<span class=${`lvl ${level}`}>${LVL[level]}${label ?? LVL_LABEL[level]}</span>`;
+}
+export const OUTCOME_LABEL = {
+  passed: "Passed", failed: "Failed", partial: "Partial", timeout: "Timed out", truncated: "Truncated",
+  max_turns: "Turn limit", infra_error: "Infra error (excluded)",
+};
+const VERDICTS = new Set(["passed", "failed", "partial"]);
+/**
+ * Whether a rollout's outcome is a pass/fail verdict: binary graders, and partial credit on a 0–1 scale
+ * (1 is a pass). Scalar rewards (reward models, judges, rubric scores) have no pass/fail; show the value.
+ */
+export function hasVerdict(kind, reward) {
+  if (kind === "binary") return true;
+  if (kind === "partial") return reward === null || reward === undefined || (reward >= 0 && reward <= 1);
+  return !kind;   // an environment that doesn't say: trust the stored outcome
+}
+/** The outcome of one rollout. `kind` is its environment's reward kind; scalar rewards show their value, not pass/fail. */
+export function Outcome({ outcome, reward, kind }) {
+  if (VERDICTS.has(outcome) && !hasVerdict(kind, reward)) {
+    return html`<span class="oc scored" title="Scalar reward: this grader gives a score, not a pass or a fail"><i></i>reward ${f.num(reward, 3)}</span>`;
+  }
+  return html`<span class=${`oc ${outcome}`}><i></i>${OUTCOME_LABEL[outcome] || outcome}</span>`;
+}
+
+// ------------------------------------------------------------------ layout pieces
+export function Loading({ label = "Loading…" }) { return html`<div class="loading">${label}</div>`; }
+export function Err({ error }) { return html`<div class="err">${String(error && error.message || error)}</div>`; }
+export function Empty({ children }) { return html`<div class="empty">${children}</div>`; }
+
+export function Tabs({ tabs, current, param = "tab" }) {
+  return html`<nav class="tabs">${tabs.map((t) => html`
+    <a href=${`?${param}=${t.id}`} class=${current === t.id ? "on" : ""}
+       onClick=${(e) => { e.preventDefault(); setQuery({ [param]: t.id === tabs[0].id ? null : t.id, rollout: null }, { replace: false }); }}>
+      ${t.label}${t.count !== undefined && t.count !== null ? html`<span class="count">${t.count}</span>` : null}
+    </a>`)}</nav>`;
+}
+
+export function Facts({ items }) {
+  return html`<div class="facts">${items.filter(Boolean).map(([k, v]) => html`<span class="f"><span class="k">${k}</span><b>${v}</b></span>`)}</div>`;
+}
+
+export function Provenance({ value, source }) {
+  if (!value) return null;
+  const text = { published: "Published data", simulated: "Simulated data", mixed: "Published metrics, simulated rollouts" }[value] || value;
+  return html`<span class="chip outline" title=${source || ""}>${text}</span>`;
+}
+
+// ------------------------------------------------------------------ table with sorting
+export function Table({ columns, rows, rowKey, onRow, initialSort, dense, empty = "Nothing here yet.", rowClass, maxHeight }) {
+  const [sort, setSort] = useState(initialSort || null);
+  let data = rows || [];
+  if (sort) {
+    const col = columns.find((c) => c.key === sort.key);
+    if (col) {
+      const get = col.sortValue || ((r) => r[col.key]);
+      data = [...data].sort((a, b) => {
+        const x = get(a), y = get(b);
+        if (x === y) return 0;
+        if (x === null || x === undefined) return 1;
+        if (y === null || y === undefined) return -1;
+        return (x < y ? -1 : 1) * sort.dir;
+      });
+    }
+  }
+  const head = columns.map((c) => {
+    const on = sort && sort.key === c.key;
+    const click = c.sortable === false ? null : () => setSort(on ? { key: c.key, dir: -sort.dir } : { key: c.key, dir: c.num ? -1 : 1 });
+    return html`<th class=${`${c.num ? "num" : ""} ${click ? "sortable" : ""}`} style=${c.width ? `width:${c.width}` : ""} onClick=${click}
+                   title=${c.title || ""}>${c.label}${on ? (sort.dir > 0 ? " ↑" : " ↓") : ""}</th>`;
+  });
+  return html`<div class="table-wrap" style=${maxHeight ? `max-height:${maxHeight}` : ""}>
+    <table class=${`t ${dense ? "dense" : ""}`}>
+      <thead><tr>${head}</tr></thead>
+      <tbody>
+        ${data.length === 0 ? html`<tr><td colspan=${columns.length}><div class="empty">${empty}</div></td></tr>` : null}
+        ${data.map((r, i) => html`<tr key=${rowKey ? rowKey(r) : i} class=${`${onRow ? "click" : ""} ${rowClass ? rowClass(r) : ""}`}
+            onClick=${onRow ? (e) => { if (e.target.closest("a,button,input")) return; onRow(r, e); } : null}>
+          ${columns.map((c) => html`<td class=${c.num ? "num" : ""} style=${c.tdStyle || ""}>${c.render ? c.render(r) : r[c.key]}</td>`)}
+        </tr>`)}
+      </tbody>
+    </table></div>`;
+}
+
+export function Bar({ value, max = 1, kind = "" }) {
+  const w = Math.max(0, Math.min(1, (value || 0) / (max || 1))) * 100;
+  return html`<span class=${`bar ${kind}`}><i style=${`width:${w}%`}></i></span>`;
+}
+
+export function Progress({ done, planned }) {
+  if (!planned) return html`<span class="muted">${f.int(done)}</span>`;
+  return html`<span class="progress"><${Bar} value=${done} max=${planned} /><span class="num nowrap">${f.int(done)} / ${f.int(planned)}</span></span>`;
+}
+
+export function Delta({ a, b, format = "pp", better = "up" }) {
+  if (a === null || a === undefined || b === null || b === undefined) return html`<span class="muted">—</span>`;
+  const d = b - a;
+  const good = better === "up" ? d > 0 : better === "down" ? d < 0 : null;
+  const cls = good === null || Math.abs(d) < 1e-9 ? "" : good ? "delta-up" : "delta-down";
+  const text = format === "pp" ? f.pp(d) : f.signed(d, 3);
+  return html`<span class=${cls}>${text}</span>`;
+}
+
+function partialStyle(a) {
+  const r = a.reward;
+  if (r === null || r === undefined || r === 0 || r === 1 || a.outcome === "infra_error") return "";
+  const pct = Math.round(Math.max(0, Math.min(1, r)) * 100);
+  return `background: color-mix(in oklab, var(--good) ${pct}%, #e9b3b3)`;
+}
+/** A scalar reward as the depth of one neutral hue, relative to the lowest and highest reward in its group. */
+function scoreStyle(a, lo, hi) {
+  const t = hi > lo ? (a.reward - lo) / (hi - lo) : 0.5;
+  return `background: color-mix(in oklab, var(--link) ${Math.round(18 + t * 64)}%, var(--surface-3))`;
+}
+
+/** One cell per attempt at a task. `kind` is the environment's reward kind (scalar rewards get no pass/fail colors). */
+export function Attempts({ attempts, current, onPick, big, kind }) {
+  const scalar = attempts.filter((a) => VERDICTS.has(a.outcome) && typeof a.reward === "number" && !hasVerdict(kind, a.reward));
+  const lo = Math.min(...scalar.map((a) => a.reward)), hi = Math.max(...scalar.map((a) => a.reward));
+  return html`<span class=${`attempts ${big ? "big" : ""}`}>${attempts.map((a) => {
+    const score = scalar.includes(a);
+    const what = score ? `reward ${f.num(a.reward, 3)}` : `${OUTCOME_LABEL[a.outcome] || a.outcome}${a.reward !== null && a.reward !== undefined ? ` · reward ${f.num(a.reward, 2)}` : ""}`;
+    return html`<button class=${`${score ? "scored" : a.outcome} ${current === a.id ? "on" : ""}`} style=${score ? scoreStyle(a, lo, hi) : hasVerdict(kind, a.reward) ? partialStyle(a) : ""}
+      title=${`#${a.sample + 1} · ${what}${a.advantage !== null && a.advantage !== undefined ? ` · advantage ${f.signed(a.advantage, 2)}` : ""}`}
+      aria-label=${`Attempt ${a.sample + 1}: ${what}`}
+      onClick=${(e) => { e.stopPropagation(); onPick && onPick(a); }}></button>`;
+  })}</span>`;
+}
+
+export function ProjectLink({ ctx, to, children, ...rest }) {
+  return html`<${Link} href=${`${ctx.base}${to}`} ...${rest}>${children}</${Link}>`;
+}
+
+export function Hist({ values, warm }) {
+  const max = Math.max(1, ...values);
+  return html`<span class=${`hist ${warm ? "warm" : ""}`}>${values.map((v) => html`<i style=${`height:${Math.max(1, (v / max) * 26)}px`} title=${String(v)}></i>`)}</span>`;
+}
diff --git a/viewer/static/ui/drawer.js b/viewer/static/ui/drawer.js
new file mode 100644
index 0000000000000000000000000000000000000000..79cd85ae86ea255e317f0856b4296aea07ac9a57
--- /dev/null
+++ b/viewer/static/ui/drawer.js
@@ -0,0 +1,135 @@
+import { html, useApi, useState, useEffect, useMemo, setQuery, Link, rolloutOrderOf } from "../lib.js";
+import { Icon, Loading, Err, Outcome, Attempts, OUTCOME_LABEL, hasVerdict } from "./common.js";
+import * as f from "./fmt.js";
+
+function highlight(text, q) {
+  if (!q || !text) return text;
+  const out = [];
+  const lower = text.toLowerCase(), ql = q.toLowerCase();
+  let i = 0, j;
+  while ((j = lower.indexOf(ql, i)) !== -1) {
+    out.push(text.slice(i, j), html`<mark>${text.slice(j, j + q.length)}</mark>`);
+    i = j + q.length;
+  }
+  out.push(text.slice(i));
+  return out;
+}
+
+function ToolCall({ call, result, q, openAll }) {
+  const [open, setOpen] = useState(false);
+  const shown = open || openAll || (q && ((result && result.content || "").toLowerCase().includes(q.toLowerCase()) || (call.arguments || "").toLowerCase().includes(q.toLowerCase())));
+  return html`<div>
+    <div class="toolchip" onClick=${() => setOpen(!open)}>
+      <span class="muted">${shown ? "▾" : "▸"}</span><span class="nm">${call.name}</span><span class="args">${highlight(call.arguments, q)}</span>
+    </div>
+    ${shown && result ? html`<div class="toolout">${highlight(result.content, q)}</div>` : null}
+  </div>`;
+}
+
+function Transcript({ messages, q, openAll }) {
+  const results = new Map(messages.filter((m) => m.role === "tool").map((m) => [m.tool_call_id, m]));
+  let turn = 0;
+  return html`${messages.filter((m) => m.role !== "tool").map((m) => {
+    if (m.role === "note") return html`<div class="msg note"><div class="msg-body">${m.content}</div></div>`;
+    if (m.role === "assistant") turn += 1;
+    return html`<div class="msg">
+      <div class="msg-head"><span class="role">${m.role}</span>${m.role === "assistant" ? html`<span class="muted">turn ${turn}</span>` : null}
+        ${m.tool_calls && m.tool_calls.length ? html`<span class="muted">· ${m.tool_calls.length} tool call${m.tool_calls.length > 1 ? "s" : ""}</span>` : null}</div>
+      ${m.content || m.reasoning ? html`<div class="msg-body">${m.reasoning ? html`<div class="reasoning">${highlight(m.reasoning, q)}</div>` : null}${highlight(m.content || "", q)}</div>` : null}
+      ${(m.tool_calls || []).map((c) => html`<${ToolCall} call=${c} result=${results.get(c.id)} q=${q} openAll=${openAll} />`)}
+    </div>`;
+  })}`;
+}
+
+export function RolloutDrawer({ ctx, id }) {
+  const { data, error } = useApi(`/rollouts/${id}`);
+  const [full, setFull] = useState(false);
+  const [q, setQ] = useState("");
+  const [openAll, setOpenAll] = useState(false);
+  const [raw, setRaw] = useState(false);
+  const sibs = data ? data.siblings : [];
+  const idx = sibs.findIndex((s) => s.id === id);
+  // next and previous follow the page's list when it has one (across groups), else this group's attempts
+  const listed = rolloutOrderOf();
+  const seq = listed.includes(id) ? listed : sibs.map((s) => s.id);
+  const pos = seq.indexOf(id);
+  const go = (d) => { if (pos >= 0 && seq[pos + d]) setQuery({ rollout: seq[pos + d] }); };
+  const close = () => setQuery({ rollout: null });
+  useEffect(() => {
+    const onKey = (e) => {
+      if (document.querySelector(".palette-overlay, .dialog-overlay")) return;
+      if (e.key === "Escape") { e.preventDefault(); close(); return; }   // also from the transcript search box
+      const t = e.target;
+      if (e.metaKey || e.ctrlKey || e.altKey || (t && (t.tagName === "INPUT" || t.tagName === "TEXTAREA" || t.tagName === "SELECT" || t.isContentEditable))) return;
+      if (e.key === "j" || e.key === "ArrowDown" || e.key === "ArrowRight") { e.preventDefault(); go(1); }
+      if (e.key === "k" || e.key === "ArrowUp" || e.key === "ArrowLeft") { e.preventDefault(); go(-1); }
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [id, data, pos, seq.length]);
+  let body;
+  if (error) body = html`<${Err} error=${error} />`;
+  else if (!data) body = html`<${Loading} />`;
+  else {
+    const r = data.rollout;
+    const t = r.timing || {};
+    const kind = data.env && data.env.reward_kind;
+    const scored = sibs.filter((s) => s.reward !== null && s.reward !== undefined);
+    const mean = scored.length ? scored.reduce((a, s) => a + s.reward, 0) / scored.length : null;
+    const verdict = scored.every((s) => hasVerdict(kind, s.reward));
+    const lo = Math.min(...scored.map((s) => s.reward)), hi = Math.max(...scored.map((s) => s.reward));
+    body = html`
+      <div class="row wrap" style="margin-bottom:10px">
+        <span class="small muted">Group</span>
+        <${Attempts} big=${true} attempts=${sibs} kind=${kind} current=${id} onPick=${(a) => setQuery({ rollout: a.id })} />
+        <span class="small muted">${verdict ? `${scored.filter((s) => s.reward >= 1).length}/${scored.length} passed · group mean ${f.num(mean, 2)}`
+          : scored.length ? `scalar rewards ${f.num(lo, 3)} to ${f.num(hi, 3)} · group mean ${f.num(mean, 3)}` : "no rewards"}</span>
+      </div>
+      ${r.phase === "train" && r.advantage !== null && r.advantage !== undefined ? html`<p class="small sec" style="margin:0 0 10px">
+        Reward ${f.num(r.reward, 2)} minus the group mean ${f.num(mean, 2)}${sibs.length > 1 ? ", divided by the group's standard deviation," : ""} gives this attempt's advantage <b>${f.signed(r.advantage, 3)}</b>.
+        ${scored.length && scored.every((s) => s.reward === scored[0].reward) ? " Every attempt in this group scored the same, so none of them moves the policy." : ""}</p>` : null}
+      <div class="idblock">
+        <div><span class="k">${data.run ? "Run" : "Eval"}</span><span class="v">${data.run ? html`<${Link} href=${`${ctx.base}/runs/${data.run.id}`}>${data.run.name}</${Link}>` : data.eval ? html`<${Link} href=${`${ctx.base}/evals/${data.eval.id}`}>${data.eval.benchmark}</${Link}>` : "—"}</span></div>
+        <div><span class="k">Step</span><span class="v mono">${r.phase}@${r.step ?? "—"}</span></div>
+        <div><span class="k">Model</span><span class="v">${data.model ? data.model.name : "—"}</span></div>
+        <div><span class="k">${data.env && data.env.id ? "Environment" : "Benchmark"}</span><span class="v">${data.env && data.env.id
+          ? html`<${Link} href=${`${ctx.base}/environments/${data.env.id}`}>${data.env.name}</${Link}>`
+          : data.eval ? html`<${Link} href=${`${ctx.base}/evals/${data.eval.id}`}>${data.eval.benchmark}</${Link}>` : "—"}</span></div>
+        <div><span class="k">Task</span><span class="v" title=${data.task.name}>${data.task.id ? html`<${Link} href=${`${ctx.base}/tasks/${data.task.id}`}>${data.task.name}</${Link}>` : "—"}</span></div>
+        <div><span class="k">Harness</span><span class="v">${r.harness || "—"}</span></div>
+        <div><span class="k">Tokens in / out</span><span class="v">${f.compact(r.tokens_in)} / ${f.compact(r.tokens_out)}${r.tokens_cached ? html` <span class="muted">(${f.compact(r.tokens_cached)} cached)</span>` : ""}</span></div>
+        <div><span class="k">Turns · tool calls</span><span class="v">${f.int(r.turns)} · ${f.int(r.tool_calls)}</span></div>
+        <div><span class="k">Time</span><span class="v" title=${Object.entries(t).map(([k, v]) => `${k} ${f.duration(v)}`).join(", ")}>${f.duration(r.duration_s)}
+          <span class="muted small">${t.generation ? ` · model ${f.duration(t.generation)} · env ${f.duration(t.environment)}` : ""}</span></span></div>
+      </div>
+      <div class="scores">
+        <div class="row" style="margin-bottom:4px"><h3>${hasVerdict(kind, r.reward) ? "Outcome" : "Reward"}</h3><span class="grow"></span><${Outcome} outcome=${r.outcome} reward=${r.reward} kind=${kind} /><span class="muted small">stop: ${r.stop_reason || "—"}</span>
+          ${r.staleness ? html`<span class="muted small">· sampled ${r.staleness} policy version${r.staleness > 1 ? "s" : ""} earlier</span>` : null}</div>
+        ${(data.scores || []).map((s) => html`<div class="score-row">
+          <span class=${`val ${s.value === null || !hasVerdict(kind, s.value) ? "" : s.value >= 1 ? "pass" : s.value <= 0 ? "fail" : ""}`}>${s.value === null ? "—" : f.num(s.value, 3)}</span>
+          <div><b>${s.name}</b>${s.weight !== undefined && s.weight !== 1 ? html` <span class="muted">weight ${s.weight}</span>` : null}<div class="small sec">${s.explanation}</div></div></div>`)}
+        ${data.grader ? html`<div class="small muted" style="margin-top:6px">Grader <b>${data.grader.name}</b> (${data.grader.kind}): ${data.grader.description}</div>` : null}
+      </div>
+      <div class="row" style="margin:18px 0 4px">
+        <h3>Transcript</h3><span class="muted small">${data.messages.length} messages</span><span class="grow"></span>
+        <input class="input search" style="width:220px" placeholder="Find in transcript" value=${q} onInput=${(e) => setQ(e.target.value)} />
+        <button class="btn small" onClick=${() => setOpenAll(!openAll)}>${openAll ? "Collapse tools" : "Expand tools"}</button>
+        <button class="btn small" onClick=${() => setRaw(!raw)}>${raw ? "Rendered" : "JSON"}</button>
+      </div>
+      ${data.rendered ? html`<p class="small muted" style="margin:0 0 6px">Demo data: this transcript is rendered from the attempt's recorded facts (turns, tool calls, outcome); the task's own text is shown as the user message.</p>` : null}
+      ${raw ? html`<pre class="code">${JSON.stringify(data.messages, null, 2)}</pre>` : html`<${Transcript} messages=${data.messages} q=${q} openAll=${openAll} />`}
+    `;
+  }
+  const r = data && data.rollout;
+  return html`<aside class=${`drawer ${full ? "full" : ""}`} aria-label="Rollout">
+    <div class="drawer-head">
+      <div class="where grow ellipsis">${r ? html`<b>${r.phase}@${r.step ?? "—"}</b> · ${data.task.name || "task"} · attempt <b>${idx + 1}/${sibs.length}</b>${seq === listed && seq.length > sibs.length ? html` <span class="muted">· ${pos + 1} of ${seq.length} listed</span>` : null}` : "Rollout"}</div>
+      <span class="kbd-hint" title="j or ↓ next, k or ↑ previous, Esc closes"><kbd>j</kbd> <kbd>k</kbd> <kbd>Esc</kbd></span>
+      <button class="icon-btn" title="Previous rollout (k or ↑)" disabled=${pos <= 0} onClick=${() => go(-1)}><${Icon} name="up" /></button>
+      <button class="icon-btn" title="Next rollout (j or ↓)" disabled=${pos < 0 || pos >= seq.length - 1} onClick=${() => go(1)}><${Icon} name="down" /></button>
+      <button class="icon-btn" title=${full ? "Narrow" : "Full width"} onClick=${() => setFull(!full)}><${Icon} name="expand" /></button>
+      <button class="icon-btn" title="Close (Esc)" onClick=${close}><${Icon} name="close" /></button>
+    </div>
+    <div class="drawer-body">${body}</div>
+  </aside>`;
+}
diff --git a/viewer/static/ui/fmt.js b/viewer/static/ui/fmt.js
new file mode 100644
index 0000000000000000000000000000000000000000..471c16ac6462d4df8fda98565c49f24b26046f2c
--- /dev/null
+++ b/viewer/static/ui/fmt.js
@@ -0,0 +1,122 @@
+// Number, time and money formatting. Every function returns "—" for missing values.
+const DASH = "—";
+const isNum = (v) => typeof v === "number" && isFinite(v);
+
+export function num(v, d = 2) {
+  if (!isNum(v)) return DASH;
+  return v.toLocaleString("en-US", { minimumFractionDigits: d, maximumFractionDigits: d });
+}
+export function int(v) {
+  if (!isNum(v)) return DASH;
+  return Math.round(v).toLocaleString("en-US");
+}
+export function pct(v, d = 1) {
+  if (!isNum(v)) return DASH;
+  return `${(v * 100).toFixed(d)}%`;
+}
+export function pp(v, d = 1) {
+  if (!isNum(v)) return DASH;
+  const s = (v * 100).toFixed(d);
+  return `${v > 0 ? "+" : v < 0 ? "−" : "±"}${Math.abs(+s).toFixed(d)} pp`;
+}
+export function signed(v, d = 3) {
+  if (!isNum(v)) return DASH;
+  return `${v > 0 ? "+" : v < 0 ? "−" : "±"}${Math.abs(v).toFixed(d)}`;
+}
+export function compact(v, d = 1) {
+  if (!isNum(v)) return DASH;
+  const a = Math.abs(v);
+  if (a >= 1e12) return `${(v / 1e12).toFixed(d)}T`;
+  if (a >= 1e9) return `${(v / 1e9).toFixed(d)}B`;
+  if (a >= 1e6) return `${(v / 1e6).toFixed(d)}M`;
+  if (a >= 1e4) return `${(v / 1e3).toFixed(d)}K`;
+  if (a >= 1e3) return `${(v / 1e3).toFixed(d + 0)}K`;
+  return a < 10 && !Number.isInteger(v) ? v.toFixed(2) : Math.round(v).toLocaleString("en-US");
+}
+export function sci(v) {
+  if (!isNum(v)) return DASH;
+  return v.toExponential(1).replace("e-", "e−");
+}
+export function money(v) {
+  if (!isNum(v)) return DASH;
+  const a = Math.abs(v);
+  if (a >= 1e6) return `$${(v / 1e6).toFixed(2)}M`;
+  if (a >= 1e4) return `$${(v / 1e3).toFixed(1)}K`;
+  if (a >= 100) return `$${Math.round(v).toLocaleString("en-US")}`;
+  return `$${v.toFixed(2)}`;
+}
+export function duration(s) {
+  if (!isNum(s)) return DASH;
+  s = Math.max(0, s);
+  if (s < 60) return `${s < 10 ? s.toFixed(1) : Math.round(s)}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${Math.round(s % 60)}s`;
+  const h = Math.floor(m / 60);
+  if (h < 48) return `${h}h ${m % 60}m`;
+  const d = Math.floor(h / 24);
+  return `${d}d ${h % 24}h`;
+}
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+export function date(t, withTime = true) {
+  if (!isNum(t)) return DASH;
+  const d = new Date(t * 1000);
+  const s = `${MONTHS[d.getUTCMonth()]} ${d.getUTCDate()}, ${d.getUTCFullYear()}`;
+  if (!withTime) return s;
+  return `${s}, ${String(d.getUTCHours()).padStart(2, "0")}:${String(d.getUTCMinutes()).padStart(2, "0")} UTC`;
+}
+export function shortDate(t) {
+  if (!isNum(t)) return DASH;
+  const d = new Date(t * 1000);
+  return `${MONTHS[d.getUTCMonth()]} ${d.getUTCDate()} ${String(d.getUTCHours()).padStart(2, "0")}:${String(d.getUTCMinutes()).padStart(2, "0")}`;
+}
+let NOW = null;
+export function setNow(t) { NOW = t; }
+export function now() { return NOW || Date.now() / 1000; }
+/** How long ago `t` was, by this page's clock or by `at` (a source's own frozen clock). */
+export function ago(t, at) {
+  if (!isNum(t)) return DASH;
+  const s = (isNum(at) ? at : now()) - t;
+  if (s < 0) return "just now";
+  if (s < 90) return "just now";
+  if (s < 3600) return `${Math.round(s / 60)} min ago`;
+  if (s < 86400 * 2) return `${Math.round(s / 3600)} h ago`;
+  if (s < 86400 * 60) return `${Math.round(s / 86400)} days ago`;
+  return date(t, false);
+}
+export function params(v) {
+  if (!isNum(v)) return DASH;
+  return v >= 1 ? `${+v.toFixed(1)}B` : `${Math.round(v * 1000)}M`;
+}
+export function by(format, v) {
+  switch (format) {
+    case "pct": return pct(v, v !== null && Math.abs(v) < 0.01 ? 2 : 1);
+    case "int": return int(v);
+    case "compact": return compact(v);
+    case "duration": return duration(v);
+    case "sci": return sci(v);
+    case "num1": return num(v, 1);
+    case "num2": return num(v, 2);
+    case "num4": return isNum(v) && Math.abs(v) < 0.001 ? sci(v) : num(v, 4);
+    default:
+      if (!isNum(v)) return DASH;
+      if (v !== 0 && Math.abs(v) < 0.001) return sci(v);
+      if (Math.abs(v) >= 1e3) return compact(v);
+      if (Math.abs(v) >= 100) return num(v, 0);
+      if (Math.abs(v) >= 10) return num(v, 1);
+      return num(v, 3);
+  }
+}
+export function plural(n, word, pl) { return `${int(n)} ${n === 1 ? word : (pl || word + "s")}`; }
+
+const RAW = new Set(["elo", "index", "score", "points"]);
+export function isRaw(metric) { return RAW.has(String(metric || "").toLowerCase()); }
+/** A benchmark score: a percentage for rates, the number itself for Elo/index scores. */
+export function score(metric, v, d = 1) {
+  if (!isNum(v)) return DASH;
+  if (isRaw(metric) || Math.abs(v) > 1.5) return num(v, Math.abs(v) >= 100 ? 0 : 1);
+  return pct(v, d);
+}
+export function scoreErr(metric, se) {
+  if (!isNum(se)) return "";
+  return isRaw(metric) ? `±${num(se, 1)}` : `±${num(se * 100, 1)}`;
+}
diff --git a/viewer/static/ui/forms.js b/viewer/static/ui/forms.js
new file mode 100644
index 0000000000000000000000000000000000000000..bdb2944fe841f3a480639274c8d920a19fcbdd38
--- /dev/null
+++ b/viewer/static/ui/forms.js
@@ -0,0 +1,141 @@
+// Form pieces shared by every page that changes something. The pattern: a title that is a verb and
+// an object, one sentence of purpose, helper text under each field, the consequences stated before
+// the button, and the verb on the button. Every form also shows the CLI line that does the same.
+import { html, useState, useEffect, useRef, copyText, setToken, needsToken } from "../lib.js";
+import { Icon } from "./common.js";
+
+export function Field({ label, help, error, optional, children, wide, group }) {
+  const body = html`<span class="field-label">${label}${optional ? html` <span class="muted">(optional)</span>` : null}</span>
+    ${children}
+    ${error ? html`<span class="field-error" role="alert">${error}</span>` : help ? html`<span class="field-help">${help}</span>` : null}`;
+  const cls = `field ${wide ? "wide" : ""}`;
+  // radio and checkbox groups are not one control, so they must not sit inside a <label>
+  return group ? html`<div class=${cls} role="group">${body}</div>` : html`<label class=${cls}>${body}</label>`;
+}
+
+/** A shell command with a copy button. The "$" prompt is drawn by CSS, so it is never copied. */
+export function Command({ cmd, compact }) {
+  const [copied, setCopied] = useState(false);
+  const copy = (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    copyText(cmd);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 1400);
+  };
+  const words = String(cmd).split(/( +)/).map((w) => (/^ +$/.test(w) ? w : html`<span class="w">${w}</span>`));
+  return html`<div class=${`cmd ${compact ? "compact" : ""}`}><code>${words}</code>
+    <button type="button" class="cmd-copy" title="Copy command" aria-label="Copy command" onClick=${copy}>${copied ? html`<span class="small">Copied</span>` : html`<${Icon} name="copy" size=${13} />`}</button></div>`;
+}
+
+export function Dialog({ title, purpose, onClose, children, width = 560 }) {
+  const box = useRef(null);
+  useEffect(() => {
+    const esc = (e) => { if (e.key === "Escape") onClose(); };
+    window.addEventListener("keydown", esc);
+    const first = box.current && box.current.querySelector("input, select, textarea");
+    if (first) first.focus();
+    return () => window.removeEventListener("keydown", esc);
+  }, []);
+  return html`<div class="dialog-overlay" onMouseDown=${(e) => e.target === e.currentTarget && onClose()}>
+    <div class="dialog" role="dialog" aria-modal="true" aria-label=${title} ref=${box} style=${`width:min(${width}px, calc(100vw - 24px))`}>
+      <div class="dialog-head"><h2>${title}</h2><span class="grow"></span>
+        <button type="button" class="icon-btn" aria-label="Close" onClick=${onClose}><${Icon} name="close" /></button></div>
+      ${purpose ? html`<p class="dialog-purpose">${purpose}</p>` : null}
+      ${children}
+    </div></div>`;
+}
+
+/** Asks for an API token in place of a failed or impossible change; the token stays in this browser. */
+export function TokenPrompt({ onSaved, reason }) {
+  const [t, setT] = useState("");
+  const save = (e) => {
+    e.preventDefault();
+    if (!t.trim()) return;
+    setToken(t.trim());
+    if (onSaved) onSaved();
+  };
+  return html`<div class="token-prompt" role="alert">
+    <div><b>${reason || "This server needs an API token for changes."}</b> <span class="sec">Paste one to continue; it is kept in this browser only.</span></div>
+    <div class="row" style="margin-top:8px"><input class="input mono grow" type="password" autocomplete="off" spellcheck="false" placeholder="pt_…"
+        aria-label="API token" value=${t} onInput=${(e) => setT(e.target.value)} onKeyDown=${(e) => e.key === "Enter" && save(e)} />
+      <button type="button" class="btn" disabled=${!t.trim()} onClick=${save}>Use token</button></div>
+    <div class="small muted" style="margin-top:6px">Create one on the server machine with <code>posttrain token create</code>, or under Settings → API tokens in a browser that has one.</div>
+  </div>`;
+}
+
+/**
+ * Runs a write and tracks it: [submit, {busy, error, auth}]. A 401 sets `auth` so the form can ask
+ * for a token; `submit.retry()` repeats the last call after a token was saved.
+ */
+export function useSubmit(fn) {
+  const [state, setState] = useState({ busy: false, error: null, auth: false });
+  const last = useRef([]);
+  const submit = async (...args) => {
+    last.current = args;
+    setState({ busy: true, error: null, auth: false });
+    try {
+      const out = await fn(...args);
+      setState({ busy: false, error: null, auth: false });
+      return out;
+    } catch (e) {
+      setState({ busy: false, error: e, auth: e && e.status === 401 });
+      return undefined;
+    }
+  };
+  submit.retry = () => submit(...last.current);
+  return [submit, state];
+}
+
+/** The line under a form's button: the token prompt on a 401, otherwise the server's own message. */
+export function SubmitProblem({ state, onRetry }) {
+  if (state.auth || (needsToken() && !state.busy && !state.error)) {
+    return html`<${TokenPrompt} reason=${state.auth ? "The server turned the change down: it needs a valid API token." : null} onSaved=${state.auth ? onRetry : null} />`;
+  }
+  if (state.error) return html`<div class="form-error" role="alert">${String(state.error.message || state.error)}</div>`;
+  return null;
+}
+
+export function Notice({ kind = "info", children }) {
+  return html`<div class=${`notice ${kind}`}>${children}</div>`;
+}
+
+// ------------------------------------------------------------------ Hugging Face model lookup
+const hfSeen = new Map();
+/** What the Hugging Face Hub says about a model id, as you type: found (revision, license, gating) or not. */
+export function useHfModel(id) {
+  const [info, setInfo] = useState(null);
+  useEffect(() => {
+    const v = String(id || "").trim();
+    if (!/^[\w.-]+\/[\w.-]+$/.test(v)) { setInfo(null); return undefined; }
+    if (hfSeen.has(v)) { setInfo(hfSeen.get(v)); return undefined; }
+    let live = true;
+    setInfo({ state: "checking", id: v });
+    const timer = setTimeout(async () => {
+      let out;
+      try {
+        const r = await fetch(`https://huggingface.co/api/models/${v}`);
+        if (r.ok) {
+          const d = await r.json();
+          out = { state: "found", id: v, sha: d.sha, gated: d.gated, license: (d.cardData || {}).license, pipeline: d.pipeline_tag };
+        } else out = { state: r.status === 401 || r.status === 404 ? "missing" : "error", id: v };
+      } catch (e) {
+        out = { state: "error", id: v };
+      }
+      hfSeen.set(v, out);
+      if (live) setInfo(out);
+    }, 350);
+    return () => { live = false; clearTimeout(timer); };
+  }, [id]);
+  return info;
+}
+
+export function hfLine(info) {
+  if (!info) return null;
+  if (info.state === "checking") return "Looking it up on Hugging Face…";
+  if (info.state === "found") {
+    return `Found: revision ${String(info.sha || "").slice(0, 7)}${info.license ? `, ${info.license}` : ""}${info.gated ? ", gated: its license must be accepted with the token the runner uses" : ", not gated"}.`;
+  }
+  if (info.state === "missing") return "Not found on Hugging Face, or private: a private model needs HF_TOKEN where it runs.";
+  return "Couldn't reach Hugging Face to check it.";
+}
diff --git a/viewer/static/vendor/InstrumentSerif-Italic.woff2 b/viewer/static/vendor/InstrumentSerif-Italic.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..480c34b7f2cb92f166544f1f8c4271a75d429c91
--- /dev/null
+++ b/viewer/static/vendor/InstrumentSerif-Italic.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2761bbd80096aa2af479145dfa4b7cd59040c10a5630fe9e5e76d099ac0fe00
+size 28052
diff --git a/viewer/static/vendor/InstrumentSerif-Regular.woff2 b/viewer/static/vendor/InstrumentSerif-Regular.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..4c206caed482aad3ce24c54a78ade5e7b7065265
--- /dev/null
+++ b/viewer/static/vendor/InstrumentSerif-Regular.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07b17c1a6d0117e70fde73f5e9d7d38150f085f3eff8b7e709901336af291eca
+size 27428
diff --git a/viewer/static/vendor/InterVariable.woff2 b/viewer/static/vendor/InterVariable.woff2
new file mode 100644
index 0000000000000000000000000000000000000000..e511e5e3baa7764a30e32b0e614f077c254084a2
--- /dev/null
+++ b/viewer/static/vendor/InterVariable.woff2
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:693b77d4f32ee9b8bfc995589b5fad5e99adf2832738661f5402f9978429a8e3
+size 352240
diff --git a/viewer/static/vendor/LICENSE-htm b/viewer/static/vendor/LICENSE-htm
new file mode 100644
index 0000000000000000000000000000000000000000..f1076112aebbfdd8b9c2cb42495d49a8a99fa788
--- /dev/null
+++ b/viewer/static/vendor/LICENSE-htm
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018 Google Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
\ No newline at end of file
diff --git a/viewer/static/vendor/LICENSE-instrument-serif.txt b/viewer/static/vendor/LICENSE-instrument-serif.txt
new file mode 100644
index 0000000000000000000000000000000000000000..076304c0b3da4ff7a9161d305b5289bc5b7c449b
--- /dev/null
+++ b/viewer/static/vendor/LICENSE-instrument-serif.txt
@@ -0,0 +1,92 @@
+Copyright 2022 The Instrument Serif Project Authors (https://github.com/Instrument/instrument-serif)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/viewer/static/vendor/LICENSE-inter.txt b/viewer/static/vendor/LICENSE-inter.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9b2ca37b3ffc77391d8b2ebef4a974ef32bf46ea
--- /dev/null
+++ b/viewer/static/vendor/LICENSE-inter.txt
@@ -0,0 +1,92 @@
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/viewer/static/vendor/LICENSE-preact b/viewer/static/vendor/LICENSE-preact
new file mode 100644
index 0000000000000000000000000000000000000000..da5389a93cbaa3ffcde17e2c76df6cb850912477
--- /dev/null
+++ b/viewer/static/vendor/LICENSE-preact
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present Jason Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/viewer/static/vendor/hooks.js b/viewer/static/vendor/hooks.js
new file mode 100644
index 0000000000000000000000000000000000000000..db76dd80709621071a2d4518bec634b5502bae3b
--- /dev/null
+++ b/viewer/static/vendor/hooks.js
@@ -0,0 +1,2 @@
+import{options as n}from"preact";var t,r,u,i,o=0,f=[],c=n,e=c.__b,a=c.__r,v=c.diffed,l=c.__c,m=c.unmount,p=c.__;function s(n,t){c.__h&&c.__h(r,n,o||t),o=0;var u=r.__H||(r.__H={__:[],__h:[]});return n>=u.__.length&&u.__.push({}),u.__[n]}function d(n){return o=1,y(D,n)}function y(n,u,i){var o=s(t++,2);if(o.t=n,!o.__c&&(o.__=[i?i(u):D(void 0,u),function(n){var t=o.__N?o.__N[0]:o.__[0],r=o.t(t,n);t!==r&&(o.__N=[r,o.__[1]],o.__c.setState({}))}],o.__c=r,!r.__f)){var f=function(n,t,r){if(!o.__c.__H)return!0;var u=!1,i=o.__c.props!==n;if(o.__c.__H.__.some(function(n){if(n.__N){u=!0;var t=n.__[0];n.__=n.__N,n.__N=void 0,t!==n.__[0]&&(i=!0)}}),c){var f=c.call(this,n,t,r);return u?f||i:f}return!u||i};r.__f=!0;var c=r.shouldComponentUpdate,e=r.componentWillUpdate;r.componentWillUpdate=function(n,t,r){if(this.__e){var u=c;c=void 0,f(n,t,r),c=u}e&&e.call(this,n,t,r)},r.shouldComponentUpdate=f}return o.__N||o.__}function h(n,u){var i=s(t++,3);!c.__s&&C(i.__H,u)&&(i.__=n,i.u=u,r.__H.__h.push(i))}function _(n,u){var i=s(t++,4);!c.__s&&C(i.__H,u)&&(i.__=n,i.u=u,r.__h.push(i))}function A(n){return o=5,T(function(){return{current:n}},[])}function F(n,t,r){o=6,_(function(){if("function"==typeof n){var r=n(t());return function(){n(null),r&&"function"==typeof r&&r()}}if(n)return n.current=t(),function(){return n.current=null}},null==r?r:r.concat(n))}function T(n,r){var u=s(t++,7);return C(u.__H,r)&&(u.__=n(),u.__H=r,u.__h=n),u.__}function q(n,t){return o=8,T(function(){return n},t)}function x(n){var u=r.context[n.__c],i=s(t++,9);return i.c=n,u?(null==i.__&&(i.__=!0,u.sub(r)),u.props.value):n.__}function P(n,t){c.useDebugValue&&c.useDebugValue(t?t(n):n)}function b(n){var u=s(t++,10),i=d();return u.__=n,r.componentDidCatch||(r.componentDidCatch=function(n,t){u.__&&u.__(n,t),i[1](n)}),[i[0],function(){i[1](void 0)}]}function g(){var n=s(t++,11);if(!n.__){for(var u=r.__v;null!==u&&!u.__m&&null!==u.__;)u=u.__;var i=u.__m||(u.__m=[0,0]);n.__="P"+i[0]+"-"+i[1]++}return n.__}function j(){for(var n;n=f.shift();){var t=n.__H;if(n.__P&&t)try{t.__h.some(z),t.__h.some(B),t.__h=[]}catch(r){t.__h=[],c.__e(r,n.__v)}}}c.__b=function(n){r=null,e&&e(n)},c.__=function(n,t){n&&t.__k&&t.__k.__m&&(n.__m=t.__k.__m),p&&p(n,t)},c.__r=function(n){a&&a(n),t=0;var i=(r=n.__c).__H;i&&(u===r?(i.__h=[],r.__h=[],i.__.some(function(n){n.__N&&(n.__=n.__N),n.u=n.__N=void 0})):(i.__h.some(z),i.__h.some(B),i.__h=[],t=0)),u=r},c.diffed=function(n){v&&v(n);var t=n.__c;t&&t.__H&&(t.__H.__h.length&&(1!==f.push(t)&&i===c.requestAnimationFrame||((i=c.requestAnimationFrame)||w)(j)),t.__H.__.some(function(n){n.u&&(n.__H=n.u,n.u=void 0)})),u=r=null},c.__c=function(n,t){t.some(function(n){try{n.__h.some(z),n.__h=n.__h.filter(function(n){return!n.__||B(n)})}catch(r){t.some(function(n){n.__h&&(n.__h=[])}),t=[],c.__e(r,n.__v)}}),l&&l(n,t)},c.unmount=function(n){m&&m(n);var t,r=n.__c;r&&r.__H&&(r.__H.__.some(function(n){try{z(n)}catch(n){t=n}}),r.__H=void 0,t&&c.__e(t,r.__v))};var k="function"==typeof requestAnimationFrame;function w(n){var t,r=function(){clearTimeout(u),k&&cancelAnimationFrame(t),setTimeout(n)},u=setTimeout(r,35);k&&(t=requestAnimationFrame(r))}function z(n){var t=r,u=n.__c;"function"==typeof u&&(n.__c=void 0,u()),r=t}function B(n){var t=r;n.__c=n.__(),r=t}function C(n,t){return!n||n.length!==t.length||t.some(function(t,r){return t!==n[r]})}function D(n,t){return"function"==typeof t?t(n):t}export{q as useCallback,x as useContext,P as useDebugValue,h as useEffect,b as useErrorBoundary,g as useId,F as useImperativeHandle,_ as useLayoutEffect,T as useMemo,y as useReducer,A as useRef,d as useState};
+//# sourceMappingURL=hooks.module.js.map
diff --git a/viewer/static/vendor/htm.js b/viewer/static/vendor/htm.js
new file mode 100644
index 0000000000000000000000000000000000000000..4a6228f9ef785ed178dd8ec5e1443bf93d55deb0
--- /dev/null
+++ b/viewer/static/vendor/htm.js
@@ -0,0 +1 @@
+var n=function(t,s,r,e){var u;s[0]=0;for(var h=1;h<s.length;h++){var p=s[h++],a=s[h]?(s[0]|=p?1:2,r[s[h++]]):s[++h];3===p?e[0]=a:4===p?e[1]=Object.assign(e[1]||{},a):5===p?(e[1]=e[1]||{})[s[++h]]=a:6===p?e[1][s[++h]]+=a+"":p?(u=t.apply(a,n(t,a,r,["",null])),e.push(u),a[0]?s[0]|=2:(s[h-2]=0,s[h]=u)):e.push(a)}return e},t=new Map;export default function(s){var r=t.get(this);return r||(r=new Map,t.set(this,r)),(r=n(this,r.get(s)||(r.set(s,r=function(n){for(var t,s,r=1,e="",u="",h=[0],p=function(n){1===r&&(n||(e=e.replace(/^\s*\n\s*|\s*\n\s*$/g,"")))?h.push(0,n,e):3===r&&(n||e)?(h.push(3,n,e),r=2):2===r&&"..."===e&&n?h.push(4,n,0):2===r&&e&&!n?h.push(5,0,!0,e):r>=5&&((e||!n&&5===r)&&(h.push(r,0,e,s),r=6),n&&(h.push(r,n,0,s),r=6)),e=""},a=0;a<n.length;a++){a&&(1===r&&p(),p(a));for(var l=0;l<n[a].length;l++)t=n[a][l],1===r?"<"===t?(p(),h=[h],r=3):e+=t:4===r?"--"===e&&">"===t?(r=1,e=""):e=t+e[0]:u?t===u?u="":e+=t:'"'===t||"'"===t?u=t:">"===t?(p(),r=1):r&&("="===t?(r=5,s=e,e=""):"/"===t&&(r<5||">"===n[a][l+1])?(p(),3===r&&(h=h[0]),r=h,(h=h[0]).push(2,0,r),r=0):" "===t||"\t"===t||"\n"===t||"\r"===t?(p(),r=2):e+=t),3===r&&"!--"===e&&(r=4,h=h[0])}return p(),h}(s)),r),arguments,[])).length>1?r:r[0]}
diff --git a/viewer/static/vendor/preact.js b/viewer/static/vendor/preact.js
new file mode 100644
index 0000000000000000000000000000000000000000..d78e38ff2766cdbf32199886d99111d047f637de
--- /dev/null
+++ b/viewer/static/vendor/preact.js
@@ -0,0 +1,2 @@
+var n,l,u,t,i,r,o,e,f,c,a,s,h,p,v,y,d={},w=[],_=/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,g=Array.isArray;function m(n,l){for(var u in l)n[u]=l[u];return n}function b(n){n&&n.parentNode&&n.parentNode.removeChild(n)}function k(l,u,t){var i,r,o,e={};for(o in u)"key"==o?i=u[o]:"ref"==o?r=u[o]:e[o]=u[o];if(arguments.length>2&&(e.children=arguments.length>3?n.call(arguments,2):t),"function"==typeof l&&null!=l.defaultProps)for(o in l.defaultProps)void 0===e[o]&&(e[o]=l.defaultProps[o]);return x(l,e,i,r,null)}function x(n,t,i,r,o){var e={type:n,props:t,key:i,ref:r,__k:null,__:null,__b:0,__e:null,__c:null,constructor:void 0,__v:null==o?++u:o,__i:-1,__u:0};return null==o&&null!=l.vnode&&l.vnode(e),e}function M(){return{current:null}}function S(n){return n.children}function C(n,l){this.props=n,this.context=l}function $(n,l){if(null==l)return n.__?$(n.__,n.__i+1):null;for(var u;l<n.__k.length;l++)if(null!=(u=n.__k[l])&&null!=u.__e)return u.__e;return"function"==typeof n.type?$(n):null}function I(n){if(n.__P&&n.__d){var u=n.__v,t=u.__e,i=[],r=[],o=m({},u);o.__v=u.__v+1,l.vnode&&l.vnode(o),q(n.__P,o,u,n.__n,n.__P.namespaceURI,32&u.__u?[t]:null,i,null==t?$(u):t,!!(32&u.__u),r),o.__v=u.__v,o.__.__k[o.__i]=o,D(i,o,r),u.__e=u.__=null,o.__e!=t&&P(o)}}function P(n){if(null!=(n=n.__)&&null!=n.__c)return n.__e=n.__c.base=null,n.__k.some(function(l){if(null!=l&&null!=l.__e)return n.__e=n.__c.base=l.__e}),P(n)}function A(n){(!n.__d&&(n.__d=!0)&&i.push(n)&&!H.__r++||r!=l.debounceRendering)&&((r=l.debounceRendering)||o)(H)}function H(){try{for(var n,l=1;i.length;)i.length>l&&i.sort(e),n=i.shift(),l=i.length,I(n)}finally{i.length=H.__r=0}}function L(n,l,u,t,i,r,o,e,f,c,a){var s,h,p,v,y,_,g=t&&t.__k||w,m=l.length;for(f=T(u,l,g,f,m),s=0;s<m;s++)null!=(p=u.__k[s])&&(h=-1!=p.__i&&g[p.__i]||d,p.__i=s,_=q(n,p,h,i,r,o,e,f,c,a),v=p.__e,p.ref&&h.ref!=p.ref&&(h.ref&&J(h.ref,null,p),a.push(p.ref,p.__c||v,p)),null==y&&null!=v&&(y=v),4&p.__u?(f=j(p,f,n),h.__e&&(h.__e=null)):"function"==typeof p.type&&void 0!==_?f=_:v&&(f=v.nextSibling),p.__u&=-7);return u.__e=y,f}function T(n,l,u,t,i){var r,o,e,f,c,a=u.length,s=a,h=0;for(n.__k=new Array(i),r=0;r<i;r++)null!=(o=l[r])&&"boolean"!=typeof o&&"function"!=typeof o?("string"==typeof o||"number"==typeof o||"bigint"==typeof o||o.constructor==String?o=n.__k[r]=x(null,o,null,null,null):g(o)?o=n.__k[r]=x(S,{children:o},null,null,null):void 0===o.constructor&&o.__b>0?o=n.__k[r]=x(o.type,o.props,o.key,o.ref?o.ref:null,o.__v):n.__k[r]=o,f=r+h,o.__=n,o.__b=n.__b+1,e=null,-1!=(c=o.__i=O(o,u,f,s))&&(s--,(e=u[c])&&(e.__u|=2)),null==e||null==e.__v?(-1==c&&(i>a?h--:i<a&&h++),"function"!=typeof o.type&&(o.__u|=4)):c!=f&&(c==f-1?h--:c==f+1?h++:(c>f?h--:h++,o.__u|=4))):n.__k[r]=null;if(s)for(r=0;r<a;r++)null!=(e=u[r])&&0==(2&e.__u)&&(e.__e==t&&(t=$(e)),K(e,e));return t}function j(n,l,u){var t,i;if("function"==typeof n.type){for(t=n.__k,i=0;t&&i<t.length;i++)t[i]&&(t[i].__=n,l=j(t[i],l,u));return l}n.__e!=l&&(l&&n.type&&!l.parentNode&&(l=$(n)),l=u.insertBefore(n.__e,l||null));do{l=l&&l.nextSibling}while(null!=l&&8==l.nodeType);return l}function F(n,l){return l=l||[],null==n||"boolean"==typeof n||(g(n)?n.some(function(n){F(n,l)}):l.push(n)),l}function O(n,l,u,t){var i,r,o,e=n.key,f=n.type,c=l[u],a=null!=c&&0==(2&c.__u);if(null===c&&null==e||a&&e==c.key&&f==c.type)return u;if(t>(a?1:0))for(i=u-1,r=u+1;i>=0||r<l.length;)if(null!=(c=l[o=i>=0?i--:r++])&&0==(2&c.__u)&&e==c.key&&f==c.type)return o;return-1}function z(n,l,u){"-"==l[0]?n.setProperty(l,null==u?"":u):n[l]=null==u?"":"number"!=typeof u||_.test(l)?u:u+"px"}function N(n,l,u,t,i){var r,o;n:if("style"==l)if("string"==typeof u)n.style.cssText=u;else{if("string"==typeof t&&(n.style.cssText=t=""),t)for(l in t)u&&l in u||z(n.style,l,"");if(u)for(l in u)t&&u[l]==t[l]||z(n.style,l,u[l])}else if("o"==l[0]&&"n"==l[1])r=l!=(l=l.replace(s,"$1")),o=l.toLowerCase(),l=o in n||"onFocusOut"==l||"onFocusIn"==l?o.slice(2):l.slice(2),n.l||(n.l={}),n.l[l+r]=u,u?t?u[a]=t[a]:(u[a]=h,n.addEventListener(l,r?v:p,r)):n.removeEventListener(l,r?v:p,r);else{if("http://www.w3.org/2000/svg"==i)l=l.replace(/xlink(H|:h)/,"h").replace(/sName$/,"s");else if("width"!=l&&"height"!=l&&"href"!=l&&"list"!=l&&"form"!=l&&"tabIndex"!=l&&"download"!=l&&"rowSpan"!=l&&"colSpan"!=l&&"role"!=l&&"popover"!=l&&l in n)try{n[l]=null==u?"":u;break n}catch(n){}"function"==typeof u||(null==u||!1===u&&"-"!=l[4]?n.removeAttribute(l):n.setAttribute(l,"popover"==l&&1==u?"":u))}}function V(n){return function(u){if(this.l){var t=this.l[u.type+n];if(null==u[c])u[c]=h++;else if(u[c]<t[a])return;return t(l.event?l.event(u):u)}}}function q(n,u,t,i,r,o,e,f,c,a){var s,h,p,v,y,d,_,k,x,M,I,P,A,H,T,j,F=u.type;if(void 0!==u.constructor)return null;128&t.__u&&(c=!!(32&t.__u),o=[f=u.__e=t.__e]),(s=l.__b)&&s(u);n:if("function"==typeof F){h=e.length;try{if(x=u.props,M=F.prototype&&F.prototype.render,I=(s=F.contextType)&&i[s.__c],P=s?I?I.props.value:s.__:i,t.__c?k=(p=u.__c=t.__c).__=p.__E:(M?u.__c=p=new F(x,P):(u.__c=p=new C(x,P),p.constructor=F,p.render=Q),I&&I.sub(p),p.state||(p.state={}),p.__n=i,v=p.__d=!0,p.__h=[],p._sb=[]),M&&null==p.__s&&(p.__s=p.state),M&&null!=F.getDerivedStateFromProps&&(p.__s==p.state&&(p.__s=m({},p.__s)),m(p.__s,F.getDerivedStateFromProps(x,p.__s))),y=p.props,d=p.state,p.__v=u,v)M&&null==F.getDerivedStateFromProps&&null!=p.componentWillMount&&p.componentWillMount(),M&&null!=p.componentDidMount&&p.__h.push(p.componentDidMount);else{if(M&&null==F.getDerivedStateFromProps&&x!==y&&null!=p.componentWillReceiveProps&&p.componentWillReceiveProps(x,P),u.__v==t.__v||!p.__e&&null!=p.shouldComponentUpdate&&!1===p.shouldComponentUpdate(x,p.__s,P)){u.__v!=t.__v&&(p.props=x,p.state=p.__s,p.__d=!1),u.__e=t.__e,u.__k=t.__k,u.__k.some(function(n){n&&(n.__=u)}),w.push.apply(p.__h,p._sb),p._sb=[],p.__h.length&&e.push(p),f=$(t);break n}null!=p.componentWillUpdate&&p.componentWillUpdate(x,p.__s,P),M&&null!=p.componentDidUpdate&&p.__h.push(function(){p.componentDidUpdate(y,d,_)})}if(p.context=P,p.props=x,p.__P=n,p.__e=!1,A=l.__r,H=0,M)p.state=p.__s,p.__d=!1,A&&A(u),s=p.render(p.props,p.state,p.context),w.push.apply(p.__h,p._sb),p._sb=[];else do{p.__d=!1,A&&A(u),s=p.render(p.props,p.state,p.context),p.state=p.__s}while(p.__d&&++H<25);p.state=p.__s,null!=p.getChildContext&&(i=m(m({},i),p.getChildContext())),M&&!v&&null!=p.getSnapshotBeforeUpdate&&(_=p.getSnapshotBeforeUpdate(y,d)),T=null!=s&&s.type===S&&null==s.key?E(s.props.children):s,f=L(n,g(T)?T:[T],u,t,i,r,o,e,f,c,a),p.base=u.__e,u.__u&=-161,p.__h.length&&e.push(p),k&&(p.__E=p.__=null)}catch(n){if(e.length=h,u.__v=null,c||null!=o){if(n.then){for(u.__u|=c?160:128;f&&8==f.nodeType&&f.nextSibling;)f=f.nextSibling;null!=o&&(o[o.indexOf(f)]=null),u.__e=f}else if(null!=o)for(j=o.length;j--;)b(o[j])}else u.__e=t.__e;null==u.__k&&(u.__k=t.__k||[]),n.then||B(u),l.__e(n,u,t)}}else null==o&&u.__v==t.__v?(u.__k=t.__k,u.__e=t.__e):f=u.__e=G(t.__e,u,t,i,r,o,e,c,a);return(s=l.diffed)&&s(u),128&u.__u?void 0:f}function B(n){n&&(n.__c&&(n.__c.__e=!0),n.__k&&n.__k.some(B))}function D(n,u,t){for(var i=0;i<t.length;i++)J(t[i],t[++i],t[++i]);l.__c&&l.__c(u,n),n.some(function(u){try{n=u.__h,u.__h=[],n.some(function(n){n.call(u)})}catch(n){l.__e(n,u.__v)}})}function E(n){return"object"!=typeof n||null==n||n.__b>0?n:g(n)?n.map(E):void 0!==n.constructor?null:m({},n)}function G(u,t,i,r,o,e,f,c,a){var s,h,p,v,y,w,_,m=i.props||d,k=t.props,x=t.type;if("svg"==x?o="http://www.w3.org/2000/svg":"math"==x?o="http://www.w3.org/1998/Math/MathML":o||(o="http://www.w3.org/1999/xhtml"),null!=e)for(s=0;s<e.length;s++)if((y=e[s])&&"setAttribute"in y==!!x&&(x?y.localName==x:3==y.nodeType)){u=y,e[s]=null;break}if(null==u){if(null==x)return document.createTextNode(k);u=document.createElementNS(o,x,k.is&&k),c&&(l.__m&&l.__m(t,e),c=!1),e=null}if(null==x)m===k||c&&u.data==k||(u.data=k);else{if(e="textarea"==x&&null!=k.defaultValue?null:e&&n.call(u.childNodes),!c&&null!=e)for(m={},s=0;s<u.attributes.length;s++)m[(y=u.attributes[s]).name]=y.value;for(s in m)y=m[s],"dangerouslySetInnerHTML"==s?p=y:"children"==s||s in k||"value"==s&&"defaultValue"in k||"checked"==s&&"defaultChecked"in k||N(u,s,null,y,o);for(s in k)y=k[s],"children"==s?v=y:"dangerouslySetInnerHTML"==s?h=y:"value"==s?w=y:"checked"==s?_=y:c&&"function"!=typeof y||m[s]===y||N(u,s,y,m[s],o);if(h)c||p&&(h.__html==p.__html||h.__html==u.innerHTML)||(u.innerHTML=h.__html),t.__k=[];else if(p&&(u.innerHTML=""),L("template"==t.type?u.content:u,g(v)?v:[v],t,i,r,"foreignObject"==x?"http://www.w3.org/1999/xhtml":o,e,f,e?e[0]:i.__k&&$(i,0),c,a),null!=e)for(s=e.length;s--;)b(e[s]);c&&"textarea"!=x||(s="value","progress"==x&&null==w?u.removeAttribute("value"):null!=w&&(w!==u[s]||"progress"==x&&!w||"option"==x&&w!=m[s])&&N(u,s,w,m[s],o),s="checked",null!=_&&_!=u[s]&&N(u,s,_,m[s],o))}return u}function J(n,u,t){try{if("function"==typeof n){var i="function"==typeof n.__u;i&&n.__u(),i&&null==u||(n.__u=n(u))}else n.current=u}catch(n){l.__e(n,t)}}function K(n,u,t){var i,r;if(l.unmount&&l.unmount(n),(i=n.ref)&&(i.current&&i.current!=n.__e||J(i,null,u)),null!=(i=n.__c)){if(i.componentWillUnmount)try{i.componentWillUnmount()}catch(n){l.__e(n,u)}i.base=i.__P=i.__n=null}if(i=n.__k)for(r=0;r<i.length;r++)i[r]&&K(i[r],u,t||"function"!=typeof n.type);t||b(n.__e),n.__c=n.__=n.__e=void 0}function Q(n,l,u){return this.constructor(n,u)}function R(u,t,i){var r,o,e,f;t==document&&(t=document.documentElement),l.__&&l.__(u,t),o=(r="function"==typeof i)?null:i&&i.__k||t.__k,e=[],f=[],q(t,u=(!r&&i||t).__k=k(S,null,[u]),o||d,d,t.namespaceURI,!r&&i?[i]:o?null:t.firstChild?n.call(t.childNodes):null,e,!r&&i?i:o?o.__e:t.firstChild,r,f),D(e,u,f),u.props.children=null}function U(n,l){R(n,l,U)}function W(l,u,t){var i,r,o,e,f=m({},l.props);for(o in l.type&&l.type.defaultProps&&(e=l.type.defaultProps),u)"key"==o?i=u[o]:"ref"==o?r=u[o]:f[o]=void 0===u[o]&&null!=e?e[o]:u[o];return arguments.length>2&&(f.children=arguments.length>3?n.call(arguments,2):t),x(l.type,f,i||l.key,r||l.ref,null)}function X(n){function l(n){var u,t;return this.getChildContext||(u=new Set,(t={})[l.__c]=this,this.getChildContext=function(){return t},this.componentWillUnmount=function(){u=null},this.shouldComponentUpdate=function(n){this.props.value!=n.value&&u.forEach(function(n){n.__e=!0,A(n)})},this.sub=function(n){u.add(n);var l=n.componentWillUnmount;n.componentWillUnmount=function(){u&&u.delete(n),l&&l.call(n)}}),n.children}return l.__c="__cC"+y++,l.__=n,l.Provider=l.__l=(l.Consumer=function(n,l){return n.children(l)}).contextType=l,l}n=w.slice,l={__e:function(n,l,u,t){for(var i,r,o;l=l.__;)if((i=l.__c)&&!i.__)try{if((r=i.constructor)&&null!=r.getDerivedStateFromError&&(i.setState(r.getDerivedStateFromError(n)),o=i.__d),null!=i.componentDidCatch&&(i.componentDidCatch(n,t||{}),o=i.__d),o)return i.__E=i}catch(l){n=l}throw n}},u=0,t=function(n){return null!=n&&void 0===n.constructor},C.prototype.setState=function(n,l){var u;u=null!=this.__s&&this.__s!=this.state?this.__s:this.__s=m({},this.state),"function"==typeof n&&(n=n(m({},u),this.props)),n&&m(u,n),null!=n&&this.__v&&(l&&this._sb.push(l),A(this))},C.prototype.forceUpdate=function(n){this.__v&&(this.__e=!0,n&&this.__h.push(n),A(this))},C.prototype.render=S,i=[],o="function"==typeof Promise?Promise.prototype.then.bind(Promise.resolve()):setTimeout,e=function(n,l){return n.__v.__b-l.__v.__b},H.__r=0,f=Math.random().toString(8),c="__d"+f,a="__a"+f,s=/(PointerCapture)$|Capture$/i,h=0,p=V(!1),v=V(!0),y=0;export{C as Component,S as Fragment,W as cloneElement,X as createContext,k as createElement,M as createRef,k as h,U as hydrate,t as isValidElement,l as options,R as render,F as toChildArray};
+//# sourceMappingURL=preact.module.js.map
diff --git a/viewer/workspace.py b/viewer/workspace.py
new file mode 100644
index 0000000000000000000000000000000000000000..90a84a8c1de5f14019da5802b88fafef9316cbf8
--- /dev/null
+++ b/viewer/workspace.py
@@ -0,0 +1,290 @@
+"""The writable workspace: your own projects, runs, datasets and jobs.
+
+Same protocol as the built sources (PROTOCOL.md) plus the tables a live platform needs: users and
+API tokens, compute targets, runners, and run logs. Jobs launched from the website are rows in
+`jobs` with status `queued`; a runner (`posttrain agent`) claims and executes them.
+
+Persistence: `$VIEWER_DATA/workspace.sqlite`. If `POSTTRAIN_SYNC_REPO` (a private Hugging Face
+dataset) and a token are set, the file is restored from it on start and uploaded after writes.
+"""
+import hashlib
+import json
+import os
+import secrets
+import sqlite3
+import threading
+import time
+from pathlib import Path
+
+from . import db
+
+EXTRA = """
+CREATE TABLE IF NOT EXISTS users (id TEXT PRIMARY KEY, name TEXT, email TEXT, created_at REAL);
+CREATE TABLE IF NOT EXISTS tokens (hash TEXT PRIMARY KEY, prefix TEXT, user_id TEXT, name TEXT,
+  created_at REAL, last_used REAL, revoked INTEGER DEFAULT 0, scope TEXT, expires REAL);
+CREATE TABLE IF NOT EXISTS compute_targets (id TEXT PRIMARY KEY, org_id TEXT, name TEXT, kind TEXT,
+  config TEXT, created_at REAL, created_by TEXT, UNIQUE(org_id, name));
+CREATE TABLE IF NOT EXISTS runners (id TEXT PRIMARY KEY, org_id TEXT, name TEXT, hostname TEXT,
+  targets TEXT, version TEXT, started_at REAL, last_seen REAL);
+CREATE TABLE IF NOT EXISTS logs (run_id TEXT, seq INTEGER, t REAL, stream TEXT, text TEXT,
+  PRIMARY KEY(run_id, seq)) WITHOUT ROWID;
+CREATE INDEX IF NOT EXISTS jobs_queue ON jobs(status, target);
+CREATE TABLE IF NOT EXISTS project_settings (project_id TEXT PRIMARY KEY, base_model TEXT, stages TEXT,
+  budget_usd REAL, updated_at REAL, updated_by TEXT);
+CREATE TABLE IF NOT EXISTS suites (project_id TEXT, name TEXT, benchmarks TEXT, updated_at REAL, updated_by TEXT,
+  PRIMARY KEY(project_id, name));
+CREATE TABLE IF NOT EXISTS stage_state (project_id TEXT, stage TEXT, skipped INTEGER, note TEXT, by TEXT, at REAL,
+  PRIMARY KEY(project_id, stage));
+CREATE TABLE IF NOT EXISTS acks (id TEXT PRIMARY KEY, project_id TEXT, model_key TEXT, model_id TEXT, model_name TEXT,
+  suite TEXT, benchmark TEXT, note TEXT, by TEXT, at REAL, comparison TEXT);
+CREATE INDEX IF NOT EXISTS acks_model ON acks(project_id, model_key, suite, benchmark);
+CREATE TABLE IF NOT EXISTS promotions (model_id TEXT PRIMARY KEY, project_id TEXT, run_id TEXT, step INTEGER,
+  checkpoint_id TEXT, weights TEXT, weights_target TEXT, pushed_to TEXT, rule TEXT, steps TEXT, notes TEXT, by TEXT, at REAL,
+  replaced_by TEXT);
+CREATE TABLE IF NOT EXISTS model_aliases (project_id TEXT, alias TEXT, model_id TEXT, set_by TEXT, set_at REAL,
+  PRIMARY KEY(project_id, alias));
+CREATE TABLE IF NOT EXISTS audit (project_id TEXT, t REAL, user TEXT, action TEXT, object TEXT, detail TEXT);
+CREATE INDEX IF NOT EXISTS audit_project ON audit(project_id, t);
+"""
+
+# columns the workspace adds to protocol tables (PROTOCOL.md) for live deployments
+DEPLOYMENT_COLUMNS = (("kind", "TEXT"), ("target", "TEXT"), ("handle", "TEXT"), ("serving", "TEXT"), ("smoke", "TEXT"),
+                      ("message", "TEXT"), ("command", "TEXT"), ("checks", "TEXT"), ("created_by", "TEXT"),
+                      ("updated_at", "REAL"), ("stopped_at", "REAL"), ("stopped_by", "TEXT"))
+
+_lock = threading.RLock()
+_local = threading.local()
+
+
+def path():
+    return db.DATA / db.SOURCES["workspace"]
+
+
+def _init(conn):
+    have = {r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")}
+    if "runs" not in have:
+        conn.executescript(db.SCHEMA.replace("CREATE TABLE ", "CREATE TABLE IF NOT EXISTS ")
+                           .replace("CREATE INDEX ", "CREATE INDEX IF NOT EXISTS "))
+        conn.execute("INSERT OR REPLACE INTO meta (key, value) VALUES ('source', 'workspace')")
+        conn.execute("INSERT OR REPLACE INTO meta (key, value) VALUES ('version', '3')")
+    else:
+        rcols = {r[1] for r in conn.execute("PRAGMA table_info(runs)")}
+        if "last_seen" not in rcols:
+            conn.execute("ALTER TABLE runs ADD COLUMN last_seen REAL")
+        cols = {r[1] for r in conn.execute("PRAGMA table_info(jobs)")}
+        for col, typ in (("target", "TEXT"), ("spec", "TEXT"), ("runner_id", "TEXT"), ("external_id", "TEXT"),
+                         ("created_at", "REAL"), ("claimed_at", "REAL"), ("cancel", "INTEGER"), ("message", "TEXT")):
+            if col not in cols:
+                conn.execute(f"ALTER TABLE jobs ADD COLUMN {col} {typ}")
+    conn.executescript(EXTRA)
+    tcols = {r[1] for r in conn.execute("PRAGMA table_info(tokens)")}
+    for col, typ in (("scope", "TEXT"), ("expires", "REAL")):
+        if col not in tcols:
+            conn.execute(f"ALTER TABLE tokens ADD COLUMN {col} {typ}")
+    rcols = {r[1] for r in conn.execute("PRAGMA table_info(runs)")}
+    if "last_seen" not in rcols:
+        conn.execute("ALTER TABLE runs ADD COLUMN last_seen REAL")
+    dcols = {r[1] for r in conn.execute("PRAGMA table_info(deployments)")}
+    for col, typ in DEPLOYMENT_COLUMNS:
+        if col not in dcols:
+            conn.execute(f"ALTER TABLE deployments ADD COLUMN {col} {typ}")
+    conn.commit()
+
+
+def connect():
+    conn = getattr(_local, "conn", None)
+    p = path()
+    if conn is not None and getattr(_local, "path", None) == p and p.exists():
+        return conn
+    p.parent.mkdir(parents=True, exist_ok=True)
+    restore()
+    conn = sqlite3.connect(p, check_same_thread=False, timeout=30)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA synchronous=NORMAL")
+    with _lock:
+        _init(conn)
+    _local.conn, _local.path = conn, p
+    return conn
+
+
+def exists():
+    return path().exists()
+
+
+# ------------------------------------------------------------------ tokens
+
+def _hash(token):
+    return hashlib.sha256(token.encode()).hexdigest()
+
+
+def issue_token(name="cli", user_name="admin", email="", scope=None, expires=None):
+    """Create a user (if needed) and a new API token; returns the token (shown once).
+
+    scope: None for a user token (pt_u_), "runner:<t1,t2>" for a runner (pt_r_), "run:<id>" for a
+    job's token (pt_j_) that can only write that run's records."""
+    conn = connect()
+    prefix = "pt_u_" if not scope else ("pt_r_" if scope.startswith("runner:") else "pt_j_")
+    with _lock:
+        u = conn.execute("SELECT id FROM users WHERE name=?", (user_name,)).fetchone()
+        uid = u[0] if u else "user_" + secrets.token_hex(6)
+        if not u:
+            conn.execute("INSERT INTO users (id, name, email, created_at) VALUES (?,?,?,?)", (uid, user_name, email, time.time()))
+        token = prefix + secrets.token_urlsafe(24)
+        conn.execute("INSERT INTO tokens (hash, prefix, user_id, name, created_at, scope, expires) VALUES (?,?,?,?,?,?,?)",
+                     (_hash(token), token[:9], uid, name, time.time(), scope, expires))
+        conn.commit()
+    changed()
+    return token
+
+
+def revoke_token(prefix):
+    conn = connect()
+    with _lock:
+        n = conn.execute("UPDATE tokens SET revoked=1 WHERE prefix=? AND coalesce(revoked,0)=0", (prefix,)).rowcount
+        conn.commit()
+    changed()
+    return n
+
+
+def check_token(token):
+    """The user row for a valid token, else None. POSTTRAIN_ADMIN_TOKEN is always accepted."""
+    if not token:
+        return None
+    admin = os.environ.get("POSTTRAIN_ADMIN_TOKEN")
+    if admin and secrets.compare_digest(token, admin):
+        return {"id": "admin", "name": "admin"}
+    conn = connect()
+    r = conn.execute("SELECT u.id, u.name, t.hash, t.scope, t.expires FROM tokens t JOIN users u ON u.id=t.user_id "
+                     "WHERE t.hash=? AND coalesce(t.revoked,0)=0", (_hash(token),)).fetchone()
+    if not r or (r["expires"] and r["expires"] < time.time()):
+        return None
+    with _lock:
+        conn.execute("UPDATE tokens SET last_used=? WHERE hash=?", (time.time(), r["hash"]))
+        conn.commit()
+    return {"id": r["id"], "name": r["name"], "scope": r["scope"]}
+
+
+def list_tokens():
+    return db.rows(connect(), "SELECT t.prefix, t.name, t.created_at, t.last_used, t.revoked, t.scope, t.expires, u.name AS user FROM tokens t "
+                              "JOIN users u ON u.id=t.user_id WHERE coalesce(t.scope,'') NOT LIKE 'run:%' ORDER BY t.created_at DESC")
+
+
+# ------------------------------------------------------------------ housekeeping: stalled runs, lost runners, stale queue
+
+STALL = 300          # a running run with no report for 5 minutes is stalled
+LEASE = 180          # a claimed job not started within 3 minutes goes back to the queue
+QUEUE_TTL = 86400    # a queued run nobody claims for 24 hours fails
+
+
+def sweep(now=None):
+    now = now or time.time()
+    conn = connect()
+    with _lock:
+        conn.execute("UPDATE runs SET status='stalled', status_reason='No report for 5 minutes.' "
+                     "WHERE status='running' AND coalesce(last_seen, updated_at, started_at) < ?", (now - STALL,))
+        lost = [r[0] for r in conn.execute("SELECT run_id FROM jobs WHERE status='starting' AND claimed_at < ? AND coalesce(cancel,0)=0", (now - LEASE,))]
+        conn.execute("UPDATE jobs SET status='queued', runner_id=NULL, claimed_at=NULL, message='Runner lost before starting; back in the queue.' "
+                     "WHERE status='starting' AND claimed_at < ? AND coalesce(cancel,0)=0", (now - LEASE,))
+        for rid in lost:
+            conn.execute("UPDATE runs SET status='queued' WHERE id=? AND status='starting'", (rid,))
+        # canceled jobs nobody will start: a lost claim, or queued again before the cancel
+        gone = [r[0] for r in conn.execute("SELECT run_id FROM jobs WHERE coalesce(cancel,0)=1 AND (status='queued' OR (status='starting' AND claimed_at < ?))", (now - LEASE,))]
+        conn.execute("UPDATE jobs SET status='stopped', ended_at=? WHERE coalesce(cancel,0)=1 AND (status='queued' OR (status='starting' AND claimed_at < ?))", (now, now - LEASE))
+        for rid in gone:
+            conn.execute("UPDATE runs SET status='stopped', status_reason='Canceled before it started.', ended_at=? WHERE id=? AND status IN ('queued','starting','stopping')", (now, rid))
+        # a stop was requested and the job went silent: it is gone
+        conn.execute("UPDATE runs SET status='stopped', status_reason='No report for 5 minutes after the stop request.', ended_at=? "
+                     "WHERE status='stopping' AND coalesce(last_seen, updated_at, started_at) < ?", (now, now - STALL))
+        stale = [r[0] for r in conn.execute("SELECT run_id FROM jobs WHERE status='queued' AND created_at < ?", (now - QUEUE_TTL,))]
+        for rid in stale:
+            conn.execute("UPDATE jobs SET status='failed', ended_at=?, message='No runner claimed this run within 24 hours.' WHERE run_id=? AND status='queued'", (now, rid))
+            conn.execute("UPDATE runs SET status='failed', status_reason='No runner claimed this run within 24 hours.', ended_at=? WHERE id=? AND status='queued'", (now, rid))
+        conn.commit()
+
+
+def start_sweeper(every=60):
+    def loop():
+        while True:
+            time.sleep(every)
+            try:
+                sweep()
+            except Exception:
+                pass
+    t = threading.Thread(target=loop, daemon=True)
+    t.start()
+    return t
+
+
+# ------------------------------------------------------------------ writes
+
+def write(fn):
+    """Run fn(conn) in a transaction and schedule a sync."""
+    conn = connect()
+    with _lock:
+        try:
+            out = fn(conn)
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+    changed()
+    return out
+
+
+# ------------------------------------------------------------------ optional sync to a private HF dataset
+
+_sync = {"dirty": False, "timer": None, "restored": False}
+
+
+def _sync_repo():
+    repo = os.environ.get("POSTTRAIN_SYNC_REPO")
+    token = os.environ.get("POSTTRAIN_SYNC_TOKEN") or os.environ.get("HF_TOKEN")
+    return (repo, token) if repo and token else (None, None)
+
+
+def restore():
+    repo, token = _sync_repo()
+    if not repo or _sync["restored"] or path().exists():
+        _sync["restored"] = True
+        return
+    _sync["restored"] = True
+    try:
+        from huggingface_hub import hf_hub_download
+        f = hf_hub_download(repo, "workspace.sqlite", repo_type="dataset", token=token)
+        path().write_bytes(Path(f).read_bytes())
+    except Exception:
+        pass
+
+
+def changed():
+    repo, token = _sync_repo()
+    if not repo:
+        return
+    with _lock:
+        _sync["dirty"] = True
+        if _sync["timer"] is None:
+            _sync["timer"] = threading.Timer(float(os.environ.get("POSTTRAIN_SYNC_SECONDS", "30")), _upload)
+            _sync["timer"].daemon = True
+            _sync["timer"].start()
+
+
+def _upload():
+    repo, token = _sync_repo()
+    with _lock:
+        _sync["timer"] = None
+        if not _sync["dirty"]:
+            return
+        _sync["dirty"] = False
+        snap = path().with_suffix(".snapshot")
+        src = sqlite3.connect(path())
+        dst = sqlite3.connect(snap)
+        src.backup(dst)
+        src.close()
+        dst.close()
+    try:
+        from huggingface_hub import HfApi
+        HfApi(token=token).upload_file(path_or_fileobj=str(snap), path_in_repo="workspace.sqlite", repo_id=repo,
+                                       repo_type="dataset", commit_message="workspace sync")
+    except Exception:
+        _sync["dirty"] = True