Deploy HF RL Explorer

CUSTOM_ENVS.md

@@ -107,6 +107,15 @@ can't load the renderer show.
 
 ## Running
 
+Every summary and task also receives a versioned `support` descriptor from
+`app/envs/capabilities.py`. It separates the source's framework, lifecycle, reward
+semantics, transport and available capabilities. The UI and dataset MCP tools consume
+the same descriptor. States are `available`, `external`, `unavailable`, and `unknown`;
+only an implemented hosted runner can advertise execution here. Register a new
+framework's documentation/lifecycle there and add its runner to `HOSTED_RUNNERS` only
+after implementing dispatch and validation. See [EXPLORER_AUDIT.md](EXPLORER_AUDIT.md)
+for the framework matrix and live protocol contract.
+
 A run option is one way to run a task, by a **runner**:
 
 - `harbor`: OpenEnv's Harbor runner on an HF Sandbox (`app/runner.py`). Implement `materialize` (the task as a Harbor
@@ -189,8 +198,10 @@ A processor can say more than a row:
   as dotted names, through lists. Put a format's set in `processors.HIDDEN` too: search never looks at them.
 
 **The framework readers.** NeMo Gym, Verifiers and verl / SkyRL rows are read by modules of their own, which show a
-row as its framework sees it and say how to run it there (they never run here: the sandbox runner runs Harbor tasks,
-and these need their framework's servers, sandboxes or trainers):
+row as its framework sees it and say how to run it there. Verifiers, verl / SkyRL and most NeMo
+configurations require their native servers, sandboxes or trainers. The two supported NeMo Pivot tool-simulation
+configurations can also run here through Responses inference and NVIDIA's pinned argument verifier; they predict
+function calls without executing the functions. `nemogym.run_option` validates this narrow hosted subset:
 
 | module | knows | how it's kept current |
 |---|---|---|

app/admin.py

@@ -19,7 +19,7 @@ from typing import Any, Literal
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel, Field
 
-from . import auth, catalog, config, runner, settings, store
+from . import auth, auto_index, catalog, community, config, runner, search_api, settings, snapshot, space_checks, space_tasks, store
 
 STALE = 600   # a rollout whose record hasn't changed for this long is no longer live, whatever it says
 
@@ -40,22 +40,29 @@ def _admin(request: Request) -> dict[str, Any]:
 @router.get("/overview")
 def overview(request: Request):
     _admin(request)
-    envs = catalog.environments(include_hidden=True)
+    envs = search_api.environments(include_hidden=True)
     runs = _runs()
     now = time.time()
     day = 86400
     by_day = Counter(time.strftime("%Y-%m-%d", time.gmtime(r.get("created_at", 0))) for r in runs if now - r.get("created_at", 0) < 14 * day)
     finished = [r for r in runs if r.get("status") in ("done", "failed", "cancelled", "interrupted")]
     new = sorted((e for e in envs if e.get("created") and now - _ts(e["created"]) < 14 * day), key=lambda e: e["created"], reverse=True)
+    hidden_runs = set(settings.get("hidden_runs", []))
+    ctx = search_api.context()
+    with snapshot.use() as (_, conn):
+        public_counts = search_api.sql_extra(conn, ctx, 0, search_api.Query(scope="ready"))["stats"]
     idx_files = list(config.INDEX_DIR.glob("*.json.gz"))
     pack_files = list(config.PACK_DIR.glob("*.json.gz")) if config.PACK_DIR.is_dir() else []
     return {
         "environments": {"datasets": sum(1 for e in envs if e["kind"] == "dataset"), "spaces": sum(1 for e in envs if e["kind"] == "space"),
-                         "openenv": sum(1 for e in envs if e.get("openenv")), "indexed": sum(1 for e in envs if e.get("indexed")),
-                         "hidden": len(catalog.hidden()), "pinned": len(catalog.pinned()), "collections": len(catalog.collections())},
+                         "openenv": sum(space_checks.verified(e.get("api_check")) for e in envs), "indexed": sum(1 for e in envs if e.get("indexed")),
+                         "checked_spaces": sum(space_checks.browseable(e.get("api_check")) for e in envs),
+                         "public": public_counts, "hidden": len(catalog.hidden()), "pinned": len(catalog.pinned()), "collections": len(catalog.collections())},
         "rollouts": {"total": len(runs), "live": sum(1 for r in runs if _live(r)), "today": sum(1 for r in runs if now - r.get("created_at", 0) < day),
                      "week": sum(1 for r in runs if now - r.get("created_at", 0) < 7 * day),
-                     "public": sum(1 for r in runs if r.get("visibility") == "public"),
+                     "public": sum(community.is_public(r, hidden_runs) for r in runs),
+                     "private": sum(r.get("visibility") != "public" for r in runs),
+                     "by_runner": Counter(community.runner(r) for r in runs).most_common(),
                      "failed": sum(1 for r in finished if r.get("status") != "done"), "finished": len(finished),
                      "users": len({r.get("user") for r in runs}),
                      "by_day": [[time.strftime("%Y-%m-%d", time.gmtime(now - i * day)), by_day.get(time.strftime("%Y-%m-%d", time.gmtime(now - i * day)), 0)]
@@ -65,6 +72,8 @@ def overview(request: Request):
         "storage": {"indexes": len(idx_files), "index_bytes": sum(f.stat().st_size for f in idx_files),
                     "packs": len(pack_files), "pack_bytes": sum(f.stat().st_size for f in pack_files)},
         "recent": [_admin_view(r) for r in runs[:8]],
+        "live": [_admin_view(r) for r in runs if _live(r)][:24],
+        "operations": _operations(envs),
         "new": new[:12],
         "settings": _settings(),
     }
@@ -117,6 +126,8 @@ def _admin_view(r: dict[str, Any]) -> dict[str, Any]:
     v = dict(r)
     if v.get("endpoint"):
         v["endpoint"] = {"host": v["endpoint"].get("host"), "model": v["endpoint"].get("model")}
+    v["runner"] = community.runner(r)
+    v["community"] = community.is_public(r, set(settings.get("hidden_runs", [])))
     v["live"] = _live(r)
     v["avatar"] = r.get("avatar") or avatar(r.get("user"))
     v["moderated"] = r["id"] in set(settings.get("hidden_runs", []))
@@ -125,14 +136,22 @@ def _admin_view(r: dict[str, Any]) -> dict[str, Any]:
 
 # ── rollouts ─────────────────────────────────────────────────────────────────
 @router.get("/rollouts")
-def rollouts(request: Request, status: str = "", q: str = "", user: str = "", limit: int = 100, offset: int = 0):
+def rollouts(request: Request, status: str = "", q: str = "", user: str = "", runner: str = "",
+             visibility: str = "", limit: int = 100, offset: int = 0):
     _admin(request)
     ql = q.strip().lower()
-    runs = [r for r in _runs()
+    hidden = set(settings.get("hidden_runs", []))
+    all_runs = _runs()
+    runs = [r for r in all_runs
             if (not status or (status == "live" and _live(r)) or r.get("status") == status)
             and (not user or r.get("user") == user)
-            and (not ql or ql in f"{r.get('title', '')} {r.get('dataset', '')} {r.get('model', '')} {r.get('user', '')} {r['id']}".lower())]
-    return {"total": len(runs), "runs": [_admin_view(r) for r in runs[offset: offset + max(1, min(limit, 500))]]}
+            and (not runner or community.runner(r) == runner)
+            and (not visibility or (visibility == "community" and community.is_public(r, hidden))
+                 or (visibility == "moderated" and r["id"] in hidden) or r.get("visibility") == visibility)
+            and (not ql or ql in f"{r.get('title', '')} {r.get('dataset', '')} {r.get('model', '')} {r.get('user', '')} {r['id']} {community.runner(r)}".lower())]
+    offset = max(0, offset)
+    return {"total": len(runs), "runners": sorted({community.runner(r) for r in all_runs}),
+            "runs": [_admin_view(r) for r in runs[offset:offset + max(1, min(limit, 500))]]}
 
 
 @router.post("/rollouts/{run_id}/cancel")
@@ -173,14 +192,14 @@ def people(request: Request):
     by: dict[str, dict[str, Any]] = {}
     for r in _runs():
         name = r.get("user") or "unknown"
-        p = by.setdefault(name, {"name": name, "avatar": None, "runs": 0, "done": 0, "solved": 0, "live": 0, "public": 0,
+        p = by.setdefault(name, {"name": name, "avatar": None, "runs": 0, "done": 0, "scored": 0, "live": 0, "public": 0,
                                  "first": r.get("created_at"), "last": r.get("created_at"), "models": Counter(), "datasets": Counter()})
         p["avatar"] = p["avatar"] or r.get("avatar")
         p["runs"] += 1
         p["done"] += r.get("status") == "done"
-        p["solved"] += (r.get("reward") or 0) >= 0.999
+        p["scored"] += r.get("status") == "done" and community.scalar_reward(r)
         p["live"] += _live(r)
-        p["public"] += r.get("visibility") == "public"
+        p["public"] += community.is_public(r, set(settings.get("hidden_runs", [])))
         p["first"] = min(p["first"] or 0, r.get("created_at") or 0)
         p["last"] = max(p["last"] or 0, r.get("created_at") or 0)
         p["models"][r.get("model") or "custom endpoint"] += 1
@@ -197,10 +216,10 @@ def people(request: Request):
 @router.get("/environments")
 def environments(request: Request):
     _admin(request)
-    envs = catalog.environments(include_hidden=True)
+    envs = search_api.environments(include_hidden=True)
     gone = catalog.hidden()
     runs = Counter(r.get("dataset") for r in _runs())
-    return {"environments": [{**e, "hidden": e["key"] in gone, "rollouts": runs.get(e["id"], 0) if e["kind"] == "dataset" else 0} for e in envs],
+    return {"environments": [{**e, "hidden": e["key"] in gone, "ready": e["kind"] == "dataset" or space_checks.browseable(e.get("api_check")), "rollouts": runs.get(e["id"], 0) if e["kind"] == "dataset" else 0} for e in envs],
             "collections": catalog.collections(), "jobs": _jobs()}
 
 
@@ -238,7 +257,7 @@ def env_action(body: EnvAction, request: Request):
         settings.save(u["name"], {"collections": cols}, note=f"{body.action} {key}" + (f" in {body.collection}" if body.collection else ""))
     elif body.action == "index":
         if key.startswith("space:"):
-            raise HTTPException(400, "Spaces aren't indexed")
+            raise HTTPException(400, "Space task counts are discovered automatically from their Task API; dataset indexes are separate")
         st = catalog.index_status(key)   # anonymous: public datasets only
         settings.save(u["name"], {}, note=f"indexed {key}")
         return {"ok": True, "job": {k: v for k, v in st.items() if k != "index"}}
@@ -339,4 +358,22 @@ def indexes(request: Request):
         out.append({"spec": f.name[:-8].replace("__", "/", 1), "bytes": f.stat().st_size, "pack_bytes": pack.stat().st_size if pack.exists() else None,
                     "tasks": head.get("tasks"), "version": head.get("version"), "current": head.get("version") == catalog.INDEX_VERSION,
                     "built": head.get("built")})
-    return {"indexes": out, "version": catalog.INDEX_VERSION, "jobs": _jobs()}
+    return {"indexes": out, "version": catalog.INDEX_VERSION, "jobs": _jobs(), "operations": _operations()}
+
+
+def _operations(envs=None):
+    """Evidence from the shared store, not the admin process's worker settings."""
+    envs = envs if envs is not None else search_api.environments(include_hidden=True)
+    spaces = [e for e in envs if e["kind"] == "space"]
+    records = space_checks.inventory()
+    states = Counter(space_checks.status(records.get(e["id"])) for e in spaces)
+    versions = Counter(e.get("declared_version") or "Unknown" for e in spaces if space_checks.verified(records.get(e["id"])))
+    job = auto_index.status()
+    now = time.time()
+    stale = bool(job and now > (job.get("next_at") or job.get("started_at") or 0) + auto_index.INTERVAL)
+    return {"snapshot": snapshot.status(), "indexer": {**job, "stale": stale},
+            "checks": {"candidates": len(spaces), "ready": sum(space_checks.browseable(records.get(e["id"])) for e in spaces),
+                       "openenv": sum(space_checks.verified(records.get(e["id"])) for e in spaces),
+                       "statuses": dict(states), "versions": versions.most_common(), "fresh_seconds": space_checks.FRESH,
+                       "latest_at": max((records.get(e["id"], {}).get("checked_at", 0) for e in spaces), default=0)},
+            "task_catalog": space_tasks.census(records, [e["id"] for e in spaces if e["key"] not in catalog.hidden() and space_checks.browseable(records.get(e["id"]))])}

app/admin_app.py

@@ -34,12 +34,13 @@ ADMIN_WEB = config.ROOT / "web-admin"
 def _startup() -> None:
     import threading
 
-    from . import catalog
+    from . import search_api, snapshot
 
     config.STORAGE_DIR.mkdir(parents=True, exist_ok=True)
     config.INDEX_DIR.mkdir(parents=True, exist_ok=True)
     # the Hub listing the dashboard opens with: fetched now, so the first visit doesn't wait on it
-    threading.Thread(target=lambda: catalog.environments(include_hidden=True), daemon=True, name="warm").start()
+    snapshot.start()
+    threading.Thread(target=lambda: search_api.environments(include_hidden=True), daemon=True, name="warm").start()
 
 
 @app.get("/healthz", include_in_schema=False)

app/auto_index.py

@@ -0,0 +1,131 @@
+"""Bounded automatic public catalog maintenance, independent of page visits.
+
+The existing indexer runs in a child process so stalled downloads cannot leave
+builder threads behind. A process lease prevents duplicate app workers from
+publishing concurrently. No HF Jobs, inference, or episode execution is used.
+Deployments with an external indexer can set RLX_AUTO_INDEX=0.
+"""
+from __future__ import annotations
+
+import gzip
+import json
+import logging
+import os
+import subprocess
+import sys
+import threading
+import time
+
+from . import catalog, config
+
+INTERVAL = 600
+LISTING_REFRESH = 3600
+MAX_SECONDS = 600
+_stop = threading.Event()
+_worker = None
+log = logging.getLogger("rlx")
+
+
+def status():
+    try:
+        record = json.loads((config.STORAGE_DIR / "auto-index.json").read_bytes())
+        return record if isinstance(record, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _save(record):
+    catalog.atomic_write(config.STORAGE_DIR / "auto-index.json", json.dumps(record).encode())
+
+
+def cached_listing(now):
+    """Reuse only a recent complete public discovery; never extend its age."""
+    try:
+        with gzip.open(config.STORAGE_DIR / "listing.json.gz", "rt") as f:
+            doc = json.load(f)
+        if not isinstance(doc, dict):
+            return None, None
+        at = doc.get("at", 0)
+        if doc.get("full") and isinstance(doc.get("rows"), list) and doc["rows"] and 0 <= now - at < LISTING_REFRESH:
+            return doc["rows"], at
+    except (OSError, ValueError, TypeError):
+        pass
+    return None, None
+
+
+def cycle():
+    """One lease-protected cycle; publication remains atomic in indexer.run."""
+    import fcntl
+    from . import indexer, snapshot
+
+    config.CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    with (config.CACHE_DIR / "auto-index.lock").open("a") as lease:
+        try:
+            fcntl.flock(lease, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            return
+        now = time.time()
+        previous = status()
+        if previous.get("next_at", 0) > now:
+            return
+        record = {"state": "indexing", "started_at": now, "last_success": previous.get("last_success"),
+                  "failures": previous.get("failures", 0), "next_at": now + MAX_SECONDS + INTERVAL}
+        _save(record)
+        try:
+            rows, at = cached_listing(now)
+            report = indexer.run(snapshot.open_store(), rows=rows, listing_at=at, budget_s=90, max_builds=4)
+            _save({"state": "idle", "last_success": time.time(), "next_at": time.time() + INTERVAL,
+                   "failures": 0, "counts": report["counts"]})
+        except Exception as exc:
+            failures = record["failures"] + 1
+            _save({**record, "state": "retrying", "failures": failures, "error": type(exc).__name__,
+                   "next_at": time.time() + min(3600, INTERVAL * 2 ** min(failures - 1, 3))})
+            log.warning("Automatic catalog update failed: %s", type(exc).__name__)
+
+
+def _child():
+    # A public index must not accidentally depend on a developer's HF login.
+    env = {**os.environ, "HF_HUB_DISABLE_IMPLICIT_TOKEN": "1"}
+    child = subprocess.Popen([sys.executable, "-m", "app.auto_index"], env=env,
+                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    deadline = time.monotonic() + MAX_SECONDS
+    try:
+        while child.poll() is None:
+            if _stop.wait(1) or time.monotonic() >= deadline:
+                break
+    finally:
+        if child.poll() is None:
+            child.terminate()
+            try:
+                child.wait(timeout=3)
+            except subprocess.TimeoutExpired:
+                child.kill()
+                child.wait()
+
+
+def start():
+    global _worker
+    if os.environ.get("RLX_TEST_TMP") or os.environ.get("RLX_AUTO_INDEX", "1") != "1" or (_worker and _worker.is_alive()):
+        return
+    _stop.clear()
+    def watch():
+        while not _stop.is_set():
+            try:
+                _child()
+            except Exception as exc:
+                log.warning("Automatic catalog worker failed: %s", type(exc).__name__)
+            _stop.wait(60)
+    _worker = threading.Thread(target=watch, daemon=True, name="auto-index")
+    _worker.start()
+
+
+def stop():
+    _stop.set()
+    if _worker:
+        _worker.join(timeout=5)
+
+
+if __name__ == "__main__":
+    from . import runtime
+    runtime.hub_timeouts()
+    cycle()

app/catalog.py

@@ -92,7 +92,7 @@ def hidden() -> set[str]:
     return set(settings.get("hidden", []))
 
 
-# FineEnvs' flagship environment servers lead Trending until an admin saves pins of their own (an empty list included)
+# Editorial picks, shown separately from the metric-based trending order.
 DEFAULT_PINNED = ["space:FineEnvs/geoguesser-env", "space:FineEnvs/latex-ocr-env"]
 
 
@@ -263,7 +263,9 @@ def _listing_fetch(full: bool) -> list[dict[str, Any]]:
             for d in _api().list_datasets(filter=tag, sort="trending_score", limit=None if full else 1000, expand=_EXPAND):
                 if d.id not in rows and not d.private and not d.gated:
                     rows[d.id] = _summary(d)
-        except Exception:  # noqa: BLE001 - one tag failing leaves the rest
+        except Exception:  # noqa: BLE001 - only the quick bootstrap tolerates incomplete discovery
+            if full:
+                raise
             continue
     missing = [s for s in featured_datasets() if s not in rows]
     with ThreadPoolExecutor(max_workers=12) as pool:   # one Hub call each: in parallel
@@ -361,9 +363,6 @@ def environments(include_hidden: bool = False) -> list[dict[str, Any]]:
         indexed = headline(r["id"]) if r["kind"] == "dataset" else None
         fw = "harbor" if indexed and indexed.get("tasks") else r.get("framework")   # its index found task folders
         coll = collection_of(r["key"])
-        if r["kind"] == "space" and coll == "fineenvs" and fw != "openenv":   # curated as OpenEnv servers, manifest or not
-            r = {**r, "openenv": True, "badges": ["OpenEnv"]}
-            fw = "openenv"
         out.append({**r, "framework": fw, "collection": coll, "pinned": r["key"] in pins, "indexed": indexed})
     return out
 
@@ -374,12 +373,12 @@ _SPACE_EXPAND = ["likes", "trendingScore", "sdk", "runtime", "tags", "lastModifi
 
 def _space_summary(s: Any) -> dict[str, Any]:
     card = (s.card_data.to_dict() if s.card_data else {}) or {}
-    raw = s.tags or []
+    raw = [str(t).lower() for t in (s.tags or [])]
     stage = getattr(s.runtime, "stage", None) if s.runtime is not None else None
     version = next((t[8:] for t in raw if re.match(r"^openenv-\d", t)), None)
     files = [f.rfilename for f in (getattr(s, "siblings", None) or [])]
     manifest = min((f for f in files if _MANIFEST.match(f) and not _VENDORED.match(f)), key=lambda f: f.count("/"), default=None)
-    openenv = "openenv" in raw or bool(version) or manifest is not None
+    openenv = bool({"openenv", "library:openenv"} & set(raw)) or bool(version) or manifest is not None
     ors = bool({"ors", "openreward"} & set(raw))
     return {"id": s.id, "key": f"space:{s.id}", "kind": "space", "openenv": openenv, "manifest": manifest,
             "framework": "openenv" if openenv else "ors" if ors else "space", "files": len(files) or None,
@@ -395,10 +394,10 @@ def _space_summary(s: Any) -> dict[str, Any]:
             "private": bool(s.private), "gated": False}
 
 
-SPACE_TAGS = ("openenv", "rl-environment", "ors", "openreward")
+SPACE_TAGS = ("openenv", "library:openenv", "rl-environment", "ors", "openreward")
 # a manifest a Space's own environment declares (not one vendored from OpenEnv's source, or its templates)
 _MANIFEST = re.compile(r"^(?:[^/]+/)?openenv\.ya?ml$")
-_VENDORED = re.compile(r"^(src/(openenv|core)/|build/|.*\.egg-info/|envs/[^/]+/)")
+_VENDORED = re.compile(r"^(src/|build/|dist/|templates?/|examples?/|tests?/|vendor/|\.venv/|.*\.egg-info/|envs/)")
 
 
 def spaces(full: bool = True) -> list[dict[str, Any]]:
@@ -415,12 +414,16 @@ def spaces(full: bool = True) -> list[dict[str, Any]]:
                 if sp.private or sp.sdk != "docker" or "research-article-template" in tags:
                     continue
                 rows.setdefault(sp.id, _space_summary(sp))
-        except Exception:  # noqa: BLE001 - Spaces failing leaves the datasets
+        except Exception:  # noqa: BLE001 - a full census must not silently publish partial counts
+            if full:
+                raise
             continue
     for sid in featured:
         if sid not in rows:
             try:
-                rows[sid] = _space_summary(_api().space_info(sid, expand=expand))   # with its files: its manifest
+                sp = _api().space_info(sid, expand=expand)
+                if not sp.private and sp.sdk == "docker" and "research-article-template" not in (sp.tags or []):
+                    rows[sid] = _space_summary(sp)
             except Exception:  # noqa: BLE001
                 continue
     return list(rows.values())

app/community.py

@@ -0,0 +1,98 @@
+"""Runner-independent filtering and honest summaries of saved public rollouts.
+
+Visibility is checked by the API before records enter this module. Facets ignore
+their own selection; headline counts always describe the filtered population.
+Rewards are grouped by environment, runner, domain, metric, judge and revision.
+There is no cross-environment model ranking.
+"""
+from __future__ import annotations
+
+import math
+from collections import Counter, defaultdict
+
+DOMAINS = {"code": "Code", "webdev": "Webdev", "cyber": "Cyber", "music": "Music", "general": "General"}
+
+
+def is_public(r, hidden=()):
+    return (r.get("visibility") == "public" and r.get("status") == "done" and scalar_reward(r)
+            and not r.get("restricted") and r.get("id") not in hidden)
+
+
+def scalar_reward(r):
+    value = r.get("reward")
+    try:
+        return type(value) in (int, float) and math.isfinite(value)
+    except OverflowError:
+        return False
+
+
+def runner(r):
+    value = r.get("runner") or ("mimo" if r.get("domain") in DOMAINS else "harbor")
+    return {"nemo": "nemo-gym", "nemogym": "nemo-gym", "nemo_gym": "nemo-gym"}.get(value, value)
+
+
+def group(r):
+    return DOMAINS.get(r.get("domain")) or r.get("dataset") or "Unknown environment"
+
+
+def served(r):
+    return "own endpoint" if r.get("endpoint") else r.get("provider") or "auto"
+
+
+def band(r):
+    if r.get("status") != "done" or not scalar_reward(r):
+        return "unscored"
+    return "full" if r["reward"] >= .999 else "zero" if r["reward"] <= 0 else "partial"
+
+
+VALUES = {"dataset": lambda r: r.get("dataset") or "", "group": group, "runner": runner,
+          "model": lambda r: r.get("model") or "custom endpoint", "served": served,
+          "judge": lambda r: r.get("judge") or "", "reward": band,
+          "thinking": lambda r: (r.get("params") or {}).get("thinking") or "default"}
+
+
+def context(r):
+    return (r.get("dataset") or "Unknown environment", runner(r), r.get("domain") or "",
+            r.get("reward_key") or "reward", r.get("judge") or "",
+            r.get("sha") or (r.get("provenance") or {}).get("commit") or "")
+
+
+def stats(runs):
+    groups = defaultdict(list)
+    for r in runs:
+        if r.get("status") == "done" and scalar_reward(r):
+            groups[(*context(r), VALUES["model"](r), served(r))].append(r["reward"])
+    results = [{"dataset": k[0], "runner": k[1], "domain": k[2], "metric": k[3], "judge": k[4], "revision": k[5],
+                "model": k[6], "served": k[7], "runs": len(v), "mean": math.fsum(x / len(v) for x in v), "min": min(v), "max": max(v)}
+               for k, v in sorted(groups.items())]
+    contexts = {context(r) for r in runs}
+    return {"runs": len(runs), "scored": sum(len(v) for v in groups.values()), "datasets": len({r.get("dataset") for r in runs}),
+            "tasks": len({(r.get("dataset"), r.get("path")) for r in runs}), "models": len({VALUES["model"](r) for r in runs}),
+            "runners": len({runner(r) for r in runs}), "comparable": len(contexts) == 1, "results": results}
+
+
+def query(everyone, filters, *, sort="new", offset=0, limit=100):
+    def keep(r, skip=None):
+        if filters.get("path") is not None and r.get("path") != filters["path"]:
+            return False
+        words = str(filters.get("q") or "").lower().split()[:16]
+        haystack = " ".join(str(r.get(k) or "") for k in ("title", "task_id", "path", "dataset", "model", "runner", "adapter")).lower()
+        if not all(word in haystack for word in words):
+            return False
+        return all(not value or name == skip or VALUES[name](r) == value
+                   for name, value in filters.items() if name in VALUES)
+    runs = [r for r in everyone if keep(r)]
+    # Stable explicit ordering also makes pagination deterministic for tied times.
+    runs.sort(key=lambda r: (-(r.get("created_at") or 0), r["id"]))
+    key = {"reward_desc": lambda r: -r["reward"], "reward_asc": lambda r: r["reward"],
+           "cost_asc": lambda r: (r.get("cost") or {}).get("total") or 0,
+           "cost_desc": lambda r: -((r.get("cost") or {}).get("total") or 0)}.get(sort)
+    if key:
+        runs.sort(key=key)
+    facets = {}
+    for name, value in VALUES.items():
+        counts = Counter(value(r) for r in everyone if keep(r, name) and value(r))
+        facets[name] = [[k, n] for k, n in sorted(counts.items(), key=lambda x: (-x[1], x[0]))]
+    summary = stats(runs)
+    return {"stats": summary, "facets": facets, "total": len(runs), "tasks": summary["tasks"],
+            "runs": runs[max(0, offset):max(0, offset) + max(1, min(limit, 500))]}

app/config.py

@@ -23,6 +23,8 @@ OPENID_PROVIDER_URL = os.environ.get("OPENID_PROVIDER_URL", "https://huggingface
 SPACE_HOST = os.environ.get("SPACE_HOST", "")
 PUBLIC_URL = (os.environ.get("RLX_PUBLIC_URL") or (f"https://{SPACE_HOST}" if SPACE_HOST else "")).rstrip("/")
 LOCAL_MODE = not OAUTH_CLIENT_ID
+# Enable only behind a proxy that replaces/appends the visitor's address.
+TRUST_PROXY = os.environ.get("RLX_TRUST_PROXY", "1" if os.environ.get("SPACE_ID") else "0") == "1"
 # `jobs` runs the sandbox on the visitor's account, `inference-api` calls Inference Providers as them,
 # `read-repos` opens their private and gated datasets.
 OAUTH_SCOPES = os.environ.get("RLX_OAUTH_SCOPES", "openid profile inference-api jobs read-repos").split()   # the admin Space asks for less

app/envs/capabilities.py

@@ -0,0 +1,127 @@
+"""Evidence-based capabilities shared by dataset adapters, live Spaces, UI and MCP.
+
+A framework label describes a format, not permission or proof that it can run.
+A dataset's native harness may be external; a live server may be asleep or may
+speak HTTP instead of OpenEnv's WebSocket protocol. Keep those axes independent.
+The contract is additive so older clients can keep using run.options/step_api.
+"""
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Framework:
+    id: str
+    label: str
+    task: str
+    lifecycle: str
+    reward: str
+    docs: str
+
+
+FRAMEWORKS = {
+    f.id: f for f in (
+        Framework("harbor", "Harbor", "Task folder or packed task files",
+                  "Prepare sandbox → run agent → verify → collect artifacts",
+                  "The task's verifier writes a scalar or named reward metrics.",
+                  "https://www.harborframework.com/docs/tasks"),
+        Framework("openenv", "OpenEnv", "Live environment with typed actions and observations",
+                  "Open session → reset → step until done → close",
+                  "The environment returns rewards and termination with observations.",
+                  "https://huggingface.co/docs/openenv/main/reference/core"),
+        Framework("verifiers", "Verifiers", "Rows loaded by an installed environment or taskset",
+                  "Load environment/taskset → run its harness → score the rollout",
+                  "The installed environment's rubric or judge defines the reward; rows alone do not include that runtime.",
+                  "https://github.com/PrimeIntellect-ai/verifiers/tree/main/docs"),
+        Framework("nemo-gym", "NeMo Gym", "Task data plus agent and resources-server configuration",
+                  "Seed → interact → verify, or reset → step for Gymnasium servers",
+                  "A resources server or embedded agent harness computes the reward.",
+                  "https://docs.nvidia.com/nemo/gym/build-verifiers/"),
+        Framework("verl", "verl", "Training rows with prompt and reward metadata",
+                  "Generate responses → route to the configured reward function → train",
+                  "data_source selects a scorer unless training config supplies a custom reward function.",
+                  "https://verl.readthedocs.io/en/latest/advance/reward_loop.html"),
+        Framework("skyrl", "SkyRL", "Training rows routed to a skyrl-gym environment",
+                  "Load rows → run environment interactions → compute training rewards",
+                  "The selected environment and its configuration define the reward.",
+                  "https://skyrl.readthedocs.io/en/latest/"),
+        Framework("mimo", "MiMo", "Tasks from the MiMo RL environment release",
+                  "Prepare task → run the release's domain harness → grade",
+                  "Each domain uses its own verifier; supported conversions also run through Harbor.",
+                  "https://huggingface.co/datasets/XiaomiMiMo/MiMo-V2.6-RL-oss"),
+        Framework("gymnasium", "Gymnasium HTTP", "A server exposing reset and step over HTTP",
+                  "Reset → step until terminated or truncated → close",
+                  "The server returns step rewards; its HTTP schema defines the request and response.",
+                  "https://gymnasium.farama.org/api/env/"),
+        Framework("mcp", "MCP", "Tools exposed by a live server", "Connect → call advertised tools → close",
+                  "A reward is available only when the server exposes a grader or returns one.",
+                  "https://modelcontextprotocol.io/specification/2025-06-18/server/tools"),
+        Framework("ors", "ORS", "A server with named environments and sessions",
+                  "Create session → call environment → close session", "The server defines its grading contract.", ""),
+        Framework("api", "HTTP API", "A live server's published operations", "Call the server's documented routes",
+                  "Inspect the published schema and grading routes for this server.", ""),
+        Framework("rows", "RL dataset", "Dataset rows", "Browse task data; use the source's environment to execute it",
+                  "A dataset label or answer column alone does not establish a runnable grader.", ""),
+    )
+}
+HOSTED_RUNNERS = frozenset({"harbor", "mimo", "nemo-gym"})
+
+
+def framework(value: str | None) -> Framework:
+    key = str(value or "").lower().replace("_", "-").replace(" ", "-")
+    aliases = {"nemo": "nemo-gym", "nemogym": "nemo-gym", "generic": "rows", "rl": "rows", "harbor-(packed)": "harbor"}
+    key = aliases.get(key, key)
+    if key.startswith("mimo"):
+        key = "mimo"
+    return FRAMEWORKS.get(key, FRAMEWORKS["rows"])
+
+
+def capability(id: str, label: str, state: str, detail: str) -> dict[str, str]:
+    if state not in {"available", "external", "unavailable", "unknown"}:
+        raise ValueError(f"invalid capability state: {state}")
+    return {"id": id, "label": label, "state": state, "detail": detail}
+
+
+def dataset_support(name: str, *, state: str = "ready", options: list[dict[str, Any]] | None = None,
+                    note: str = "", revision: str | None = None, restricted: bool = False) -> dict[str, Any]:
+    f = framework(name)
+    ready = state == "ready"
+    features = [capability("browse", "Browse tasks", "available" if ready else "unknown",
+                           "Inspect the prompt, grading information and source files." if ready else "Task discovery is still in progress.")]
+    if options is None:
+        features.append(capability("run", "Run an agent", "unknown", "Open a task to check its harness and runtime requirements."))
+    else:
+        runnable = [o for o in options if o.get("ok") and o.get("runner") in HOSTED_RUNNERS and not o.get("href")]
+        external = [o for o in options if o.get("href") or (not o.get("ok") and o.get("runner") in {"verifiers", "nemo-gym", "nemogym", "verl", "skyrl"})]
+        why = "; ".join(dict.fromkeys(o.get("why") for o in options if o.get("why")))
+        features.append(capability("run", "Run an agent", "available" if runnable else "external" if external else "unavailable",
+                                   "Runs here with " + ", ".join(o["label"] for o in runnable) + "." if runnable else
+                                   why or note or "This source has no executable harness configured here."))
+    features.append(capability("mcp", "Explore with an agent", "unavailable" if restricted else "available" if ready else "unknown",
+                               "The MCP bridge only serves public datasets; this source requires your sign-in." if restricted else
+                               "MCP exposes public task browsing. Execution follows the runtime support above."))
+    return {"version": 1, "framework": asdict(f), "source": "dataset", "evidence": "adapter", "revision": revision,
+            "transport": None, "capabilities": features}
+
+
+def space_support(info: dict[str, Any]) -> dict[str, Any]:
+    up = bool(info.get("running"))
+    f = framework(info.get("framework") or "api")
+    transport = "openenv-ws" if info.get("openenv") else "http" if info.get("api") else "mcp-http" if info.get("mcp") else None
+    can_play = bool(info.get("step_api") or info.get("mcp") or info.get("api"))
+    status = "available" if up and can_play else "unavailable" if up else "unknown"
+    detail = ("Play an episode over OpenEnv's WebSocket session." if transport == "openenv-ws" else
+              "Call the published HTTP routes; each explorer session keeps its own cookies." if transport == "http" else
+              "Call MCP tools. Episode state depends on the server's MCP implementation.") if can_play else "No supported interactive API was discovered."
+    if not up:
+        detail = "The Space is " + str(info.get("stage") or "unreachable").lower().replace("_", " ") + "; check its live interface when it is running."
+    return {"version": 1, "framework": asdict(f), "source": "space", "evidence": "live" if up else "unverified",
+            "transport": transport, "capabilities": [
+                capability("play", "Interactive playground", status, detail),
+                capability("browse", "Browse tasks", "available" if up and info.get("task_api") else "unavailable" if up else "unknown",
+                           "Tasks are served by the environment's Task API." if info.get("task_api") else "No live Task API was discovered; source files may describe the tasks."),
+                capability("mcp", "Connect an agent", status,
+                           "The explorer bridges the advertised interface to MCP." if up and can_play else detail),
+            ]}

app/envs/mimo.py

@@ -250,7 +250,7 @@ class MiMoAdapter(c.Adapter):
         if not rows and not how:
             return None
         net = ("Web search and fetch tools are off." if d == "webdev" else "Web search and fetch tools are off, and the sites where answers live "
-               "(code hosting, bug trackers, search engines) are unreachable from the sandbox; everything else, including local services, works as usual.")
+               "(code hosting, bug trackers, search engines) are added to a hosts-file blocklist. This reduces answer leakage but is not an egress firewall. Other connections depend on the hosting provider's network policy.")
         return c.section("setup", "How the sandbox is set up", [c.kv(rows), c.note(f"{how} {net}", "shield") if how else None], icon="box")
 
     def _glance(self, v: dict[str, Any]) -> list[list[str]]:

app/envs/nemo_gym_build.py

@@ -18,6 +18,12 @@ from pathlib import Path
 
 import yaml
 
+# Reviewed against each server's implementation; the upstream environment table
+# incorrectly calls these LLM judges. Keep regenerated catalogs accurate too.
+VERIFICATION_OVERRIDES = {
+    "instruction_following": "Rule-based instruction checks",
+    "math_proof_judgement": "Deterministic answer parsing",
+}
 
 def main(ROOT: Path) -> None:
     OUT = CAT = Path(__file__).with_name("nemo_gym_catalog.json")
@@ -93,6 +99,8 @@ def main(ROOT: Path) -> None:
             continue
         t = table.get(d.name, {})
         servers[d.name] = {k: v for k, v in {"description": t.get("description"), "verification": t.get("verification"), "readme": readme_para(d)}.items() if v}
+        if d.name in VERIFICATION_OVERRIDES:
+            servers[d.name]["verification"] = VERIFICATION_OVERRIDES[d.name]
         for cfg in sorted((d / "configs").glob("*.yaml")):
             flavor = d.name if cfg.stem == d.name else f"{d.name}/{cfg.stem}"
             scan(cfg, d.name, flavor, None)

app/envs/nemo_gym_catalog.json

@@ -1985,7 +1985,7 @@
 },
 "instruction_following": {
 "description": "IFEval and IFBench-style instruction following",
-"verification": "LLM judge",
+"verification": "Rule-based instruction checks",
 "readme": "Evaluates language model responses against instruction-following criteria using Open-Instruct and IFEval constraints.",
 "fields": {
 "id": {
@@ -2454,7 +2454,7 @@
 },
 "math_proof_judgement": {
 "description": "Binary proof judgement — model reads a problem and proof, outputs Yes/No",
-"verification": "LLM judge",
+"verification": "Deterministic answer parsing",
 "readme": "Binary judgement of math proofs. The policy model reads a problem + candidate proof and outputs `Judgement: Yes` (proof correct) or `Judgement: No` (proof incorrect). Verification is fully deterministic — a single regex parses the final judgement — so **no external LLM judge is called**. This mirrors NeMo Skills' `answer-judgement` metric (`is_correct_judgement` format 1).",
 "fields": {
 "expected_judgement": {

app/envs/nemogym.py

@@ -250,7 +250,8 @@ def run_blocks(spec: str, config: str, split: str, agents: list[dict[str, Any]],
     artifact = next((u.get("artifact") for u in cat["datasets"].get(spec.lower()) or [] if u.get("type") == split and u.get("artifact")), None) \
         if config == "default" else None
     what = f"this dataset's {split} split" + ("" if config == "default" else f" of {config}")
-    lines = ["# NeMo Gym, from source (Python 3.13+, uv)", "git clone https://github.com/NVIDIA-NeMo/Gym.git && cd Gym",
+    lines = ["# NeMo Gym, from the revision used by this explorer's catalog (Python 3.13+, uv)",
+             "git clone https://github.com/NVIDIA-NeMo/Gym.git && cd Gym", f"git checkout {cat['commit']}",
              "uv venv --python 3.13.14 && source .venv/bin/activate && uv sync", "",
              f"# the rows: {what}, as JSON Lines" + (", and this row alone" if row is not None else ""), *_download(spec, config, split, local, artifact,
                                                                                                     rowfiles.files_of(spec, meta or {}, config, split) if config != "default" else [])]
@@ -292,8 +293,21 @@ def run_blocks(spec: str, config: str, split: str, agents: list[dict[str, Any]],
     return blocks
 
 
-def run_option(agent: dict[str, Any]) -> dict[str, Any]:
-    """Not here: the run panel says why in one sentence and points at the commands on the page."""
+def run_option(agent: dict[str, Any], row: dict | None = None) -> dict[str, Any]:
+    from .. import nemo_runner
+    if row is not None and nemo_runner.supported(agent):
+        try:
+            nemo_runner.validate(row, agent)
+        except (ValueError, KeyError, TypeError) as error:
+            return c.run_option("nemo-gym", "NeMo Gym prediction", ok=False, why=str(error), endpoint=False, sandbox=False)
+        return c.run_option("nemo-gym", "NeMo Gym prediction", ok=True, endpoint=False, sandbox=False,
+                            about="One model prediction, scored by NVIDIA's NeMo Gym argument comparator. Tool calls are predictions, not executed actions. No sandbox is needed.",
+                            notes=[f"Verifier pinned to NVIDIA-NeMo/Gym `{nemo_runner.REVISION[:12]}` with its native 0.1 word-similarity threshold."] +
+                                  (["Some source tools have invalid strict schemas. Their parameters stay unchanged; strict enforcement is disabled so HF providers accept them."] if nemo_runner.relaxed_tools(row) else []),
+                            harnesses=["opencode"], fields=[
+                                c.field("max_tokens", "Max output tokens", "number", default=2048, min=256, max=8192, advanced=True),
+                                c.field("temperature", "Temperature", "number", min=0, max=2, step=0.1, advanced=True)],
+                            estimate={"tokens_in": 4000, "tokens_out": 1000, "minutes": 0})
     rs = agent.get("resources_server")
     return c.run_option("nemo-gym", "NeMo Gym", ok=False,
                         why=f"it is scored by NeMo Gym's {rs + ' ' if rs else ''}resources server, which runs only inside NeMo Gym",
@@ -430,8 +444,9 @@ class NemoGym(Processor):
             rows = convo.field_rows({**dict(settings), **nested})
             sections.append(section("request", "Request settings", [c.custom("rl", "fields", {"rows": rows}, convo.fields_text(rows))], kind="blocks",
                                     note="the rest of responses_create_params"))
+        option = run_option(agent, row)
         sections.append(section("run", "Run it with NeMo Gym", run_blocks(ds.spec, config, split, [agent], row=i, meta=ds.card), kind="blocks",
-                                note="it doesn't run in this app"))
+                                note="Native CLI alternative; prediction runs are also available here" if option["ok"] else "This task needs the native runtime"))
         rest = {k: v for k, v in clean.items() if k not in task_data and k not in FRAMEWORK and v not in (None, "", [], {})}
         if rest:
             label = "provenance and metrics" if roles_of else "the rest of the row"
@@ -452,7 +467,7 @@ class NemoGym(Processor):
             glance.append(["Pass rate", p])
         card = self.card(row, i, roles)
         return {"title": title[:200], "id": card["id"], "chips": card["chips"], "sections": sections, "withheld": gone, "glance": glance,
-                "framework_run": run_option(agent),
+                "framework_run": option,
                 "summary": "Scored on the next action matching the expert's" if pivot else
                            (f"Verifier: {agent['verification'].lower()}" if agent.get("verification") else "Scored by its resources server")}
 

app/envs/registry.py

@@ -16,6 +16,7 @@ from typing import Any, Callable
 
 from .. import catalog
 from .contract import Adapter, Env
+from .capabilities import dataset_support
 from .harbor import HarborAdapter
 from .mimo import MiMoAdapter, harbor_aliases, harbor_to_mimo
 from .rows import RowsAdapter
@@ -86,8 +87,10 @@ def summary(spec: str, token: str | None = None, subset: str | None = None) -> d
         env = resolve("dataset", spec, token)
         s = env.adapter.summary(env, subset)
     how = s.get("how") or {}
+    name = how.get("framework") or env.adapter.framework
     return {"env": {**describe_env(env), "framework": how.get("framework") or env.adapter.framework},
-            "info": {k: v for k, v in env.meta.items() if k != "all_tags"}, "collection": catalog.collection(spec), **s}
+            "info": {k: v for k, v in env.meta.items() if k != "all_tags"}, "collection": catalog.collection(spec), **s,
+            "support": dataset_support(name, state=s.get("state", "ready"), revision=env.meta.get("sha"), restricted=bool(env.meta.get("restricted")))}
 
 
 def tasks(spec: str, token: str | None = None, **kw: Any) -> dict[str, Any]:
@@ -108,6 +111,7 @@ def task(spec: str, ref: str, token: str | None = None) -> dict[str, Any]:
     out.setdefault("collection", catalog.collection(spec))
     out["env"] = {**describe_env(env), "framework": view.get("framework") or env.adapter.framework}
     out["run"] = {"options": options, "note": "" if options else env.adapter.run_note}
+    out["support"] = dataset_support(out["env"]["framework"], options=options, note=env.adapter.run_note, revision=env.meta.get("sha"), restricted=bool(env.meta.get("restricted")))
     out["aliases"] = [{"env": k, "ref": r} for k, r in aliases(env, ref)]
     return out
 

app/envs/rows.py

@@ -635,6 +635,16 @@ class RowsAdapter(c.Adapter):
 
         config, split, i = parse_ref(ref)
         view = self.task(env, ref)
+        if (view.get("_framework_run") or {}).get("runner") == "nemo-gym":
+            from .nemogym import agent_of
+            from .. import nemo_runner
+            *_, row, truncated = _row(env.id, config, split, i, env.token)
+            if truncated:
+                raise ValueError("This task row is truncated; use the complete dataset with NeMo Gym")
+            agent = agent_of(row, env.id)
+            nemo_runner.validate(row, agent)
+            return {"title": view["title"], "restricted": bool(env.meta.get("restricted")), "sha": env.meta.get("sha"),
+                    "native_task": {"row": row, "agent": agent}}
         if view.get("_packed_run"):
             p = packed(env.id, config, split, i, env.token)
             return {"title": p["title"], "restricted": p["restricted"], "sha": p["sha"], "bytes": p["bytes"], "runnable": p["runnable"],

app/envs/tools.py

@@ -49,6 +49,7 @@ def call(spec: str, name: str, args: dict[str, Any]) -> Any:
         if s.get("state") != "ready":
             return {"state": s.get("state"), "note": "Its index is being built; try again in a minute.", "progress": s.get("progress")}
         return {"id": spec, "format": s["env"]["framework"], "read_as": (s.get("how") or {}).get("name"), "about": (s.get("how") or {}).get("about"),
+                "support": s.get("support"),
                 "tasks": s.get("total"), "subsets": [x["id"] for x in s.get("subsets") or []], "subset": s.get("subset"),
                 "facets": {f["key"]: f["label"] for f in s.get("facets") or []},
                 "overview": blocks_text([b for sec in s.get("overview") or [] for b in [{"type": "markdown", "text": f"## {sec['title']}"}, *sec["blocks"]]])}
@@ -101,6 +102,10 @@ def task_text(v: dict[str, Any]) -> str:
     if v.get("withheld"):
         out.append("\nWithheld, as they hold the answer: " + ", ".join(v["withheld"]))
     opts = (v.get("run") or {}).get("options") or []
+    support = v.get("support") or {}
+    if support.get("framework"):
+        f = support["framework"]
+        out.append(f"\nLifecycle: {f['lifecycle']}\nReward: {f['reward']}")
     out.append("\n## Running it\n" + ("\n".join(f"- {o['label']}: " + ("runs here" if o["ok"] else f"can't run here ({o['why']})") for o in opts)
                                      or (v.get("run") or {}).get("note") or ""))
     for link in v.get("links") or []:

app/envs/verifiers_rows.py

@@ -196,8 +196,11 @@ def _prompt_turns(row: dict[str, Any], env: dict[str, Any]) -> list[dict[str, An
         ts = [{"kind": "message", "role": "user", "text": row["question"]}]
     else:
         ts = []
-    if env.get("system") and not any(t["role"] == "system" for t in ts):
-        ts.insert(0, {"kind": "message", "role": "system", "text": env["system"]})
+    # v1 TaskData carries an explicit system_prompt. It belongs in the agent's
+    # conversation, ahead of the row's prompt, and overrides a known v0 default.
+    system = row.get("system_prompt") if isinstance(row.get("system_prompt"), str) else env.get("system")
+    if system and not any(t["role"] == "system" for t in ts):
+        ts.insert(0, {"kind": "message", "role": "system", "text": system})
     return ts
 
 
@@ -308,7 +311,7 @@ class Verifiers(Processor):
                 gblocks += [c.note("`info`, which the rewards also get:", "list"), c.custom("rl", "fields", {"rows": rows}, convo.fields_text(rows))]
         sections.append(section("grading", "How it's graded", gblocks, kind="blocks", note="the environment's rewards"))
         sections.append(section("run", "Run it with Verifiers", run_blocks(ds.spec, env, config, split, row=i), kind="blocks", note="it doesn't run in this app"))
-        shown = {"problem_statement", "prompt", "question", "info", "task", *IMAGE_COLS, "repo", "base_commit", "parent_commit", "workdir", "language",
+        shown = {"problem_statement", "prompt", "system_prompt", "question", "info", "task", *IMAGE_COLS, "repo", "base_commit", "parent_commit", "workdir", "language",
                  "repo_language", "version", "test_cmd", "install_config"}
         rest = {k: v for k, v in clean.items() if k not in shown and v not in (None, "", [], {})}
         if rest:
@@ -361,10 +364,10 @@ class Verifiers(Processor):
 
 
 def run_blocks(spec: str, env: dict[str, Any], config: str, split: str, row: int | None = None) -> list[dict[str, Any]]:
-    """Commands that evaluate these rows with Verifiers 0.3.1 (the current release) and the Prime CLI."""
+    """Commands targeting the release that exposes both the v0 and v1 CLIs."""
     eid = env.get("env")
     head = ["# Verifiers (pip: verifiers 0.3.1) and the Prime CLI, in a new uv project",
-            "uv init vf-eval-here && cd vf-eval-here && uv add verifiers", "uv tool install prime"]
+            "uv init vf-eval-here && cd vf-eval-here && uv add 'verifiers==0.3.1'", "uv tool install prime"]
     if not eid:
         lines = head + ["", "# find and install the environment that loads this dataset (its card or repository names it)",
                         "prime env list", "prime env install <owner>/<environment>", "",

app/http.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import os
 import threading
 import time
+from urllib.parse import urlsplit
 
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
@@ -21,7 +22,7 @@ CSP = ("default-src 'self'; script-src 'self' https://cdn.jsdelivr.net; style-sr
 def client_ip(request: Request) -> str:
     """The visitor's address: the last X-Forwarded-For entry is the one the Space's proxy added (earlier ones are
     whatever the client claimed)."""
-    fwd = [p.strip() for p in request.headers.get("x-forwarded-for", "").split(",") if p.strip()]
+    fwd = [p.strip() for p in request.headers.get("x-forwarded-for", "").split(",") if p.strip()] if config.TRUST_PROXY else []
     return fwd[-1] if fwd else (request.client.host if request.client else "?")
 
 
@@ -51,9 +52,22 @@ class Limiter:
 
 
 def same_origin(request: Request) -> bool:
+    """Compare complete origins; forwarding headers supplied by a client aren't authority."""
     origin = request.headers.get("origin")
-    host = request.headers.get("x-forwarded-host") or request.headers.get("host")
-    return not origin or origin.split("://", 1)[-1] == host
+    if not origin:
+        return request.headers.get("sec-fetch-site") in (None, "same-origin", "none")
+
+    def canonical(value: str):
+        try:
+            u = urlsplit(value)
+            if u.scheme not in ("http", "https") or not u.hostname or u.username or u.password or u.path or u.query or u.fragment:
+                return None
+            return u.scheme, u.hostname.lower(), u.port or (443 if u.scheme == "https" else 80)
+        except ValueError:
+            return None
+
+    expected = canonical(config.PUBLIC_URL) if config.PUBLIC_URL else canonical(f"{request.url.scheme}://{request.headers.get('host', '')}")
+    return expected is not None and canonical(origin) == expected
 
 
 def install(app: FastAPI) -> None:
@@ -61,7 +75,11 @@ def install(app: FastAPI) -> None:
     async def _revalidate(request: Request, call_next):
         """Code and styles revalidate on every load (cheap: ETag -> 304), so a deploy is never half-cached."""
         resp = await call_next(request)
-        if not request.url.path.startswith("/api/"):
+        if request.url.path.startswith(("/api/", "/mcp/", "/login")):
+            # APIs can contain a visitor's private dataset, run, or account. A shared
+            # proxy or the browser's cache must never reuse them for another visitor.
+            resp.headers["Cache-Control"] = "private, no-store"
+        else:
             resp.headers.setdefault("Cache-Control", "no-cache")
         return resp
 
@@ -88,10 +106,6 @@ def install(app: FastAPI) -> None:
         """The session cookie is SameSite=None (it has to work in the huggingface.co iframe), so a state-changing
         request must prove it came from this page: another site could otherwise start rollouts billed to you."""
         if request.method not in ("GET", "HEAD", "OPTIONS") and request.url.path.startswith("/api/"):
-            origin = request.headers.get("origin")
-            host = request.headers.get("x-forwarded-host") or request.headers.get("host")
-            if origin and origin.split("://", 1)[-1] != host:
-                return JSONResponse({"detail": "cross-site request refused"}, 403)
-            if not origin and request.headers.get("sec-fetch-site") not in (None, "same-origin", "none"):
+            if not same_origin(request):
                 return JSONResponse({"detail": "cross-site request refused"}, 403)
         return await call_next(request)

app/indexer.py

@@ -231,6 +231,9 @@ def refresh_indexes(items: list[dict[str, Any]], state: dict[str, Any], *, budge
         th.join(timeout=max(60.0, deadline - time.time() + 120))
         if th.is_alive():
             out["abandoned"].append(spec)
+            # A bounded automatic worker exits after publication. Avoid retrying
+            # the same oversized build at the front of every subsequent batch.
+            state["failed"][spec] = {"sha": sha, "at": time.time(), "error": "Index build exceeded its time budget"}
             _ev("build_abandoned", spec=spec, seconds=round(time.time() - t0))
             continue
         if "error" in result:
@@ -318,7 +321,7 @@ def prune(store, keep: int) -> list[str]:
 
 def run(store, *, rows: list[dict[str, Any]] | None = None, budget_s: float = 1800, max_builds: int = 100, keep: int = 5,
         min_ratio: float = 0.8, force: bool = False, index: bool = True, dry_run: bool = False,
-        out: Path | None = None) -> dict[str, Any]:
+        out: Path | None = None, listing_at: float | None = None) -> dict[str, Any]:
     """One indexer run (see the module docstring). `rows` stands in for the Hub listing (tests). Raises IndexerError
     (or anything else) without publishing."""
     from . import catalog, config, snapshot
@@ -330,17 +333,18 @@ def run(store, *, rows: list[dict[str, Any]] | None = None, budget_s: float = 18
         _ev("pointer_unreadable", error=str(e))
         prev = None
     rows = rows if rows is not None else fetch_listing()
+    listing_at = listing_at if listing_at is not None else time.time()
     rows = [r for r in rows if not r.get("private") and not r.get("gated")]
     if not force:
         guard(rows, prev, min_ratio)
     # catalog's own readers (environments, featured lookups) see this listing, and the app's fallback path finds it
     with catalog._listing_lock:
-        catalog._env_list.update(rows=rows, at=time.time(), full=True)
+        catalog._env_list.update(rows=rows, at=listing_at, full=True)
     if not dry_run:
         import gzip
 
         catalog.atomic_write(config.STORAGE_DIR / "listing.json.gz",
-                             gzip.compress(json.dumps({"at": time.time(), "full": True, "rows": rows}, default=str).encode()))
+                             gzip.compress(json.dumps({"at": listing_at, "full": True, "rows": rows}, default=str).encode()))
     report: dict[str, Any] = {"listing": len(rows)}
     state = load_state()
     if index and not dry_run:

app/main.py

@@ -23,6 +23,7 @@ from pydantic import BaseModel, Field
 
 from . import auth, catalog, config, endpoints, envs, http, mcp_bridge, models, runner, runtime, search_api, seo, settings, space_files, spaces_live, store, version
 from .envs import registry
+from . import community as community_data
 
 app = FastAPI(title="HF RL Explorer", docs_url="/api/docs")
 app.include_router(auth.router)
@@ -50,6 +51,10 @@ def _shutdown() -> None:
     """Live rollouts' events to the store, and locally the capture proxy's tunnels closed: gradio starts `frpc` as a child
     that outlives this process otherwise, and stale tunnels pile up across restarts."""
     import sys
+    from . import auto_index, space_checks
+
+    space_checks.stop()
+    auto_index.stop()
 
     store.flush_due(force=True)
     tunneling = sys.modules.get("gradio.tunneling")
@@ -63,9 +68,12 @@ def _shutdown() -> None:
 @app.on_event("startup")
 def _startup() -> None:
     import threading
+    from . import auto_index, space_checks
 
     config.STORAGE_DIR.mkdir(parents=True, exist_ok=True)
     config.INDEX_DIR.mkdir(parents=True, exist_ok=True)
+    space_checks.start()
+    auto_index.start()
     # rollouts whose worker is gone are marked interrupted by the watcher below, once they've been silent a while
     threading.Thread(target=runner.watch_cancel_requests, daemon=True, name="cancel-requests").start()
     if os.environ.get("RLX_WARM", "1") == "1":
@@ -157,8 +165,15 @@ def environments():
 
 @app.get("/api/spaces/{org}/{name}")
 def space_page(org: str, name: str):
-    """An environment Space: its card and README, and what its OpenEnv server says about itself."""
-    return _hub_errors(catalog.space, f"{org}/{name}")
+    """Repository metadata is distinct from verified live OpenEnv support."""
+    from . import space_checks
+    source = _hub_errors(catalog.space, f"{org}/{name}")
+    check = space_checks.inventory().get(f"{org}/{name}", {})
+    verified = space_checks.verified(check)
+    return {**source, "declared_openenv": bool(source.get("openenv")), "openenv": verified,
+            "framework": "openenv" if verified else "ors" if source.get("framework") == "ors" else "space",
+            "badges": [b for b in source.get("badges", []) if verified or b != "OpenEnv"],
+            "api_status": space_checks.status(check)}
 
 
 # ── live Spaces: status, wake/restart, Task API, playground ─────────────────
@@ -181,7 +196,7 @@ def space_live(org: str, name: str, fresh: bool = False):
     with no MCP tools of its own (a reset/step environment) still has tools for an agent: `bridge_tools` are exactly what
     this explorer's MCP bridge offers for it (reset, step with its typed action, state, its Task API), for the page."""
     info = _live(spaces_live.probe, f"{org}/{name}", fresh)
-    if info.get("running") and not info.get("mcp") and (info.get("step_api") or info.get("api") or info.get("task_api")):
+    if info.get("running") and (info.get("mcp") or info.get("step_api") or info.get("api") or info.get("task_api")):
         info = {**info, "bridge_tools": mcp_bridge._tools(info)}
     return info
 
@@ -204,14 +219,14 @@ def space_restart(org: str, name: str, request: Request):
 
 
 @app.get("/api/spaces/{org}/{name}/tasks")
-def space_tasks(org: str, name: str, split: str = "", start: int = 0, stop: int = 20):
+def space_tasks(org: str, name: str, split: str = "", start: int = 0, stop: int = 20, env: str = ""):
     """A page of tasks from the server's Task API (answer-like fields left out)."""
-    return _live(spaces_live.tasks, f"{org}/{name}", split, start, stop)
+    return _live(spaces_live.tasks, f"{org}/{name}", split, start, stop, env)
 
 
 @app.get("/api/spaces/{org}/{name}/task")
-def space_task(org: str, name: str, split: str = "", index: int = 0):
-    return _live(spaces_live.task, f"{org}/{name}", split, index)
+def space_task(org: str, name: str, split: str = "", index: int = 0, env: str = ""):
+    return _live(spaces_live.task, f"{org}/{name}", split, index, env)
 
 
 class PlayIn(BaseModel):
@@ -335,9 +350,10 @@ def env_data(org: str, name: str, request: Request, ref: str, part: str):
 def env_raw(org: str, name: str, request: Request, ref: str, f: str, download: bool = False):
     """One of a task's files as it is (an image, a page for a sandboxed frame). Never runs with this site's origin."""
     data, media = _env(registry.raw, f"{org}/{name}", ref, f, _token(request))
-    fname = f.rsplit("/", 1)[-1].replace('"', "")
+    # RFC 5987 handles Unicode and keeps control characters out of HTTP headers.
+    fname = quote(f.rsplit("/", 1)[-1], safe="")
     return Response(data, media_type=media, headers={"Content-Security-Policy": "sandbox", "X-Content-Type-Options": "nosniff",
-                                                     "Content-Disposition": f'{"attachment" if download else "inline"}; filename="{fname}"'})
+                                                     "Content-Disposition": f"{'attachment' if download else 'inline'}; filename*=UTF-8''{fname}"})
 
 
 @app.get("/api/env/{org}/{name}/random")
@@ -484,19 +500,19 @@ PUBLIC_FIELDS = ("id", "dataset", "path", "task_id", "title", "collection", "dif
 
 def _shareable(r: dict) -> bool:
     """Shown to everyone: finished and graded, on a public dataset, and not taken off Community by an admin."""
-    return (r.get("status") == "done" and r.get("reward") is not None and not r.get("restricted")
-            and r["id"] not in set(settings.get("hidden_runs", [])))
+    return community_data.is_public(r, set(settings.get("hidden_runs", [])))
 
 
 def _public_view(r: dict) -> dict:
     v = {k: r.get(k) for k in PUBLIC_FIELDS}
+    v["runner"] = community_data.runner(r)
     if r.get("endpoint"):
         v["endpoint"] = {"custom": True}
     return {**v, "visibility": "public"}
 
 
 def _owner_view(r: dict) -> dict:
-    return {**r, "is_owner": True}
+    return {**r, "runner": community_data.runner(r), "is_owner": True}
 
 
 def _visible(request: Request, run_id: str) -> tuple[dict, bool]:
@@ -530,7 +546,7 @@ def my_runs(request: Request, d: str = "", p: str | None = None):
 @app.get("/api/runs/{run_id}")
 def run_detail(run_id: str, request: Request, after: int = 0):
     r, owner = _visible(request, run_id)
-    if r.get("runner") == "mimo":   # the MiMo harness: its events, live while it runs (app/mimo/runner/core.py)
+    if community_data.runner(r) in ("mimo", "nemo-gym"):   # event-based hosted runners
         from .mimo.runner import core as mimo
 
         live = mimo.live(run_id)
@@ -570,85 +586,17 @@ def set_visibility(run_id: str, body: VisibilityIn, request: Request):
     return {"run": _owner_view(store.update(run_id, visibility=body.visibility))}
 
 
-DOMAINS = {"code": "Code", "webdev": "Webdev", "cyber": "Cyber", "music": "Music", "general": "General"}
-
-
-def _group(r: dict) -> str:
-    """Where a rollout's task belongs, for the leaderboard's columns: a MiMo domain, else its environment."""
-    if r.get("domain") in DOMAINS:
-        return DOMAINS[r["domain"]]
-    return (r.get("dataset") or "?").split("/")[-1]
-
-
-def _served(r: dict) -> str:
-    return "own endpoint" if r.get("endpoint") else (r.get("provider") or "auto")
-
-
-def _band(r: dict) -> str:
-    rw = r.get("reward")
-    if rw is None or r.get("status") != "done":
-        return "unscored"
-    return "full" if rw >= 0.999 else "zero" if rw <= 0 else "partial"
-
-
-def _stats(runs: list[dict]) -> dict:
-    """How the rollouts shown did: the spread of rewards, each model's mean, and each model in each group."""
-    scored = [r for r in runs if r.get("reward") is not None and r.get("status") == "done"]
-    hist = [0] * 10
-    for r in scored:
-        hist[min(9, max(0, int(float(r["reward"]) * 10)))] += 1
-    by: dict[str, list[float]] = {}
-    for r in scored:
-        by.setdefault(r.get("model") or "custom endpoint", []).append(float(r["reward"]))
-    models_ = sorted(({"model": m, "custom": any(x.get("endpoint") for x in runs if (x.get("model") or "custom endpoint") == m), "runs": len(v),
-                       "mean": round(sum(v) / len(v), 4), "best": max(v), "full": sum(x >= 0.999 for x in v),
-                       "solved": sum(x > 0 for x in v)} for m, v in by.items()), key=lambda x: (-x["mean"], -x["runs"]))
-    cells: dict[str, dict[str, list[float]]] = {}
-    for r in scored:
-        cells.setdefault(r.get("model") or "custom endpoint", {}).setdefault(_group(r), []).append(float(r["reward"]))
-    matrix = {m: {g: {"mean": round(sum(v) / len(v), 4), "runs": len(v)} for g, v in gs.items()} for m, gs in cells.items()}
-    return {"runs": len(runs), "scored": len(scored), "mean": round(sum(float(r["reward"]) for r in scored) / len(scored), 4) if scored else None,
-            "full": sum(float(r["reward"]) >= 0.999 for r in scored), "histogram": hist, "by_model": models_, "models": models_, "matrix": matrix,
-            "datasets": len({r.get("dataset") for r in runs}), "tasks": len({(r.get("dataset"), r.get("path")) for r in runs})}
-
-
-def _counts(runs: list[dict], f) -> list[list]:
-    c: dict[str, int] = {}
-    for r in runs:
-        v = f(r)
-        if v:
-            c[v] = c.get(v, 0) + 1
-    return [[k, n] for k, n in sorted(c.items(), key=lambda kv: -kv[1])]
-
-
 @app.get("/api/community")
 def community(dataset: str = "", group: str = "", model: str = "", served: str = "", judge: str = "", reward: str = "", thinking: str = "",
               runner: str = "", q: str = "", sort: str = "new", d: str = "", p: str | None = None, limit: int = 100, offset: int = 0):
-    """Public, graded rollouts, by anyone, without who ran them: filtered every way a reader might want, and how each
-    model does, overall and in each environment (MiMo's domains count as environments of their own)."""
+    """Finished, graded public rollouts from any saved runner, without account identities or private endpoint locations."""
     everyone = [r for r in store.list_runs(public=True, limit=100000) if _shareable(r)]
-    dataset = dataset or d
-
-    def keep(r):
-        return ((not dataset or r.get("dataset") == dataset) and (p is None or r.get("path") == p) and (not group or _group(r) == group)
-                and (not model or (r.get("model") or "") == model) and (not served or _served(r) == served)
-                and (not judge or (r.get("judge") or "") == judge) and (not reward or _band(r) == reward)
-                and (not thinking or ((r.get("params") or {}).get("thinking") or "default") == thinking)
-                and (not runner or (r.get("runner") or "harbor") == runner)
-                and (not q or q.lower() in f"{r.get('title', '')} {r.get('task_id', '')} {r.get('path', '')}".lower()))
-    runs = [r for r in everyone if keep(r)]
-    key = {"reward_desc": lambda r: -(r.get("reward") if r.get("reward") is not None else -1),
-           "reward_asc": lambda r: (r.get("reward") if r.get("reward") is not None else 2),
-           "cost_asc": lambda r: (r.get("cost") or {}).get("total", 0), "cost_desc": lambda r: -(r.get("cost") or {}).get("total", 0)}.get(sort)
-    if key:
-        runs.sort(key=key)
-    facets = {"group": _counts(everyone, _group), "dataset": _counts(everyone, lambda r: r.get("dataset")),
-              "model": _counts(everyone, lambda r: r.get("model")), "served": _counts(everyone, _served), "judge": _counts(everyone, lambda r: r.get("judge")),
-              "reward": _counts(everyone, _band), "thinking": _counts(everyone, lambda r: (r.get("params") or {}).get("thinking") or "default"),
-              "runner": _counts(everyone, lambda r: r.get("runner") or "harbor")}
-    page = runs[max(0, offset): max(0, offset) + max(1, min(limit, 500))]
-    return {"stats": _stats(runs), "facets": facets, "total": len(runs), "tasks": len({(r.get("dataset"), r.get("path")) for r in runs}),
-            "runs": [{**_public_view(r), "group": _group(r), "shot": r.get("domain") == "webdev" and store.has_artifact(r["id"], "screenshot.jpg")} for r in page]}
+    filters = {"dataset": dataset or d, "path": p, "group": group, "model": model, "served": served, "judge": judge,
+               "reward": reward, "thinking": thinking, "runner": runner, "q": q[:200]}
+    out = community_data.query(everyone, filters, sort=sort, offset=offset, limit=limit)
+    out["runs"] = [{**_public_view(r), "runner": community_data.runner(r), "group": community_data.group(r),
+                    "shot": r.get("domain") == "webdev" and store.has_artifact(r["id"], "screenshot.jpg")} for r in out["runs"]]
+    return out
 
 
 @app.get("/api/community/tasks")
@@ -664,7 +612,7 @@ def community_tasks(dataset: str):
         if r.get("reward") is not None:
             t["scored"] += 1
             t["sum"] += float(r["reward"])
-            t["best"] = max(t["best"] if t["best"] is not None else 0, float(r["reward"]))
+            t["best"] = max(t["best"], float(r["reward"])) if t["best"] is not None else float(r["reward"])
     return {"tasks": {k: {"runs": v["runs"], "mean": round(v["sum"] / v["scored"], 4) if v["scored"] else None, "best": v["best"], "last": v["last"],
                           "title": v["title"]} for k, v in out.items()}}
 
@@ -692,6 +640,14 @@ def run_artifact(run_id: str, name: str, request: Request):
 LLM_REPLY_MAX = 64 * 1024 * 1024
 
 
+@app.get("/api/llm/{cap}/health")
+def llm_health(cap: str):
+    from .mimo.runner import core as events
+    if events.by_cap(cap) is None:
+        raise HTTPException(404, "unknown or finished rollout")
+    return {"status": "ok"}
+
+
 @app.post("/api/llm/{cap}/v1/chat/completions")
 async def llm_proxy(cap: str, request: Request):
     import asyncio
@@ -712,6 +668,8 @@ async def llm_proxy(cap: str, request: Request):
         body = json.loads(raw)
     except ValueError:
         return JSONResponse({"error": {"message": "invalid JSON"}}, 400)
+    if not isinstance(body, dict):
+        return JSONResponse({"error": {"message": "JSON object required"}}, 400)
     up = r.upstream(str(body.get("model") or ""))
     if up is None:
         return JSONResponse({"error": {"message": "this rollout may not call that model"}}, 403)

app/mcp_bridge.py

@@ -51,6 +51,9 @@ def _limited(owner: str) -> bool:
     now = time.time()
     with _lock:
         hits = [t for t in _hits.get(owner, []) if now - t < RATE[1]]
+        if len(hits) >= RATE[0]:
+            _hits[owner] = hits
+            return True
         hits.append(now)
         _hits[owner] = hits
         if len(_hits) > 5000:
@@ -84,19 +87,31 @@ def _tools(info: dict) -> list[dict[str, Any]]:
         ]
         # a tool server takes its actions as tool calls: it gets reset and state, not step
         tools += [t for t in episode if not (names and t["name"] == "step")]
-    # a server's own routes (NeMo Gym, ORS, custom): one tool each, named after its path, when it has no tools of its own
-    if not info.get("mcp") and info.get("api"):
+    # Keep published grading/seed routes alongside native tools, without naming collisions.
+    if info.get("api"):
         taken = {t["name"] for t in tools}
         for r in info["api"]:
             name = _route_tool(r)
             if name in taken:
                 continue
             taken.add(name)
-            props = {p: {"type": "string", "description": "in the path"} for p in r["params"]}
-            body = r.get("schema") or {}
-            props.update({k: v for k, v in (body.get("properties") or {}).items()})
+            # Separate request locations: a body key named 'id' or 'query' must
+            # not overwrite a path/query parameter with the same name.
+            props, required = {}, []
+            if r["params"]:
+                props["path_params"] = {"type": "object", "properties": {p: {"type": "string"} for p in r["params"]},
+                                        "required": r["params"], "additionalProperties": False}
+                required.append("path_params")
+            if (r.get("query_schema") or {}).get("properties"):
+                props["query"] = r["query_schema"]
+                if r["query_schema"].get("required"):
+                    required.append("query")
+            if r["method"] == "POST":
+                props["body"] = r.get("schema") or {"type": "object"}
+                if r.get("body_required"):
+                    required.append("body")
             tools.append({"name": name, "description": f"{r['method']} {r['path']}" + (f": {r['summary']}" if r["summary"] else ""),
-                          "inputSchema": {"type": "object", "properties": props, "required": list(r["params"]) + list(body.get("required") or [])}})
+                          "inputSchema": {"type": "object", "properties": props, "required": required, "additionalProperties": False}})
     if info.get("task_api"):
         extra = [
             {"name": "list_splits", "description": "The server's task splits and how many tasks each holds.", "inputSchema": {"type": "object", "properties": {}}},
@@ -163,11 +178,12 @@ def _call(spec: str, info: dict, client: dict, name: str, args: dict) -> dict[st
         if name == "list_tasks":
             return _content(live.tasks(spec, str(args.get("split", "")), int(args.get("start", 0) or 0), int(args.get("stop", 20) or 20)))
         return _content(live.task(spec, str(args.get("split", "")), int(args.get("index", 0) or 0)))
-    route = next((r for r in info.get("api") or [] if _route_tool(r) == name), None) if not own else None
+    route = next((r for r in info.get("api") or [] if _route_tool(r) == name), None)
     if route is not None:
-        params = {p: args.get(p) for p in route["params"]}
-        body = {k: v for k, v in args.items() if k not in route["params"]} if route["method"] == "POST" else None
-        out = live.act(_play(spec, client), client["owner"], "http", {"method": route["method"], "path": route["path"], "params": params, "body": body})["result"]
+        params = args.get("path_params") if isinstance(args.get("path_params"), dict) else {}
+        query = args.get("query") if isinstance(args.get("query"), dict) else {}
+        body = args.get("body") if route["method"] == "POST" else None
+        out = live.act(_play(spec, client), client["owner"], "http", {"method": route["method"], "path": route["path"], "params": params, "query": query, "body": body})["result"]
         payload = out.get("json", out.get("text"))
         result = _content(payload if payload is not None else {"status": out["status"]})
         if out["status"] >= 400:

app/mimo/__init__.py

@@ -3,7 +3,7 @@ every one of its 7,780 tasks browsable in full (brief, agent prompt, systems and
 repository, the grader with its judge prompts), and rollouts on its own harness: OpenCode on an HF Sandbox, graded by
 Xiaomi's graders (hidden tests, a fuzz crash, rubric checks with a judge model, a screenshot judge, the music scorer).
 
-The code is the MiMo explorer's (mimo-explorer/app), kept close to it so the two can be compared and synced:
+The code is the MiMo explorer's (tooling/mimo-rl-explorer/app), kept close to it so the two can be compared and synced:
     catalog.py   the task views and what the runner needs (data/: the browsing index, built by build_data.py)
     judges.py    the judge prompts, pinned
     previews.py  workspace file previews (spreadsheets, documents, slides, PDFs)

app/mimo/runner/core.py

@@ -137,7 +137,7 @@ class Rollout:
         self.update(flavor=flavor)
         t = time.time()
         self.sandbox = Sandbox.create(image=image, flavor=flavor, idle_timeout=config.SANDBOX_IDLE_TIMEOUT,
-                                      forward_hf_token=not config.PUBLIC_URL, token=self.token, start_timeout=900,
+                                      forward_hf_token=False, token=self.token, start_timeout=900,
                                       labels={"app": "rl-explorer", "runner": "mimo", "run": self.id})
         self.update(sandbox_id=self.sandbox.id)
         self.phase("sandbox", "done", f"ready in {time.time() - t:.0f}s")
@@ -152,8 +152,30 @@ class Rollout:
         return config.ROUTER, self.token, mid
 
     def llm_base(self) -> str | None:
-        """The OpenAI-compatible base URL the sandbox should use, or None to call the provider directly."""
-        return f"{config.PUBLIC_URL}/api/llm/{self.cap}/v1" if config.PUBLIC_URL else None
+        """Only a per-run capability reaches the sandbox, including local previews."""
+        if config.PUBLIC_URL:
+            return f"{config.PUBLIC_URL}/api/llm/{self.cap}/v1"
+        from ...runner import _proxy_url
+        return f"{_proxy_url().rstrip('/')}/rlx/llm/{self.cap}/v1"
+
+    def check_model_network(self):
+        """Check the exact relay path from the sandbox, without a model call."""
+        url = self.llm_base().removesuffix("/v1") + "/health"
+        script = ("import urllib.request,urllib.error\n"
+                  f"url={url!r}\n"
+                  "try:\n"
+                  " r=urllib.request.urlopen(url,timeout=15)\n"
+                  " print('relay HTTP',r.status)\n"
+                  "except urllib.error.HTTPError as e:\n"
+                  " print('relay HTTP',e.code);raise SystemExit(1)\n"
+                  "except Exception as e:\n"
+                  " print(type(e).__name__);raise SystemExit(1)\n")
+        import shlex
+        result = self.sh("python3 -c " + shlex.quote(script), timeout=25)
+        if result.exit_code:
+            raise RuntimeError("The sandbox cannot reach the model relay. Check HTTPS egress from the sandbox and ingress to the explorer. "
+                               "No account token was forwarded. " + (result.stdout or "")[-120:])
+        self.log("Network check passed: sandbox → model relay. HF account token stays on the explorer.")
 
     def upstream(self, model: str) -> tuple[str, str | None] | None:
         """For the model proxy: (base URL, key) for a model this rollout may call, else None."""
@@ -193,12 +215,16 @@ class Rollout:
     def execute(self) -> None:
         from .domains import ADAPTERS
 
-        adapter = ADAPTERS[self.run["domain"]]
+        if self.run.get("runner") == "nemo-gym":
+            from ... import nemo_runner as adapter
+        else:
+            adapter = ADAPTERS[self.run["domain"]]
         try:
             self.update(status="starting", started_at=time.time())
             self.settle_model()
             result = adapter.run(self)
-            self.update(status="done", reward=result.get("reward"), reward_error=result.get("error"),
+            self.update(status="done", phase="done", reward=result.get("reward"), reward_error=result.get("error"),
+                        graded=result.get("reward") is not None, wall_s=round(time.time() - self.t0, 2),
                         finished_at=time.time(), cost=self.cost_now())
             self.phase("done", "done", f"reward {result.get('reward')}" if result.get("reward") is not None
                        else f"not scored: {result.get('error')}")
@@ -217,10 +243,12 @@ class Rollout:
                 self._flush()
             self.stop_sandbox()
             self.agent_key = None
+            self.native_task = None
             with _live_lock:
                 _caps.pop(self.cap, None)
             with _live_lock:
                 _live.pop(self.id, None)
+            self.token = ""
 
     def stop_sandbox(self) -> None:
         if self.sandbox is None:
@@ -270,11 +298,12 @@ def submit(user: str, token: str, task: dict, model: str, provider: str | None,
         "facets": task.get("facets"), "model": model, "provider": provider, "judge": judge,
         "status": "queued", "harness": "opencode", "endpoint": endpoint, "params": params or {},
         "visibility": "private" if visibility == "private" else "public",
-        "image": catalog.image_for(task["id"]) if task["domain"] != "music" else None,
+        "image": catalog.image_for(task["id"]) if task["domain"] not in ("music", "nemo-gym") else None,
         "provenance": version.provenance(),
         **(extra or {}),
     })
     r = Rollout(run, token, agent_key)
+    r.native_task = task.get("native_task")  # reference action stays in memory; never in the run record
     with _live_lock:
         _live[r.id] = r
         _caps[r.cap] = r

app/mimo/runner/opencode.py

@@ -119,6 +119,7 @@ def run(r, prompt: str, cwd: str, *, steps: int, timeout: float, user: str | Non
     steps = params.get("steps") or steps
     timeout = params["timeout_min"] * 60 if params.get("timeout_min") else timeout
     proxy = r.llm_base()
+    r.check_model_network()
     cfg = config_for(r.run["model"], r.run.get("provider"), steps, mcp, ep, params, proxy)
     r.sandbox.files.write("/tmp/opencode.json", json.dumps(cfg))
     r.sandbox.files.write("/tmp/prompt.txt", prompt)
@@ -166,6 +167,10 @@ def run(r, prompt: str, cwd: str, *, steps: int, timeout: float, user: str | Non
             r.sandbox.run("rm -f /root/.agent_key", shell=True, check=False, timeout=30)
     if buf[0].strip():
         _event(r, buf[0], texts)
+    if getattr(r, "agent_failure", None):
+        raise RuntimeError("The agent's model call failed; this run is not graded. " + r.agent_failure[:500])
+    if res.exit_code and not res.timed_out:
+        raise RuntimeError(f"The agent exited with code {res.exit_code}; this run is not graded.")
     if res.timed_out:
         r.emit("error", text=f"The agent hit the {int(timeout // 60)}-minute limit; grading what it left.")
     return texts[-1] if texts else ""
@@ -209,8 +214,8 @@ def _event(r, line: str, texts: list[str]) -> None:
                                  "so OpenCode ends the session there, as it does in Xiaomi's harness.")
     elif typ == "error":
         err = ev.get("error") or part
-        r.emit("error", text=(err.get("data") or {}).get("message") or json.dumps(err)[:800]
-               if isinstance(err, dict) else str(err)[:800])
+        r.agent_failure = ((err.get("data") or {}).get("message") or json.dumps(err)[:800]) if isinstance(err, dict) else str(err)[:800]
+        r.emit("error", text=r.agent_failure)
 
 
 def _scripted(r, cwd: str, user: str | None) -> str:

app/nemo_runner.py

@@ -0,0 +1,158 @@
+"""One-step NeMo Pivot prediction, scored by NVIDIA's unmodified comparator.
+
+Tool definitions are prediction targets; tool calls are never executed. No task
+code, model key, or reference action enters a sandbox. Other Gym agents require
+their resources server and are intentionally outside this adapter's scope.
+"""
+from __future__ import annotations
+
+import json
+
+import httpx
+from pydantic import TypeAdapter
+
+from .vendor.nemo_gym.verification_utils import (
+    ActionComparator, ExpectedAction, FunctionCallAction, FunctionCallBatchAction,
+    MessageAction, StepRewardCategory, ToolCallComparatorConfig,
+)
+
+REVISION = "3ef478df1ee163134d32a3f291f0a9e5981d0e52"
+CONFIGS = {
+    "resources_servers/single_step_tool_use_with_argument_comparison/configs/"
+    + name + ".yaml" for name in (
+        "single_step_tool_use_with_argument_comparison",
+        "toolcall_schema_single_step_tool_use_with_argument_comparison",
+    )
+}
+
+
+def supported(agent):
+    return agent.get("known") and agent.get("agent_type") == "tool_simulation_agent" and agent.get("config") in CONFIGS
+
+
+def strict_schema(schema):
+    if not isinstance(schema, dict):
+        return False
+    if schema.get("type") == "object" or "properties" in schema:
+        if schema.get("additionalProperties") is not False or set(schema.get("required") or []) != set(schema.get("properties") or {}):
+            return False
+    return all(strict_schema(v) for k, v in schema.items() if k in ("items", "additionalProperties") and isinstance(v, dict)) and all(
+        strict_schema(v) for v in (schema.get("properties") or {}).values()) and all(
+        strict_schema(v) for k in ("anyOf", "oneOf", "allOf") for v in schema.get(k, []))
+
+
+def relaxed_tools(row):
+    return [t["name"] for t in (row.get("responses_create_params") or {}).get("tools", [])
+            if isinstance(t, dict) and t.get("name") and t.get("strict") is True and not strict_schema(t.get("parameters"))]
+
+
+def responses_request(row):
+    """Keep NeMo's native Responses input, including prior reasoning and tool turns.
+
+    Only function definitions are allowed: provider-hosted MCP, web search and
+    code execution would change a prediction task into a side-effecting agent.
+    """
+    rcp = row.get("responses_create_params")
+    if not isinstance(rcp, dict) or not rcp.get("input"):
+        raise ValueError("This row has no NeMo Gym Responses request")
+    if len(json.dumps(rcp)) > 200_000:
+        raise ValueError("This task's model input exceeds the hosted limit")
+    raw = rcp["input"]
+    if not isinstance(raw, (str, list)) or isinstance(raw, list) and len(raw) > 500:
+        raise ValueError("This row needs the native NeMo Gym runtime")
+    tools = rcp.get("tools") or []
+    if not isinstance(tools, list) or len(tools) > 128 or not all(
+        isinstance(t, dict) and t.get("type") == "function" and isinstance(t.get("name"), str) for t in tools
+    ):
+        raise ValueError("Only function prediction tools are supported here; use the native NeMo Gym runtime")
+    allowed = {"input", "instructions", "tools", "tool_choice", "temperature", "top_p", "parallel_tool_calls", "reasoning", "text"}
+    # Model, token limits, persistence and execution mode belong to the runner.
+    body = {k: v for k, v in rcp.items() if k in allowed and v is not None}
+    relaxed = set(relaxed_tools(row))
+    if tools:
+        body["tools"] = [{**t, "strict": False} if t["name"] in relaxed else t for t in tools]
+    return body
+
+
+def prediction(response):
+    """Match NeMo's response_utils.extract_action: calls take precedence over text."""
+    if response.get("error") or response.get("status") in ("failed", "cancelled"):
+        error = response.get("error") or {}
+        raise ValueError("Inference provider did not produce a prediction: " + str(error.get("message") or response.get("status"))[:600])
+    if not isinstance(response.get("output"), list):
+        raise ValueError("Inference provider returned an invalid Responses payload")
+    if response.get("status") == "incomplete" and not response["output"]:
+        raise ValueError("The model reached its output limit without a prediction. Increase Max output tokens.")
+    calls, content = [], None
+    for item in response.get("output") or []:
+        if item.get("type") == "function_call":
+            calls.append({"function": {"name": item["name"], "arguments": item["arguments"]}})
+        elif item.get("type") == "message" and item.get("role") == "assistant" and content is None:
+            content = next((p["text"] for p in item.get("content", []) if p.get("type") == "output_text"), None)
+    return {"tool_calls": calls, "content": content}
+
+
+def validate(row, agent):
+    if not supported(agent):
+        raise ValueError("This NeMo resources server is not hosted here")
+    responses_request(row)
+    if len(json.dumps(row.get("expected_action"))) > 100_000:
+        raise ValueError("The reference action exceeds the hosted verifier limit")
+    try:
+        return TypeAdapter(ExpectedAction).validate_python(row.get("expected_action"))
+    except ValueError:
+        raise ValueError("The reference action is invalid for this NeMo Gym verifier") from None
+
+
+def score(expected, message):
+    calls = message.get("tool_calls") or []
+    if len(calls) > 64:
+        raise ValueError("The provider returned too many tool calls")
+    actions = [FunctionCallAction(type="function_call", name=c["function"]["name"], arguments=c["function"]["arguments"]) for c in calls]
+    actual = (actions[0] if len(actions) == 1 else FunctionCallBatchAction(type="function_call_batch", calls=actions)) if actions else (
+        MessageAction(type="message", content=message["content"]) if isinstance(message.get("content"), str) else None)
+    if actual is None:
+        return 0.0, str(StepRewardCategory.NO_ACTION_FOUND)
+    result = ActionComparator(config=ToolCallComparatorConfig(word_count_similarity_threshold=0.1)).compare_action(expected, actual)
+    return result.reward, str(result.category)
+
+
+def run(r):
+    payload = r.native_task
+    expected = validate(payload["row"], payload["agent"])
+    body = responses_request(payload["row"])
+    base, key, model = r.agent_api()
+    params = r.run["params"]
+    body.update(model=model, max_output_tokens=params.get("max_tokens", 2048), stream=False, store=False)
+    if params.get("temperature") is not None:
+        body["temperature"] = params["temperature"]
+    r.check_cancel()
+    r.phase("agent", detail="One prediction; tools are not executed")
+    if relaxed_tools(payload["row"]):
+        r.log("Some source tools declare strict=true with incompatible parameter schemas. Kept the original parameters and disabled strict enforcement for: "
+              + ", ".join(relaxed_tools(payload["row"])))
+    r.emit("prompt", harness="nemo-gym", text=json.dumps({k: v for k, v in body.items() if k != "model"}, ensure_ascii=False, indent=2))
+    response = httpx.post(base + "/responses", json=body, headers={"Authorization": f"Bearer {key}"}, timeout=90, follow_redirects=False)
+    if response.status_code != 200:
+        raise RuntimeError(f"Inference provider returned HTTP {response.status_code}; check model availability and Inference Providers permission")
+    r.check_cancel()
+    if len(response.content) > 2_000_000:
+        raise ValueError("The model response exceeds the hosted limit")
+    result = response.json()
+    message = prediction(result)
+    if message.get("content"):
+        r.emit("text", text=message["content"])
+    for call in (message.get("tool_calls") or [])[:64]:
+        r.emit("tool", tool=call["function"]["name"], title="Predicted tool call", input=call["function"]["arguments"],
+               output="Prediction only; no tool was executed.", status="done")
+    usage = result.get("usage") or {}
+    r.add_tokens({"input": usage.get("input_tokens", 0), "output": usage.get("output_tokens", 0)})
+    r.emit("step", tokens=r.tokens, cost=r.model_cost)
+    r.update(n_turns=1)
+    r.phase("agent", "done")
+    r.phase("verify", detail="NeMo Gym's pinned argument comparator")
+    reward, category = score(expected, message)
+    r.emit("checks", checks=[{"id": "native-comparator", "passed": reward == 1, "score": reward,
+                              "method": "NeMo Gym", "message": category}], reward=reward, summary=category)
+    r.phase("verify", "done", category)
+    return {"reward": reward}

app/runner.py

@@ -20,6 +20,7 @@ import asyncio
 import contextlib
 import contextvars
 import json
+import math
 import logging
 import re
 import secrets
@@ -28,6 +29,7 @@ import threading
 import time
 from pathlib import Path
 from typing import Any
+from fastapi import Request
 
 from . import catalog, config, dockerfile, judge, store
 
@@ -243,6 +245,16 @@ async def _replay(env: Any, plan: Any) -> None:
 
 
 # ── the capture proxy ────────────────────────────────────────────────────────
+async def _event_model_proxy(cap: str, request: Request):
+    from .main import llm_proxy
+    return await llm_proxy(cap, request)
+
+
+def _event_model_health(cap: str):
+    from .main import llm_health
+    return llm_health(cap)
+
+
 def service() -> Any:
     """OpenEnv's Harbor service: the capture proxy, and the URL the sandbox reaches it at."""
     global _service
@@ -253,6 +265,12 @@ def service() -> Any:
             # No default engine: every rollout brings its own (the visitor's token or endpoint).
             _service = HarborService(llm_url=config.ROUTER, model="", datasets=[], provider="hf", capture_level="text",
                                      expose=config.CAPTURE_EXPOSE)
+            _service.capture.app.add_api_route("/rlx/llm/{cap}/v1/chat/completions", _event_model_proxy, methods=["POST"])
+            _service.capture.app.add_api_route("/rlx/llm/{cap}/health", _event_model_health, methods=["GET"])
+            # OpenEnv ends with a catch-all POST capture route. Specific relay
+            # routes must precede it; they keep their own per-run capability auth.
+            routes = _service.capture.app.router.routes
+            routes[:] = routes[-2:] + routes[:-2]
             _patch_hf_sandbox()
             _patch_harbor_env()
             _patch_opencode_install()
@@ -525,10 +543,13 @@ def submit(user: dict[str, Any], dataset: str, path: str, harness: str, model: s
     """Start a rollout of task `path` (the environment's ref) of `dataset`, with agent `harness`, by `runner`; `fields`
     are the run option's own inputs (contract.run_option fields), checked against it."""
     from . import settings
+    from .envs.capabilities import HOSTED_RUNNERS
 
     token = user.get("token")
     if not token:
         raise PermissionError("sign in to run a rollout")
+    if runner not in HOSTED_RUNNERS:
+        raise ValueError(f"The {runner} runtime is not hosted here. Use the task's native framework instructions.")
     if not settings.get("rollouts_enabled", True):
         raise RuntimeError("Rollouts are paused for maintenance. Try again later.")
     if harness not in settings.get("agents", list(AGENT_IDS)):
@@ -547,6 +568,18 @@ def submit(user: dict[str, Any], dataset: str, path: str, harness: str, model: s
     if endpoint and not opt.get("endpoint", True):
         raise ValueError(f"the {opt['label']} runner can't use your own endpoint")
     fields = _check_fields(opt.get("fields") or [], fields or {})
+    if runner == "nemo-gym":
+        from . import nemo_runner
+        from .mimo.runner import core as events
+        with _slot(user["name"], max_user, max_all):
+            return events.submit(user["name"], token,
+                                 {"id": path, "domain": "nemo-gym", "title": row["title"], "native_task": row["native_task"]},
+                                 model, provider, None, params=fields,
+                                 visibility="private" if row.get("restricted") else visibility,
+                                 extra={"dataset": env.id, "path": path, "task_id": f"{env.id}:{path}", "env": env.key, "adapter": env.adapter.id,
+                                        "runner": runner, "harness": "single-prediction", "restricted": bool(row.get("restricted")),
+                                        "sha": row.get("sha"), "provenance": {"framework": "NeMo Gym", "commit": nemo_runner.REVISION,
+                                        "source": "https://github.com/NVIDIA-NeMo/Gym/tree/" + nemo_runner.REVISION}}, reserved=True)
     if runner == "mimo":
         return _submit_mimo(user, env, row, model, provider, endpoint, endpoint_key, fields, visibility, max_user, max_all)
     params = {**params, **{k: fields[k] for k in ("steps", "timeout_min") if k in fields}}   # the Harbor runner's limits
@@ -623,8 +656,10 @@ def _check_fields(spec: list[dict[str, Any]], given: dict[str, Any]) -> dict[str
 
             if not isinstance(v, str) or v not in {m["id"] for m in models.catalog().get(f.get("pool") or "", [])}:
                 raise ValueError(f"{f.get('label', key)}: pick one of the models offered")
-        if kind == "number" and (not isinstance(v, (int, float)) or isinstance(v, bool)):
+        if kind == "number" and (not isinstance(v, (int, float)) or isinstance(v, bool) or not math.isfinite(v)):
             raise ValueError(f"{f.get('label', key)} should be a number")
+        if kind == "number" and f.get("step") == 1 and v != int(v):
+            raise ValueError(f"{f.get('label', key)} should be a whole number")
         if kind == "number" and ((f.get("min") is not None and v < f["min"]) or (f.get("max") is not None and v > f["max"])):
             raise ValueError(f"{f.get('label', key)} should be between {f.get('min')} and {f.get('max')}")
         if kind == "bool" and not isinstance(v, bool):

app/runtime.py

@@ -52,7 +52,7 @@ def more_threads() -> None:
 
 
 # ── logs ─────────────────────────────────────────────────────────────────────
-SECRET_PATH = re.compile(r"(/api/llm/)[^/\s]+|((?:session|cap|token)=)[^&\s]+", re.I)
+SECRET_PATH = re.compile(r"(/(?:api|rlx)/llm/)[^/\s]+|((?:session|cap|token)=)[^&\s]+", re.I)
 
 
 class _Json(logging.Formatter):

app/search_api.py

@@ -5,14 +5,15 @@
 
 /api/search answers exactly as the Explore page always filtered its full listing in the browser:
 
-  kind        what an environment is: OpenEnv Spaces (a manifest or the tag, and FineEnvs' curated servers), other
+  kind        OpenEnv Spaces require fresh successful API checks. Metadata-only matches are unverified-space; other
               environment Spaces (ORS included), Harbor datasets (tagged, or an index found task folders), Verifiers,
               NeMo Gym, OpenEnv datasets, verl and SkyRL, other RL datasets
+  owner       exact Hub namespace, case-insensitive; applies to datasets and Spaces
   collection  an admin's collection, "other" (in none) or "mine" (the signed-in visitor's datasets, with mine=1)
   f           facet filters as the page's own URL writes them: `type:Benchmark|Neither;tags:code` (values
               URI-encoded); values of one facet are alternatives, facets all apply
   q           every word must be part of the id, heading, brief or tags (substrings, any case)
-  sort        trending (pinned first; with kind=openenv, FineEnvs' curated servers next) | downloads | likes | tasks |
+  sort        trending (Hub score, then likes, then monthly dataset downloads; no editorial boosts) | downloads | likes | tasks |
               rollouts | updated | new; ties keep the listing's order
 
 Each facet is counted over what every *other* filter leaves (so picking a value never hides its alternatives).
@@ -31,20 +32,24 @@ import re
 import threading
 import time
 from collections import OrderedDict
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import Any
 from urllib.parse import unquote
 
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import Response
 
-from . import snapshot
+from . import snapshot, space_checks
 
 router = APIRouter(on_startup=[snapshot.start])
 
-KINDS = ("all", "harbor", "openenv", "other-space", "verifiers", "nemo-gym", "openenv-data", "verl", "rows")
+KINDS = ("all", "harbor", "openenv", "unverified-space", "other-space", "verifiers", "nemo-gym", "openenv-data", "verl", "rows")
 SORTS = ("trending", "downloads", "likes", "tasks", "rollouts", "updated", "new")
-FACETS = ("type", "size", "stage", "mcp", "oe", "tags")
+FACETS = ("type", "size", "health", "mode", "tools", "stage", "mcp", "oe", "oe_source", "evidence", "tags")
+RANKING = {"version": 2, "source": "Hugging Face Hub", "order": ["trending", "likes", "downloads"],
+           "description": "Hub trending score first; ties use total likes, then dataset downloads over the last month. "
+                          "Spaces have no download metric. Remaining ties keep catalog order. Featured picks do not affect rank.",
+           "scope": "Current search and filters", "quality": "Interest signals, not measured environment quality or live availability."}
 OLD_KINDS = {"dataset": "harbor", "space": "openenv", "ors": "other-space"}   # the page's older links
 FACET_LIMIT = 100       # values returned per facet (most common first); the rest are counted in facets_more
 MAX_WORDS = 16
@@ -55,7 +60,9 @@ MAX_VALUES = 50
 @dataclass
 class Query:
     q: str = ""
+    scope: str = "all"
     kind: str = "all"
+    owner: str | None = None
     coll: str | None = None
     sel: dict[str, list[str]] = field(default_factory=dict)
     sort: str = "trending"
@@ -67,7 +74,7 @@ class Query:
         return self.q.lower().split()[:MAX_WORDS]
 
     def public(self) -> dict[str, Any]:
-        return {"q": self.q, "kind": self.kind, "collection": self.coll, "f": self.sel, "sort": self.sort,
+        return {"q": self.q, "scope": self.scope, "owner": self.owner, "kind": self.kind, "collection": self.coll, "f": self.sel, "sort": self.sort,
                 "page": self.page, "size": self.size}
 
 
@@ -79,6 +86,10 @@ def parse_f(f: str) -> dict[str, list[str]]:
         if k not in FACETS or not v:
             continue
         vals = [unquote(x)[:200] for x in v.split("|") if x]
+        if k == "stage" and "Asleep or stopped" in vals:   # saved links from the former broad bucket
+            vals = [x for x in vals if x != "Asleep or stopped"] + ["Sleeping", "Paused", "Building", "Starting", "Error", "Deleting"]
+        if k == "mcp":
+            vals = ["MCP tagged" if x == "Has MCP tools" else x for x in vals]
         for x in vals:
             if x not in sel.setdefault(k, []) and len(sel[k]) < MAX_VALUES:
                 sel[k].append(x)
@@ -101,7 +112,7 @@ def parse_query(params: Any, collections: list[dict[str, Any]], mine: bool) -> Q
     coll = g("collection", "c")
     known = {c["id"] for c in collections} | {"other"} | ({"mine"} if mine else set())
     sort = g("sort", "s") or "trending"
-    return Query(q=(g("q") or "").strip()[:200], kind=kind if kind in KINDS else "all", coll=coll if coll in known else None,
+    return Query(q=(g("q") or "").strip()[:200], scope="ready" if g("scope") == "ready" else "all", owner=(g("owner") or "").strip()[:200] or None, kind=kind if kind in KINDS else "all", coll=coll if coll in known else None,
                  sel=parse_f(g("f") or ""), sort=sort if sort in SORTS else "trending",
                  page=_int(g("page"), 1, 1, 10_000), size=_int(g("size"), 40, 1, 100))
 
@@ -155,12 +166,14 @@ class Ctx:
     hidden: list[str]
     mine: list[str]
     rolls: dict[str, int]
+    checks: dict[str, dict] = field(default_factory=dict)
 
     def params(self) -> dict[str, str]:
         """The admin settings as query parameters: each collection's keys, pins, hidden ones, the visitor's, rollouts.
         (Lists checked with IN, which SQLite evaluates once per statement: no per-row JSON.)"""
         out = {"pins": json.dumps(self.pins), "hidden": json.dumps(self.hidden), "mine": json.dumps(self.mine),
-               "rolls": json.dumps(self.rolls)}
+               "rolls": json.dumps(self.rolls), "checks": json.dumps([
+                   {**r, "status": space_checks.status(r), "browseable": space_checks.browseable(r)} for r in self.checks.values()])}
         for i, g in enumerate(self.collections):
             out[f"c{i}"] = json.dumps([k for k, c in self.cmap.items() if c == g["id"]])
             out[f"cid{i}"] = g["id"]
@@ -181,32 +194,53 @@ def context(mine: list[str] | None = None) -> Ctx:
         for k in g.get("ids") or []:
             cmap.setdefault(k, g["id"])   # the first collection naming it, as catalog.collection_of
     return Ctx(collections=[{k: v for k, v in g.items() if k != "ids"} for g in colls], cmap=cmap, pins=list(catalog.pinned()),
-               hidden=sorted(catalog.hidden()), mine=list(mine or []), rolls=rollout_counts())
+               hidden=sorted(catalog.hidden()), mine=list(mine or []), rolls=rollout_counts(), checks=space_checks.inventory())
 
 
 # ── SQL over the snapshot ────────────────────────────────────────────────────
 BASE = """
-WITH b0 AS (
+WITH checks AS MATERIALIZED (
+  SELECT CAST(json_extract(value, '$.id') AS TEXT) AS id, value AS check_json FROM json_each(:checks)
+), b0 AS (
   SELECT e.rowid AS rid, e.ord, e.id, e.key, e.kind, e.framework, e.openenv, e.heading, e.brief, e.downloads, e.likes,
          e.trending, e.created, e.updated, e.created_ms, e.updated_ms, e.stage, e.mcp, e.openenv_version, e.manifest,
          e.hardware, e.badges, e.tags, e.tasks, e.indexed, e.size_f, e.stage_f, e.mcp_f, e.oe_f, e.blob,
+         c.check_json,
          {coll} AS coll,
          (e.key IN (SELECT value FROM json_each(:pins))) AS pinned,
          (e.key IN (SELECT value FROM json_each(:mine))) AS mine
   FROM envs e
+  LEFT JOIN checks c ON c.id = e.id AND e.kind = 'space'
   WHERE e.key NOT IN (SELECT value FROM json_each(:hidden))
 ),
-b1 AS (SELECT b0.*, (kind = 'space' AND coll IS 'fineenvs' AND framework IS NOT 'openenv') AS ov FROM b0),
 base AS (
-  SELECT b1.*,
-         CASE WHEN ov THEN 'openenv' ELSE framework END AS framework_q,
-         CASE WHEN ov THEN 1 ELSE openenv END AS openenv_q,
-         CASE WHEN ov THEN '["OpenEnv"]' ELSE badges END AS badges_q,
-         CASE WHEN kind = 'space' THEN (CASE WHEN ov OR framework IS 'openenv' OR openenv THEN 'openenv' ELSE 'other-space' END)
-              ELSE COALESCE(framework, 'harbor') END AS fw
-  FROM b1
+  SELECT b0.*,
+         CASE WHEN kind = 'space' THEN CASE WHEN {verified} THEN 'openenv' WHEN framework = 'ors' THEN 'ors' ELSE 'space' END ELSE framework END AS framework_q,
+         CASE WHEN kind = 'space' AND {verified} THEN 1 ELSE 0 END AS openenv_q,
+         CASE WHEN kind = 'space' AND NOT COALESCE(({verified}), 0) THEN
+           (SELECT json_group_array(value) FROM json_each(badges) WHERE value != 'OpenEnv') ELSE badges END AS badges_q,
+         CASE WHEN kind = 'space' THEN (CASE WHEN {verified} THEN 'openenv' WHEN framework IS 'openenv' OR openenv THEN 'unverified-space' ELSE 'other-space' END)
+              ELSE COALESCE(framework, 'harbor') END AS fw,
+         CASE WHEN kind = 'space' AND (framework IS 'openenv' OR openenv)
+              THEN CASE WHEN manifest IS NOT NULL THEN 'Manifest present' ELSE 'Hub tag only' END END AS evidence_f,
+         CASE WHEN kind = 'space' THEN {stage} END AS runtime_f,
+         CASE WHEN kind = 'space' THEN CASE WHEN mcp THEN 'MCP tagged' ELSE 'No MCP tag' END END AS mcp_tag_f,
+         CASE WHEN kind = 'space' AND (framework IS 'openenv' OR openenv OR ({verified}))
+              THEN COALESCE(json_extract(check_json, '$.status'), 'Not checked') END AS health_f,
+         CASE WHEN json_extract(check_json, '$.status') = 'API checked' THEN json_extract(check_json, '$.mode') END AS mode_f,
+         CASE WHEN kind = 'space' AND (framework IS 'openenv' OR openenv OR ({verified})) THEN
+           CASE WHEN json_extract(check_json, '$.status') IN ('API checked', 'Checks failed') THEN
+             CASE WHEN json_extract(check_json, '$.tools') > 0 THEN 'Tools discovered' ELSE 'No tools discovered' END
+           ELSE 'Not checked' END END AS tools_f,
+         CASE WHEN kind = 'space' AND (framework IS 'openenv' OR openenv OR ({verified})) THEN
+           COALESCE(NULLIF(json_extract(check_json, '$.version.value'), 'Unknown'), openenv_version, 'Unknown') END AS version_f,
+         CASE WHEN kind = 'space' AND (framework IS 'openenv' OR openenv OR ({verified})) THEN
+           CASE WHEN json_extract(check_json, '$.version.value') IS NOT NULL AND json_extract(check_json, '$.version.value') != 'Unknown'
+             THEN json_extract(check_json, '$.version.source') WHEN openenv_version IS NOT NULL THEN 'Hub tag' ELSE 'Unknown' END END AS version_source_f
+  FROM b0
 )
-"""
+""".replace("{stage}", snapshot.stage_sql("stage")).replace("{verified}",
+    "json_extract(check_json, '$.status') = 'API checked' AND json_extract(check_json, '$.stage') = 'RUNNING'")
 ROLLOUTS = "COALESCE((SELECT value FROM json_each(:rolls) WHERE key = b.id), 0)"
 
 
@@ -214,33 +248,51 @@ TYPE_VALUES = "json_each(CASE WHEN json_array_length(b.badges_q) = 0 THEN '[\"Ne
 FACET_FILTER = {
     "type": f"EXISTS (SELECT 1 FROM {TYPE_VALUES} j WHERE j.value IN (SELECT value FROM json_each({{p}})))",
     "size": "b.size_f IN (SELECT value FROM json_each({p}))",
-    "stage": "b.stage_f IN (SELECT value FROM json_each({p}))",
-    "mcp": "b.mcp_f IN (SELECT value FROM json_each({p}))",
-    "oe": "b.oe_f IN (SELECT value FROM json_each({p}))",
+    "stage": "b.runtime_f IN (SELECT value FROM json_each({p}))",
+    "health": "b.health_f IN (SELECT value FROM json_each({p}))",
+    "mode": "b.mode_f IN (SELECT value FROM json_each({p}))",
+    "tools": "b.tools_f IN (SELECT value FROM json_each({p}))",
+    "mcp": "b.mcp_tag_f IN (SELECT value FROM json_each({p}))",
+    "oe": "b.version_f IN (SELECT value FROM json_each({p}))",
+    "oe_source": "b.version_source_f IN (SELECT value FROM json_each({p}))",
+    "evidence": "b.evidence_f IN (SELECT value FROM json_each({p}))",
     "tags": "EXISTS (SELECT 1 FROM json_each(b.tags) j WHERE j.value IN (SELECT value FROM json_each({p})))",
 }
 FACET_COUNT = {   # FROM, value expression, extra condition
     "type": (f"base b, {TYPE_VALUES} j", "j.value", "1"),
     "size": ("base b", "b.size_f", "b.size_f IS NOT NULL"),
-    "stage": ("base b", "b.stage_f", "b.stage_f IS NOT NULL"),
-    "mcp": ("base b", "b.mcp_f", "b.mcp_f IS NOT NULL"),
-    "oe": ("base b", "b.oe_f", "b.oe_f IS NOT NULL"),
+    "stage": ("base b", "b.runtime_f", "b.runtime_f IS NOT NULL"),
+    "health": ("base b", "b.health_f", "b.health_f IS NOT NULL"),
+    "mode": ("base b", "b.mode_f", "b.mode_f IS NOT NULL"),
+    "tools": ("base b", "b.tools_f", "b.tools_f IS NOT NULL"),
+    "mcp": ("base b", "b.mcp_tag_f", "b.mcp_tag_f IS NOT NULL"),
+    "oe": ("base b", "b.version_f", "b.version_f IS NOT NULL"),
+    "oe_source": ("base b", "b.version_source_f", "b.version_source_f IS NOT NULL"),
+    "evidence": ("base b", "b.evidence_f", "b.evidence_f IS NOT NULL"),
     "tags": ("base b, json_each(b.tags) j", "j.value", "1"),
 }
-TRENDING = "((b.pinned * 1e15) + ((b.trending * 1e9 + b.likes * 1e4) + MIN(b.downloads, 9999)))"
+TRENDING = "b.trending"
 SORT_SQL = {"trending": TRENDING, "downloads": "b.downloads", "likes": "b.likes", "tasks": "COALESCE(b.tasks, -1)",
             "rollouts": ROLLOUTS, "updated": "b.updated_ms", "new": "b.created_ms"}
 
 
 def sort_sql(q: Query) -> str:
-    if q.sort == "trending" and q.kind == "openenv":   # FineEnvs' curated servers lead the OpenEnv Spaces
-        return f"((b.coll IS 'fineenvs') * 1e14 + {TRENDING})"
     return SORT_SQL[q.sort]
 
 
+def order_sql(q: Query) -> str:
+    return "sk DESC, " + ("b.likes DESC, b.downloads DESC, " if q.sort == "trending" else "") + "b.ord ASC"
+
+
+def order_key(q: Query, d: dict[str, Any]) -> tuple:
+    return (-d["_sk"],) + ((-(d.get("likes") or 0), -(d.get("downloads") or 0)) if q.sort == "trending" else ()) + (d["_ord"],)
+
+
 def where(q: Query, skip: str | None = None, ignore_coll: bool = False, ignore_kind: bool = False) -> tuple[str, dict[str, Any]]:
     parts: list[str] = []
     params: dict[str, Any] = {}
+    if q.scope == "ready":
+        parts.append("(b.kind = 'dataset' OR json_extract(b.check_json, '$.browseable') = 1)")
     if not ignore_kind and q.kind != "all":
         parts.append("b.fw = :kind")
         params["kind"] = q.kind
@@ -250,6 +302,9 @@ def where(q: Query, skip: str | None = None, ignore_coll: bool = False, ignore_k
         else:
             parts.append("COALESCE(b.coll, 'other') = :coll")
             params["coll"] = q.coll
+    if q.owner:
+        parts.append("substr(b.id, 1, instr(b.id, '/') - 1) = :owner COLLATE NOCASE")
+        params["owner"] = q.owner
     words = q.words
     if words:
         fts = envs_fts_query(words)
@@ -274,6 +329,9 @@ def card(r: Any, rolls: dict[str, int]) -> dict[str, Any]:
             "downloads": r["downloads"], "likes": r["likes"], "trending": r["trending"], "updated": r["updated"],
             "created": r["created"], "stage": r["stage"], "mcp": bool(r["mcp"]), "openenv_version": r["openenv_version"],
             "manifest": r["manifest"], "hardware": r["hardware"], "badges": json.loads(r["badges_q"]), "tags": json.loads(r["tags"]),
+            "evidence": r["evidence_f"], "stage_label": r["runtime_f"],
+            "api_status": r["health_f"], "api_check": json.loads(r["check_json"]) if r["check_json"] else None,
+            "declared_version": r["version_f"], "version_source": r["version_source_f"], "api_mode": r["mode_f"], "tools_status": r["tools_f"],
             "pinned": bool(r["pinned"]), "mine": bool(r["mine"]), "indexed": json.loads(r["indexed"]) if r["indexed"] else None,
             "rollouts": rolls.get(r["id"], 0), "private": False, "_sk": r["sk"], "_ord": r["ord"]}
 
@@ -289,7 +347,7 @@ def sql_search(conn, q: Query, ctx: Ctx, *, facets: bool = True, limit: int | No
     w, p = where(q)
     lim = q.size if limit is None else limit
     off = (q.page - 1) * q.size if offset is None else offset
-    rows = conn.execute(f"{B} SELECT b.*, {sort_sql(q)} AS sk FROM base b WHERE {w} ORDER BY sk DESC, b.ord ASC LIMIT :lim OFFSET :off",
+    rows = conn.execute(f"{B} SELECT b.*, {sort_sql(q)} AS sk FROM base b WHERE {w} ORDER BY {order_sql(q)} LIMIT :lim OFFSET :off",
                         {**base, **p, "lim": lim, "off": off}).fetchall()
     total = conn.execute(f"{B} SELECT COUNT(*) FROM base b WHERE {w}", {**base, **p}).fetchone()[0]
     out: dict[str, Any] = {"rows": [card(r, ctx.rolls) for r in rows], "total": total}
@@ -317,22 +375,46 @@ def sql_search(conn, q: Query, ctx: Ctx, *, facets: bool = True, limit: int | No
     return out
 
 
-def sql_extra(conn, ctx: Ctx, trending: int) -> dict[str, Any]:
-    """The page's header numbers, and the trending row (every environment, pinned first)."""
+def sql_extra(conn, ctx: Ctx, trending: int, q: Query | None = None) -> dict[str, Any]:
+    """Counts, task coverage and editorial picks all follow the current search."""
     base, B = ctx.params(), ctx.base()
-    ds, sp, tasks = conn.execute(f"{B} SELECT SUM(b.kind = 'dataset'), SUM(b.kind = 'space'), SUM(COALESCE(b.tasks, 0)) FROM base b",
-                                 base).fetchone()
-    out: dict[str, Any] = {"stats": {"datasets": ds or 0, "spaces": sp or 0, "tasks": tasks or 0}}
+    w, p = where(q or Query())
+    params = {**base, **p}
+    ds, sp = conn.execute(f"{B} SELECT SUM(b.kind = 'dataset'), SUM(b.kind = 'space') FROM base b WHERE {w}", params).fetchone()
+    # Count actual searchable records, including adapters (MiMo) with no Harbor
+    # summary. Health discovery must never imply that tasks were downloaded.
+    tasks = conn.execute(f"{B} SELECT COUNT(*) FROM tasks t JOIN base b ON b.key=t.env WHERE b.kind='dataset' AND {w}", params).fetchone()[0]
+    from . import space_tasks
+    visible = [r[0] for r in conn.execute(f"{B} SELECT b.id FROM base b WHERE b.kind='space' AND {w}", params)]
+    space_counts = space_tasks.census(ctx.checks, visible)
+    out: dict[str, Any] = {"stats": {"datasets": ds or 0, "spaces": sp or 0, "tasks": tasks,
+                                    "dataset_tasks": tasks, "space_tasks": space_counts["tasks"],
+                                    "space_task_coverage": space_counts}}
+    out["stats"]["openenv"] = dict(conn.execute(f"{B} SELECT b.evidence_f, COUNT(*) FROM base b WHERE b.evidence_f IS NOT NULL AND {w} GROUP BY 1", params))
+    out["stats"]["openenv_running"] = conn.execute(f"{B} SELECT COUNT(*) FROM base b WHERE b.evidence_f IS NOT NULL AND b.stage = 'RUNNING' AND {w}", params).fetchone()[0]
     if trending:
-        rows = conn.execute(f"{B} SELECT b.*, {TRENDING} AS sk FROM base b ORDER BY sk DESC, b.ord ASC LIMIT :n", {**base, "n": trending})
-        out["trending"] = [card(r, ctx.rolls) for r in rows]
+        tq = replace(q or Query(), sort="trending", page=1, size=trending)
+        out["trending"] = sql_search(conn, tq, ctx, facets=False)["rows"]
+        w, p = where(tq)
+        rows = conn.execute(f"{B} SELECT b.*, 0 AS sk FROM base b WHERE b.pinned AND {w} "
+                            "ORDER BY (SELECT CAST(key AS INTEGER) FROM json_each(:pins) WHERE value = b.key) LIMIT 12", {**base, **p})
+        out["featured"] = [card(r, ctx.rolls) for r in rows]
+        # FineEnvs is an explicit editorial section, independent of admin pins
+        # and interest rank. Owner/search filters still apply to it.
+        promoted = conn.execute(f"{B} SELECT b.*, {TRENDING} AS sk FROM base b WHERE {w} "
+                               "AND substr(b.id, 1, instr(b.id, '/') - 1) = 'FineEnvs' COLLATE NOCASE "
+                               "AND (b.kind = 'dataset' OR json_extract(b.check_json, '$.browseable') = 1) "
+                               "ORDER BY (b.kind = 'space') DESC, b.pinned DESC, " + order_sql(tq) + " LIMIT 4", {**base, **p})
+        out["promoted"] = [card(r, ctx.rolls) for r in promoted]
     return out
 
 
 # ── the same, in Python: the visitor's own datasets that aren't in the snapshot, and the tests' reference ────────
-def py_fw(d: dict[str, Any]) -> str:
+def py_fw(d: dict[str, Any], check=None) -> str:
     if d.get("kind") == "space":
-        return "openenv" if d.get("framework") == "openenv" or d.get("openenv") else "other-space"
+        if space_checks.verified(check):
+            return "openenv"
+        return "unverified-space" if d.get("framework") == "openenv" or d.get("openenv") else "other-space"
     return d.get("framework") or "harbor"
 
 
@@ -341,15 +423,19 @@ PY_FACETS = {
     "size": lambda d: [snapshot.size_bucket((d.get("indexed") or {}).get("tasks"))]
     if d.get("kind") == "dataset" and (d.get("framework") or "harbor") == "harbor" else [],
     "stage": lambda d: [snapshot.stage_value(d.get("stage"))] if d.get("kind") == "space" else [],
-    "mcp": lambda d: (["Has MCP tools" if d.get("mcp") else "No MCP tag"]) if d.get("kind") == "space" else [],
-    "oe": lambda d: [d["openenv_version"]] if d.get("kind") == "space" and d.get("openenv_version") else [],
+    "mcp": lambda d: (["MCP tagged" if d.get("mcp") else "No MCP tag"]) if d.get("kind") == "space" else [],
+    "health": lambda d: [d["api_status"]] if d.get("api_status") else [],
+    "mode": lambda d: [d["api_mode"]] if d.get("api_mode") else [],
+    "tools": lambda d: [d["tools_status"]] if d.get("tools_status") else [],
+    "oe": lambda d: [d["declared_version"]] if d.get("declared_version") else [],
+    "oe_source": lambda d: [d["version_source"]] if d.get("version_source") else [],
+    "evidence": lambda d: [d["evidence"]] if d.get("evidence") else [],
     "tags": lambda d: d.get("tags") or [],
 }
 
 
 def py_cards(rows: list[dict[str, Any]], ctx: Ctx, ord0: int = 0) -> list[dict[str, Any]]:
-    """Listing rows as the query sees them: collection, pins, the visitor's, rollouts, and FineEnvs' curated Spaces
-    as OpenEnv (catalog.environments' rule). Hidden ones left out."""
+    """Apply visibility and editorial metadata without changing framework evidence or rank."""
     hidden, pins, mine = set(ctx.hidden), set(ctx.pins), set(ctx.mine)
     out = []
     for i, r in enumerate(rows):
@@ -360,9 +446,26 @@ def py_cards(rows: list[dict[str, Any]], ctx: Ctx, ord0: int = 0) -> list[dict[s
         d = {**r, "key": key, "collection": coll, "pinned": key in pins, "mine": key in mine or bool(r.get("mine")),
              "rollouts": ctx.rolls.get(str(r["id"]), 0), "_ord": ord0 + i, "_blob": snapshot.blob_of(r),
              "badges": list(r.get("badges") or []), "tags": list(r.get("tags") or [])}
-        if d.get("kind") == "space" and coll == "fineenvs" and r.get("framework") != "openenv":
-            d.update(framework="openenv", openenv=True, badges=["OpenEnv"])
-        d["fw"] = py_fw(d)
+        check = ctx.checks.get(d["id"], {}) if d.get("kind") == "space" else {}
+        declared = d.get("kind") == "space" and (d.get("framework") == "openenv" or d.get("openenv"))
+        d["fw"] = py_fw(d, check)
+        d["evidence"] = ("Manifest present" if d.get("manifest") else "Hub tag only") if declared else None
+        d["stage_label"] = snapshot.stage_value(d.get("stage")) if d.get("kind") == "space" else None
+        health = space_checks.status(check)
+        candidate = declared or d["fw"] == "openenv"
+        ver = check.get("version") or {}
+        known_ver = ver.get("value") and ver["value"] != "Unknown"
+        d.update(api_check={**check, "status": health} if check else None, api_status=health if candidate else None,
+                 api_mode=check.get("mode") if health == space_checks.PASS else None,
+                 tools_status=("Tools discovered" if check.get("tools", 0) > 0 else "No tools discovered")
+                     if candidate and health in (space_checks.PASS, "Checks failed") else "Not checked" if candidate else None,
+                 declared_version=(ver["value"] if known_ver else d.get("openenv_version") or "Unknown") if candidate else None,
+                 version_source=(ver.get("source") if known_ver else "Hub tag" if d.get("openenv_version") else "Unknown") if candidate else None)
+        if d.get("kind") == "space":
+            d["openenv"] = d["fw"] == "openenv"
+            d["framework"] = "openenv" if d["openenv"] else "ors" if d.get("framework") == "ors" else "space"
+            if not d["openenv"]:
+                d["badges"] = [b for b in d["badges"] if b != "OpenEnv"]
         out.append(d)
     return out
 
@@ -372,22 +475,22 @@ def _time(iso: Any) -> int:
 
 
 def py_key(q: Query):
-    tk = lambda d: ((d.get("trending") or 0) * 1e9 + (d.get("likes") or 0) * 1e4) + min(d.get("downloads") or 0, 9999)
-    keys = {"trending": lambda d: (1e15 if d["pinned"] else 0) + tk(d), "downloads": lambda d: d.get("downloads") or 0,
+    keys = {"trending": lambda d: d.get("trending") or 0, "downloads": lambda d: d.get("downloads") or 0,
             "likes": lambda d: d.get("likes") or 0, "tasks": lambda d: ((d.get("indexed") or {}).get("tasks") if (d.get("indexed") or {}).get("tasks") is not None else -1),
             "rollouts": lambda d: d["rollouts"], "updated": lambda d: _time(d.get("updated")), "new": lambda d: _time(d.get("created"))}
-    k = keys[q.sort]
-    if q.sort == "trending" and q.kind == "openenv":
-        return lambda d: (1e14 if d.get("collection") == "fineenvs" else 0) + k(d)
-    return k
+    return keys[q.sort]
 
 
 def py_passes(d: dict[str, Any], q: Query, skip: str | None = None, ignore_coll: bool = False, ignore_kind: bool = False) -> bool:
     """The page's own `passes()`, line for line."""
+    if q.scope == "ready" and d.get("kind") == "space" and not space_checks.browseable(d.get("api_check")):
+        return False
     if not ignore_kind and q.kind != "all" and d["fw"] != q.kind:
         return False
     if not ignore_coll and q.coll and not (d["mine"] if q.coll == "mine" else (d.get("collection") or "other") == q.coll):
         return False
+    if q.owner and d["id"].split("/", 1)[0].lower() != q.owner.lower():
+        return False
     if q.words and not all(w in d["_blob"] for w in q.words):
         return False
     for k, vals in q.sel.items():
@@ -401,9 +504,10 @@ def py_passes(d: dict[str, Any], q: Query, skip: str | None = None, ignore_coll:
 def py_search(cards: list[dict[str, Any]], q: Query, *, with_mine: bool = False) -> dict[str, Any]:
     """`cards` (from py_cards) filtered, sorted and counted as the page did it: every match (sorted) and raw facets."""
     key = py_key(q)
-    matches = sorted((d for d in cards if py_passes(d, q)), key=lambda d: (-key(d), d["_ord"]))
+    matches = [d for d in cards if py_passes(d, q)]
     for d in matches:
         d["_sk"] = key(d)
+    matches.sort(key=lambda d: order_key(q, d))
     fc: dict[str, dict[Any, int]] = {"kind": {}, "collection": {}}
     for d in cards:
         if py_passes(d, q, ignore_kind=True):
@@ -428,7 +532,8 @@ def py_search(cards: list[dict[str, Any]], q: Query, *, with_mine: bool = False)
 def _public_card(d: dict[str, Any]) -> dict[str, Any]:
     keep = ("id", "key", "kind", "framework", "fw", "openenv", "collection", "heading", "brief", "downloads", "likes",
             "trending", "updated", "created", "stage", "mcp", "openenv_version", "manifest", "hardware", "badges", "tags",
-            "pinned", "mine", "indexed", "rollouts", "private")
+            "pinned", "mine", "indexed", "rollouts", "private", "evidence", "stage_label", "api_status", "api_check",
+            "declared_version", "version_source", "api_mode", "tools_status")
     out = {k: d.get(k) for k in keep}
     out["openenv"], out["mcp"], out["private"] = bool(out["openenv"]), bool(out["mcp"]), bool(out["private"])
     ix = d.get("indexed")
@@ -557,7 +662,7 @@ def search(request: Request):
                 res = sql_search(conn, q, ctx, facets=facets, limit=off + q.size, offset=0)
                 more = py_search(py_cards([{**r, "key": r.get("key") or r["id"], "kind": "dataset", "mine": True} for r in extras],
                                           ctx, ord0=10**9), q, with_mine=True)
-                merged = sorted(res["rows"] + more["matches"], key=lambda d: (-d["_sk"], d["_ord"]))
+                merged = sorted(res["rows"] + more["matches"], key=lambda d: order_key(q, d))
                 res["rows"], res["total"] = merged[off:off + q.size], res["total"] + more["total"]
                 if facets:
                     for k, counts in more["facets"].items():
@@ -565,15 +670,17 @@ def search(request: Request):
                             res["facets"][k][v] = res["facets"][k].get(v, 0) + n
             else:
                 res = sql_search(conn, q, ctx, facets=facets)
-            head = sql_extra(conn, ctx, trending) if trending or facets else {}
+            head = sql_extra(conn, ctx, trending, q) if trending or facets else {}
             if extras and head:
-                head["stats"]["datasets"] += len(extras)
-                head["stats"]["tasks"] += sum((r.get("indexed") or {}).get("tasks") or 0 for r in extras)
+                head["stats"]["datasets"] += more["total"]
+                private_tasks = sum((r.get("indexed") or {}).get("tasks") or 0 for r in more["matches"])
+                for metric in ("tasks", "dataset_tasks"):
+                    head["stats"][metric] += private_tasks
                 if trending:
-                    tq = Query(sort="trending")
+                    tq = replace(q, sort="trending")
                     more = py_search(py_cards([{**r, "key": r.get("key") or r["id"], "kind": "dataset", "mine": True} for r in extras],
                                               ctx, ord0=10**9), tq)["matches"]
-                    head["trending"] = sorted(head["trending"] + more, key=lambda d: (-d["_sk"], d["_ord"]))[:trending]
+                    head["trending"] = sorted(head["trending"] + more, key=lambda d: order_key(tq, d))[:trending]
             info = {"built_at": snap.built_at, "source": snap.source}
     except snapshot.SnapshotError as e:
         raise HTTPException(503, f"the catalog isn't ready: {e}")
@@ -593,6 +700,11 @@ def search(request: Request):
         out["stats"] = head["stats"]
     if trending:
         out["trending"] = [_public_card(d) for d in head.get("trending", [])]
+        out["featured"] = [_public_card(d) for d in head.get("featured", [])]
+        out["promoted"] = [_public_card(d) for d in head.get("promoted", [])]
+    out["ranking"] = RANKING
+    out["api_checks"] = {"fresh_seconds": space_checks.FRESH, "description": "Running on the Hub and OpenEnv API checks passed within the last hour. "
+                         "No episode or reward validation. Versions come from repository dependencies or Hub tags, not the installed runtime."}
     out["snapshot"] = info
     if key is not None:
         with _answers_lock:
@@ -636,19 +748,18 @@ def search_tasks(request: Request, q: str = "", env: str = "", page: int = 1, si
 
 
 @router.get("/api/search/rank")
-def search_rank(key: str, request: Request):
-    """Where one environment stands among its kind (Spaces, or datasets) by the page's trending order, pins aside:
+def search_rank(key: str, request: Request, scope: str = "all"):
+    """Where one environment stands among its kind (Spaces, or datasets) by the page's trending order:
     {n, of}. One query, so a page can say "#599 of 6,818 Spaces" without loading the whole listing."""
     ctx = context()
-    score = "(%s.trending * 1e9 + %s.likes * 1e4 + MIN(%s.downloads, 9999))"
-    sql = ctx.base() + f"""
-SELECT (SELECT COUNT(*) FROM base b WHERE b.kind = t.kind AND ({score % ('b', 'b', 'b')} > {score % ('t', 't', 't')}
-                                                               OR ({score % ('b', 'b', 'b')} = {score % ('t', 't', 't')} AND b.ord < t.ord))) + 1,
-       (SELECT COUNT(*) FROM base b WHERE b.kind = t.kind)
-FROM base t WHERE t.key = :key"""
+    w, params = where(Query(scope="ready" if scope == "ready" else "all"))
+    sql = ctx.base() + f""", ranked AS (
+SELECT key, ROW_NUMBER() OVER (PARTITION BY kind ORDER BY trending DESC, likes DESC, downloads DESC, ord) AS n,
+       COUNT(*) OVER (PARTITION BY kind) AS total FROM base b WHERE {w})
+SELECT n, total FROM ranked WHERE key = :key"""
     try:
         with snapshot.use() as (_snap, conn):
-            row = conn.execute(sql, {**ctx.params(), "key": key}).fetchone()
+            row = conn.execute(sql, {**ctx.params(), **params, "key": key}).fetchone()
     except snapshot.SnapshotError as e:
         raise HTTPException(503, f"the catalog isn't ready: {e}")
     if not row:

app/seo.py

@@ -133,6 +133,8 @@ def kind_of(row: dict[str, Any] | None, spec: str = "") -> str:
     if not row:
         return "RL environment"
     if row.get("kind") == "space":
+        if row.get("fw") == "unverified-space":
+            return "Unverified Space"
         return {"openenv": KIND["openenv"], "ors": "ORS Space"}.get(row.get("framework") or ("openenv" if row.get("openenv") else ""), KIND["space"])
     return KIND.get(row.get("framework") or "", "RL dataset")
 
@@ -283,7 +285,7 @@ def space(request: Request, spec: str) -> HTMLResponse:
            "sameAs": f"https://huggingface.co/spaces/{spec}", "applicationCategory": "DeveloperApplication", "operatingSystem": "Web",
            "offers": {"@type": "Offer", "price": "0", "priceCurrency": "USD"},
            "author": {"@type": "Organization", "name": spec.split("/")[0], "url": f"https://huggingface.co/{spec.split('/')[0]}"},
-           "keywords": ["reinforcement learning", "RL environment", "OpenEnv", *((r or {}).get("tags") or [])[:10]]}, cld]
+           "keywords": ["reinforcement learning", "RL environment", *(["OpenEnv"] if (r or {}).get("openenv") else []), *((r or {}).get("tags") or [])[:10]]}, cld]
     return page(request, title=f"{name} · {kind}", description=desc, path=path, body=body, jsonld=ld, image=f"/og{path}.png" if r else None, noindex=not r)
 
 
@@ -291,7 +293,7 @@ def simple(request: Request, path: str) -> HTMLResponse:
     """The app's other pages: community (indexed), a rollout, your rollouts, a comparison (not indexed: they change, or are personal)."""
     if path.startswith("/community"):
         return page(request, title="Community rollouts", path="/community",
-                    description="Public rollouts of RL environments on Hugging Face, by every model: a leaderboard by environment, the traces, and the tasks nobody has tried yet.",
+                    description="Public, graded RL rollouts across Harbor, MiMo, NeMo Gym and other supported runners. Explore traces and model results grouped by environment and scoring metric.",
                     body="<header class=\"tp-head\"><h1>Community rollouts</h1><p class=\"lede\">Public rollouts from everyone, shown without who ran them.</p></header>")
     titles = {"/runs": "My rollouts"}
     return page(request, title=titles.get(path, "Rollout" if path.startswith("/run/") else "Compare rollouts"), path=path,

app/snapshot.py

@@ -331,8 +331,21 @@ def size_bucket(n: int | None) -> str:
     return "Not indexed yet" if n is None else "Under 100" if n < 100 else "100 to 1,000" if n < 1000 else "1,000 or more"
 
 
+SPACE_STAGES = {
+    "RUNNING": "Running", "SLEEPING": "Sleeping", "PAUSED": "Paused", "STOPPED": "Paused",
+    "BUILDING": "Building", "APP_STARTING": "Starting", "RUNNING_APP_STARTING": "Starting",
+    "RUNNING_BUILDING": "Building", "BUILD_ERROR": "Error", "RUNTIME_ERROR": "Error",
+    "CONFIG_ERROR": "Error", "NO_APP_FILE": "Error", "DELETING": "Deleting",
+}
+
+
 def stage_value(stage: Any) -> str:
-    return "Running" if stage == "RUNNING" else "Asleep or stopped" if stage else "Unknown"
+    return SPACE_STAGES.get(stage, "Unknown")
+
+
+def stage_sql(column: str) -> str:
+    """Also classify old snapshots from their raw runtime, without trusting the old broad stage_f bucket."""
+    return "CASE " + column + " " + " ".join(f"WHEN '{k}' THEN '{v}'" for k, v in SPACE_STAGES.items()) + " ELSE 'Unknown' END"
 
 
 def blob_of(r: dict[str, Any]) -> str:

app/space_checks.py

@@ -0,0 +1,358 @@
+"""Recent, non-executing OpenEnv API evidence, separate from the immutable catalog.
+
+No wake, reset, step or tool invocation. Only public running Spaces are probed.
+Per-Space atomic files work on both local storage and the mounted bucket. Search
+reads a bounded cached inventory; it never waits for the network.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import threading
+import time
+import tomllib
+from concurrent.futures import ThreadPoolExecutor
+
+import httpx
+from packaging.requirements import InvalidRequirement, Requirement
+from packaging.version import InvalidVersion, Version
+
+from . import catalog, config
+
+FRESH = 3600
+REFRESH = 1800
+PASS = "API checked"
+UNKNOWN = "Not checked"
+_cache = (None, 0.0, {})
+_lock = threading.Lock()
+_stop = threading.Event()
+_worker = None
+log = logging.getLogger("rlx")
+
+
+def _path(spec):
+    return config.STORAGE_DIR / "openenv-checks" / f"{catalog._slug(catalog.check_spec(spec))}.json"
+
+
+def save(rec):
+    global _cache
+    path = _path(rec["id"])
+    with _lock:
+        try:
+            old = json.loads(path.read_bytes())
+            if old.get("checked_at", 0) > rec["checked_at"]:
+                return
+        except (OSError, ValueError):
+            pass
+        catalog.atomic_write(path, json.dumps(rec, separators=(",", ":")).encode())
+        _cache = (None, 0.0, {})
+
+
+def inventory():
+    """Public evidence only; invalid or oversized files are ignored, never trusted."""
+    global _cache
+    directory = config.STORAGE_DIR / "openenv-checks"
+    with _lock:
+        if _cache[0] == directory and time.time() - _cache[1] < 15:
+            return _cache[2]
+        records = {}
+        for path in sorted(directory.glob("*.json"))[:20000]:
+            try:
+                if path.stat().st_size > 32 * 1024:
+                    continue
+                r = json.loads(path.read_bytes())
+                spec = catalog.check_spec(r["id"])
+                if r.get("schema") == 1 and isinstance(r.get("checked_at"), (float, int)):
+                    records[spec] = r
+            except (OSError, ValueError, KeyError, TypeError):
+                continue
+        _cache = (directory, time.time(), records)
+        return records
+
+
+def status(rec, now=None):
+    if not rec:
+        return UNKNOWN
+    age = (time.time() if now is None else now) - rec.get("checked_at", 0)
+    if age < 0 or age >= FRESH:
+        return "Check expired"
+    return rec.get("status") if rec.get("status") in (PASS, "Checks failed", "Not running", "Check unavailable") else UNKNOWN
+
+
+def verified(rec):
+    """Only a fresh successful check of a running server establishes API support."""
+    return bool(rec and rec.get("stage") == "RUNNING" and status(rec) == PASS)
+
+
+def browseable(rec):
+    """A live, recognized environment API; this does not certify reward quality."""
+    return verified(rec) or bool(rec and rec.get("stage") == "RUNNING"
+                                and status(rec) == "Checks failed"
+                                and rec.get("interface") in ("nemo-gym", "ors"))
+
+
+def environment_interface(api):
+    """Other supported server contracts, kept distinct from OpenEnv evidence."""
+    if not isinstance(api, dict) or not isinstance(api.get("info"), dict) or not api["info"].get("version"):
+        return None
+    paths = api.get("paths")
+    if not isinstance(paths, dict):
+        return None
+    for name, routes in (("nemo-gym", ("/seed_session", "/verify")), ("ors", ("/create_session", "/{env_name}/call"))):
+        if all(isinstance(paths.get(p), dict) and isinstance(paths[p].get("post"), dict) for p in routes):
+            return name
+    return None
+
+
+def tag_version(tags):
+    for tag in tags or []:
+        match = re.fullmatch(r"openenv-(\d[^\s]{0,70})", str(tag), re.I)
+        if match:
+            try:
+                return {"value": str(Version(match[1])), "source": "Hub tag"}
+            except InvalidVersion:
+                pass
+    return {"value": "Unknown", "source": "Unknown"}
+
+
+def requirement_version(text):
+    try:
+        req = Requirement(text)
+    except InvalidRequirement:
+        return None
+    if req.name.lower().replace("_", "-") not in ("openenv", "openenv-core"):
+        return None  # current OpenEnv and the earlier openenv-core distribution
+    if req.marker:
+        return {"value": "Conditional", "source": "Dependency constraint", "requirement": str(req)[:240]}
+    if req.url:
+        ref = re.search(r"@([^/#?\s]+)(?:#.*)?$", req.url)
+        return {"value": "git:" + ref[1][:64] if ref else "Unpinned source", "source": "Source reference"}
+    specs = list(req.specifier)
+    if len(specs) == 1 and specs[0].operator in ("==", "===") and "*" not in specs[0].version:
+        try:
+            return {"value": str(Version(specs[0].version)), "source": "Dependency pin"}
+        except InvalidVersion:
+            pass
+    return {"value": str(req.specifier) or "Unpinned", "source": "Dependency constraint"}
+
+
+def parse_version(text, path):
+    """Repository evidence, never an assertion about the installed runtime."""
+    if path.endswith(".toml") or path.endswith("uv.lock"):
+        try:
+            doc = tomllib.loads(text)
+        except (ValueError, RecursionError):
+            return None
+        if path.endswith("uv.lock"):
+            pins = []
+            for pkg in doc.get("package", []):
+                if not isinstance(pkg, dict) or pkg.get("name", "").replace("_", "-") not in ("openenv", "openenv-core"):
+                    continue
+                source = pkg.get("source") or {}
+                if source.get("git"):
+                    ref = source["git"].rsplit("#", 1)
+                    pins.append({"value": "git:" + ref[-1][:64] if len(ref) == 2 else "Unpinned source", "source": "Lockfile"})
+                elif pkg.get("version"):
+                    pins.append(requirement_version(f"openenv-core=={pkg['version']}"))
+            pins = [p for p in pins if p]
+            if len({p["value"] for p in pins}) == 1:
+                return {**pins[0], "source": "Lockfile"}
+            return {"value": "Multiple locked versions", "source": "Lockfile"} if pins else None
+        sources = doc.get("tool", {}).get("uv", {}).get("sources", {})
+        source = sources.get("openenv") or sources.get("openenv-core") or sources.get("openenv_core")
+        if isinstance(source, dict) and source.get("git"):
+            ref = source.get("rev") or source.get("tag") or source.get("branch")
+            return {"value": "git:" + str(ref)[:64] if ref else "Unpinned source", "source": "Source reference"}
+        if source:
+            return {"value": "Custom source", "source": "Source reference"}
+        deps = doc.get("project", {}).get("dependencies", [])
+    else:
+        deps = [line.split(" #", 1)[0].strip() for line in text.splitlines()]
+    for dep in deps:
+        if isinstance(dep, str) and (v := requirement_version(dep)):
+            return v
+    return None
+
+
+def declared_version(spec, tags):
+    from . import space_files as files
+    fallback = tag_version(tags)
+    try:
+        info = files._info(spec)
+        listing, _, _ = files.listing(info)
+        paths = [f["path"] for f in listing]
+        manifest = files.manifest_path(paths, "Dockerfile" if "Dockerfile" in paths else None, spec)
+        root = manifest.rsplit("/", 1)[0] if manifest and "/" in manifest else ""
+        keys = files.key_files(paths, root, manifest)
+        sizes = {f["path"]: f.get("size", 0) for f in listing}
+        reqs = [f"{root}/requirements.txt" if root else "requirements.txt", "requirements.txt"]
+        for path in dict.fromkeys([keys.get("lock"), keys.get("pyproject"), *reqs]):
+            if not path or path not in sizes or sizes[path] > 400 * 1024:
+                continue
+            text = files._fetch_text(spec, info["sha"], path, sizes[path])
+            if text and (v := parse_version(text, path)):
+                return {**v, "path": path, "revision": info["sha"]}
+    except Exception:  # incomplete version evidence must not change API health
+        pass
+    return fallback
+
+
+def assess(api, health, metadata, schema, tools):
+    api = api if isinstance(api, dict) else {}
+    paths = api.get("paths") if isinstance(api.get("paths"), dict) else {}
+    def method(path, verb):
+        return isinstance(paths.get(path), dict) and isinstance(paths[path].get(verb), dict)
+    checks = {
+        "OpenAPI": isinstance(api.get("info"), dict) and isinstance(api["info"].get("version"), str),
+        "Health": isinstance(health, dict) and health.get("status") == "healthy",
+        "Metadata": isinstance(metadata, dict) and all(isinstance(metadata.get(k), str) for k in ("name", "description")),
+        "Schemas": isinstance(schema, dict) and all(isinstance(schema.get(k), dict) for k in ("action", "observation", "state")),
+    }
+    simulation = any(p in paths for p in ("/reset", "/step", "/state"))
+    mode = "Simulation" if simulation else "MCP service"
+    checks["Control routes" if simulation else "MCP tools"] = (
+        all(method(p, v) for p, v in (("/reset", "post"), ("/step", "post"), ("/state", "get")))
+        if simulation else method("/mcp", "post") and bool(tools))
+    return {"status": PASS if all(checks.values()) else "Checks failed", "mode": mode if all(checks.values()) else None,
+            "failed": [k for k, ok in checks.items() if not ok], "tools": len(tools or [])}
+
+
+def check(spec):
+    from . import spaces_live as live
+    rec = {"schema": 1, "id": catalog.check_spec(spec), "checked_at": time.time(), "status": "Check unavailable"}
+    previous = inventory().get(spec, {})
+    rec["version"] = previous.get("version") or {"value": "Unknown", "source": "Unknown"}
+    try:
+        hub = live.record(spec, fresh=True)
+        rec["stage"] = hub["stage"]
+        if hub["stage"] != "RUNNING":
+            rec["status"] = "Not running"
+        elif hub.get("host"):
+            urls = ("/openapi.json", "/health", "/metadata", "/schema")
+            def get(path):
+                try:
+                    with live.SpaceClient(timeout=httpx.Timeout(6, connect=4), follow_redirects=False) as client:
+                        response = client.get(live._url(hub, path))
+                        return response.json() if response.status_code == 200 and "json" in response.headers.get("content-type", "") else None
+                except (httpx.HTTPError, ValueError, live.SpaceError):
+                    return None
+            with ThreadPoolExecutor(4) as pool:
+                api, health, meta, schema = list(pool.map(get, urls))
+            # MCP discovery is separate from typed-action OpenEnv compatibility.
+            paths = api.get("paths", {}) if isinstance(api, dict) else {}
+            typed = isinstance(schema, dict) and all(isinstance(schema.get(k), dict) for k in ("action", "observation", "state"))
+            tools, _, _ = live._tools({**hub, "mcp_standard": not typed}) if isinstance(paths, dict) and "/mcp" in paths else (None, None, None)
+            rec.update(assess(api, health, meta, schema, tools))
+            rec["interface"] = environment_interface(api)
+            from . import space_tasks
+            task_api = space_tasks.discover(hub, paths)
+            rec["task_catalog"] = space_tasks.summary(task_api)
+            if rec["status"] == PASS:
+                rec["version"] = declared_version(spec, hub.get("tags"))
+            elif rec["version"]["value"] == "Unknown":
+                rec["version"] = tag_version(hub.get("tags"))
+    except Exception as exc:
+        rec["error"] = type(exc).__name__  # no upstream response/secret in public inventory
+    save(rec)
+    return rec
+
+
+def observe(spec, info):
+    """Opening/rechecking a Space also updates discovery, including negative results."""
+    try:
+        old = inventory().get(spec, {})
+        rec = {"schema": 1, "id": spec, "checked_at": info.get("checked") or time.time(), "stage": info.get("stage"),
+               "version": old.get("version") or {"value": "Unknown", "source": "Unknown"}}
+        if not info.get("running"):
+            rec["status"] = "Not running"
+        else:
+            rec.update(assess({"info": {"version": info.get("openapi_version")}, "paths": info.get("endpoint_methods")},
+                              info.get("health"), info.get("metadata"), info.get("schema"), info.get("mcp")))
+            rec["interface"] = environment_interface({"info": {"version": info.get("openapi_version")}, "paths": info.get("endpoint_methods")})
+            from . import space_tasks
+            rec["task_catalog"] = space_tasks.summary(info.get("task_api"))
+        info["openenv_verified"] = verified(rec)
+        save(rec)
+    except Exception:
+        log.warning("Could not save OpenEnv check for %s", spec)
+
+
+def scan():
+    # App workers and an operator's CLI refresh share one bounded probe queue.
+    # Use local cache storage for this lock, never a mounted object-store bucket.
+    try:
+        import fcntl
+    except ImportError:  # Windows development: the app still has one worker thread
+        return _scan()
+    config.CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    with (config.CACHE_DIR / "openenv-checks.lock").open("a") as lease:
+        try:
+            fcntl.flock(lease, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            return []
+        return _scan()
+
+
+def _scan():
+    from . import snapshot
+    old = inventory()
+    with snapshot.use() as (_, conn):
+        candidates = list(conn.execute("SELECT id, stage FROM envs WHERE kind = 'space' ORDER BY trending DESC, likes DESC"))
+    due = pending(candidates, old)
+    def visit(spec):
+        if not _stop.is_set():
+            return check(spec)
+    with ThreadPoolExecutor(4) as pool:
+        return [r for r in pool.map(visit, due) if r]
+
+
+def pending(candidates, old, now=None):
+    """Bound the queue and reserve capacity for inactive candidates too.
+
+    Never probing sleeping hosts, but refreshing their Hub metadata lets a
+    newly started Space enter the catalog without someone opening its page.
+    """
+    now = time.time() if now is None else now
+    active, inactive = [], []
+    for spec, stage in candidates:
+        rec = old.get(spec, {})
+        running = rec.get("stage", stage) == "RUNNING"
+        at = rec.get("checked_at", 0)
+        interval = REFRESH if running else 6 * 3600
+        if not rec or now - at >= interval or (running and status(rec, now) == PASS and "task_catalog" not in rec):
+            (active if running else inactive).append((spec, at))
+    # Once checked, older entries take precedence so a failing popular Space
+    # cannot starve the long tail. FineEnvs goes first within each generation.
+    key = lambda item: (int(item[1] // REFRESH), item[0].split("/", 1)[0].lower() != "fineenvs", item[1])
+    active.sort(key=key)
+    inactive.sort(key=key)
+    return [s for s, _ in active[:96] + inactive[:32]]
+
+
+def start():
+    global _worker
+    if os.environ.get("RLX_TEST_TMP") or os.environ.get("RLX_SPACE_CHECKS", "1") != "1" or (_worker and _worker.is_alive()):
+        return
+    _stop.clear()
+    def watch():
+        while not _stop.is_set():
+            try:
+                scan()
+            except Exception:
+                log.exception("OpenEnv API inventory refresh failed")
+            _stop.wait(60)
+    _worker = threading.Thread(target=watch, daemon=True, name="openenv-checks")
+    _worker.start()
+
+
+def stop():
+    _stop.set()
+
+
+if __name__ == "__main__":
+    from collections import Counter
+    from . import runtime
+    runtime.hub_timeouts()
+    print(dict(Counter(r["status"] for r in scan())), flush=True)

app/space_tasks.py

@@ -0,0 +1,94 @@
+"""Bounded discovery of the public OpenEnv Task API, without starting episodes.
+
+These are server-reported catalog sizes, not downloaded task records or proof that
+an episode works. Keep their own timestamp so a health check cannot freshen them.
+"""
+from __future__ import annotations
+
+import re
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+MAX_COUNT = 1_000_000_000
+FRESH = 3600
+
+
+def count(value):
+    return value if type(value) is int and 0 <= value <= MAX_COUNT else None
+
+
+def discover(rec, paths, envs=None):
+    from . import spaces_live as live
+
+    if "/{env_name}/splits" not in paths:
+        return None
+    if envs is None:
+        envs = live._get_json(rec, "/list_environments")
+    if not isinstance(envs, list):
+        return None
+    names = list(dict.fromkeys(e for e in envs if isinstance(e, str) and re.fullmatch(r"[\w.-]{1,80}", e) and e not in (".", "..")))
+
+    def read(name):
+        raw = live._get_json(rec, f"/{name}/splits")
+        splits, seen = [], set()
+        for s in raw[:40] if isinstance(raw, list) else []:
+            if not isinstance(s, dict) or not isinstance(s.get("name"), str) or len(s["name"]) > 200 or s["name"] in seen:
+                continue
+            seen.add(s["name"])
+            n = count(s.get("num_tasks"))
+            if n is None and "/{env_name}/num_tasks" in paths and len(splits) < 12:
+                try:
+                    r = live._client.post(live._url(rec, f"/{name}/num_tasks"), json={"split": s["name"]}, timeout=6)
+                    doc = live._json(r) if r.status_code == 200 else None
+                    n = count(doc.get("num_tasks")) if isinstance(doc, dict) else None
+                except Exception:
+                    pass
+            splits.append({"name": s["name"], "type": s.get("type"), "num_tasks": n, "default": s.get("default") is True})
+        return {"env": name, "splits": splits, "complete": isinstance(raw, list) and len(raw) <= 40 and len(seen) == len(raw)}
+
+    with ThreadPoolExecutor(4) as pool:
+        environments = list(pool.map(read, names[:16]))
+    if not environments:
+        return None
+    return {"env": environments[0]["env"], "splits": environments[0]["splits"], "environments": environments,
+            "complete": len(names) <= 16 and all(e["complete"] for e in environments), "checked_at": time.time()}
+
+
+def summary(task_api):
+    if not isinstance(task_api, dict):
+        return None
+    envs = task_api.get("environments") or [task_api]
+    entries, unknown, seen = [], 0, set()
+    for env in envs[:16]:
+        for split in env.get("splits", [])[:40]:
+            key = (env.get("env"), split.get("name"))
+            if key in seen:
+                continue
+            seen.add(key)
+            n = count(split.get("num_tasks"))
+            if n is None:
+                unknown += 1
+            else:
+                entries.append(n)
+    return {"tasks": sum(entries), "counted_splits": len(entries), "unknown_splits": unknown,
+            "complete": bool(task_api.get("complete", True)) and not unknown,
+            "checked_at": task_api.get("checked_at") or time.time()}
+
+
+def census(records, visible, now=None):
+    now = time.time() if now is None else now
+    out = {"tasks": 0, "spaces": 0, "partial_spaces": 0, "oldest_check": None}
+    for spec in visible:
+        rec = records.get(spec, {})
+        s = rec.get("task_catalog") or {}
+        at = s.get("checked_at", 0)
+        if rec.get("stage") != "RUNNING" or not isinstance(at, (int, float)) or not 0 <= now - at < FRESH or not s.get("counted_splits"):
+            continue
+        n = s.get("tasks")
+        if type(n) is not int or not 0 <= n <= MAX_COUNT * 640:
+            continue
+        out["tasks"] += n
+        out["spaces"] += 1
+        out["partial_spaces"] += not s.get("complete")
+        out["oldest_check"] = min(out["oldest_check"] or at, at)
+    return out

app/spaces_live.py

@@ -20,6 +20,8 @@ import re
 import secrets
 import threading
 import time
+import zlib
+from urllib.parse import urlencode
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any
 
@@ -38,9 +40,6 @@ STANDARD_ROUTES = {"/reset", "/step", "/state", "/metadata", "/health", "/health
                    "/{env_name}/splits", "/{env_name}/tasks", "/{env_name}/num_tasks", "/{env_name}/task", "/{env_name}/task_range",
                    "/web/metadata", "/web/reset", "/web/step", "/web/state", "/docs", "/redoc", "/openapi.json"}
 MAX_REPLY = 12 * 2**20          # bytes from a Space for one reply (observations can carry images)
-_client = httpx.Client(timeout=httpx.Timeout(12, connect=6), follow_redirects=False,
-                       headers={"User-Agent": "hf-rl-explorer (+https://huggingface.co/FineEnvs)"},
-                       limits=httpx.Limits(max_connections=64, max_keepalive_connections=16))
 _lock = threading.Lock()
 
 
@@ -52,6 +51,48 @@ class SpaceError(Exception):
         self.status = status
 
 
+class SpaceClient(httpx.Client):
+    """Bound decompressed replies while receiving them, including chunked bodies.
+
+    Space operators control their responses. Checking Response.content after a
+    normal get() is too late: httpx has already buffered the complete response.
+    Keep httpx's cookie jar and connection pooling, but never buffer without a cap.
+    """
+
+    def send(self, request, *, stream=False, **kwargs):
+        # Negotiate only a codec with a bounded decompression API.
+        request.headers["Accept-Encoding"] = "gzip, identity"
+        response = super().send(request, stream=True, **kwargs)
+        try:
+            body = bytearray()
+            codec = response.headers.get("content-encoding", "identity").lower()
+            decoded = response.is_stream_consumed
+            if not decoded and codec not in {"identity", "gzip"}:
+                raise SpaceError("the Space used an unsupported response encoding", 502)
+            decoder = zlib.decompressobj(16 + zlib.MAX_WBITS) if not decoded and codec == "gzip" else None
+            chunks = (response.content,) if decoded else response.iter_raw(chunk_size=64 * 1024)
+            for chunk in chunks:
+                if decoder:
+                    chunk = decoder.decompress(chunk, MAX_REPLY - len(body) + 1)
+                if len(body) + len(chunk) > MAX_REPLY:
+                    raise SpaceError("the Space's reply is too large to show", 502)
+                body.extend(chunk)
+            if decoder and (not decoder.eof or decoder.unused_data):
+                raise SpaceError("the Space returned an invalid compressed response", 502)
+            headers = [(k, v) for k, v in response.headers.multi_items()
+                       if k.lower() not in ("content-encoding", "content-length", "transfer-encoding")]
+            return httpx.Response(response.status_code, headers=headers, content=bytes(body), request=request)
+        except zlib.error:
+            raise SpaceError("the Space returned an invalid compressed response", 502) from None
+        finally:
+            response.close()
+
+
+_client = SpaceClient(timeout=httpx.Timeout(12, connect=6), follow_redirects=False,
+                      headers={"User-Agent": "hf-rl-explorer (+https://huggingface.co/FineEnvs)"},
+                      limits=httpx.Limits(max_connections=64, max_keepalive_connections=16))
+
+
 # ── the Space's record ───────────────────────────────────────────────────────
 def record(spec: str, fresh: bool = False) -> dict[str, Any]:
     """Host, stage and declared UI path of a public Space (cached a few seconds: the page polls it while it wakes)."""
@@ -99,7 +140,7 @@ def _get_here(rec: dict, path: str, hops: int = 3) -> httpx.Response | None:
         if r.status_code not in (301, 302, 303, 307, 308):
             return r
         nxt = r.url.join(r.headers.get("location", ""))
-        if nxt.scheme != "https" or nxt.host != httpx.URL(rec["host"]).host:
+        if nxt.scheme != "https" or nxt.host != httpx.URL(rec["host"]).host or nxt.port not in (None, 443) or nxt.userinfo:
             return None
         url = str(nxt)
     return None
@@ -133,6 +174,13 @@ def _get_json(rec: dict, path: str) -> Any:
 def mcp_call(rec: dict, method: str, params: dict | None = None, timeout: float = 30, raw: bool = False) -> Any:
     """One JSON-RPC call to the Space's /mcp. Returns `result`; raises SpaceError with the server's message on error.
     `raw`: the whole JSON-RPC reply, an error reply included (HTTP failures still raise)."""
+    if rec.get("mcp_standard"):
+        with SpaceClient(timeout=httpx.Timeout(timeout, connect=6), follow_redirects=False) as client:
+            remote = RemoteMCP(rec, client)
+            try:
+                return remote.call(method, params or {}, timeout, raw=raw)
+            finally:
+                remote.close()
     try:
         r = _client.post(_url(rec, "/mcp"), timeout=httpx.Timeout(timeout, connect=6),
                          headers={"Accept": "application/json, text/event-stream", "Content-Type": "application/json"},
@@ -157,6 +205,100 @@ def mcp_call(rec: dict, method: str, params: dict | None = None, timeout: float
     return doc.get("result")
 
 
+class RemoteMCP:
+    """A Streamable HTTP MCP session, isolated along with the visitor's cookies.
+
+    No credentials from the explorer are forwarded. Expiry never replays an action:
+    callers must explicitly open a new episode after a 410 response.
+    """
+    def __init__(self, rec: dict, client: httpx.Client):
+        self.url = _url(rec, "/mcp")
+        self.client = client
+        self.session = None
+        self.version = None
+        self.initialized = False
+        self.expired = False
+
+    def headers(self):
+        headers = {"Accept": "application/json, text/event-stream", "Content-Type": "application/json"}
+        if self.session:
+            headers["Mcp-Session-Id"] = self.session
+        if self.version:
+            headers["MCP-Protocol-Version"] = self.version
+        return headers
+
+    def request(self, method, params, timeout, *, notification=False):
+        rid = secrets.randbelow(10**9)
+        message = {"jsonrpc": "2.0", "method": method, "params": params}
+        if not notification:
+            message["id"] = rid
+        try:
+            r = self.client.post(self.url, headers=self.headers(), json=message, timeout=httpx.Timeout(timeout, connect=6))
+        except httpx.TimeoutException:
+            raise SpaceError("the MCP server timed out; the action was not retried", 504) from None
+        except httpx.HTTPError as e:
+            raise SpaceError(f"couldn't reach the MCP server: {type(e).__name__}", 502) from None
+        if self.session and r.status_code == 404:
+            self.expired = True
+            raise SpaceError("the MCP session has expired: start a new session", 410)
+        if notification and r.status_code in (200, 202, 204):
+            return {}
+        if r.status_code != 200:
+            raise SpaceError(f"the Space's /mcp answered HTTP {r.status_code}", 502)
+        try:
+            if "text/event-stream" in r.headers.get("content-type", ""):
+                # Notifications can precede the response; SSE data may span lines.
+                docs = [json.loads("\n".join(line[5:].lstrip() for line in event.splitlines() if line.startswith("data:")))
+                        for event in r.text.replace("\r\n", "\n").split("\n\n") if any(line.startswith("data:") for line in event.splitlines())]
+                doc = next((d for d in docs if isinstance(d, dict) and d.get("id") == rid), None)
+            else:
+                doc = r.json()
+        except ValueError:
+            raise SpaceError("the MCP server returned invalid JSON", 502) from None
+        if not isinstance(doc, dict) or doc.get("jsonrpc") != "2.0" or doc.get("id") != rid:
+            raise SpaceError("the MCP server returned no matching JSON-RPC response", 502)
+        if method == "initialize" and not doc.get("error"):
+            sid = r.headers.get("mcp-session-id")
+            if sid and (len(sid) > 2048 or not all(0x21 <= ord(c) <= 0x7e for c in sid)):
+                raise SpaceError("the MCP server returned an invalid session ID", 502)
+            self.session = sid
+        return doc
+
+    def call(self, method, params, timeout, *, raw=False):
+        if self.expired:
+            raise SpaceError("the MCP session has expired: start a new session", 410)
+        if not self.initialized:
+            init = self.request("initialize", {"protocolVersion": "2025-06-18", "capabilities": {},
+                                               "clientInfo": {"name": "hf-rl-explorer", "version": "0.1.0"}}, timeout)
+            error = init.get("error") or {}
+            if not isinstance(error, dict):
+                raise SpaceError("the MCP server returned an invalid initialization error", 502)
+            if error.get("code") != -32601:  # compatibility with simple JSON-RPC tool servers
+                result = init.get("result") or {}
+                if not isinstance(result, dict):
+                    raise SpaceError("the MCP server returned an invalid initialization result", 502)
+                self.version = result.get("protocolVersion")
+                if error or self.version not in {"2025-03-26", "2025-06-18", "2025-11-25"}:
+                    raise SpaceError("the MCP server could not negotiate a supported protocol", 502)
+                self.request("notifications/initialized", {}, timeout, notification=True)
+            self.initialized = True
+        doc = self.request(method, params, timeout)
+        if raw:
+            return doc
+        if doc.get("error"):
+            error = doc["error"]
+            raise SpaceError(str(error.get("message", "MCP error") if isinstance(error, dict) else error)[:500], 422)
+        return doc.get("result")
+
+    def close(self):
+        if self.session and not self.expired:
+            try:
+                self.client.delete(self.url, headers=self.headers(), timeout=3)
+            except Exception:  # best-effort cleanup of an untrusted remote server
+                pass
+        self.expired = True
+
+
 def _tools(rec: dict) -> tuple[list[dict] | None, str | None, dict]:
     """Its MCP tools (or why there are none), and how /mcp answered: a JSON-RPC 2.0 reply, as `openenv validate`
     asks of it, or the failure."""
@@ -182,8 +324,6 @@ def _api_routes(api: Any, openenv: bool) -> list[dict[str, Any]]:
     own plumbing (geoguesser's /geoguesser/task/{i} returns the answer's coordinates). GET and POST only."""
     if openenv or not isinstance(api, dict) or not isinstance(api.get("paths"), dict):
         return []
-    comps = ((api.get("components") or {}).get("schemas") or {}) if isinstance(api.get("components"), dict) else {}
-
     def resolve(x: Any, depth: int = 0) -> Any:
         if not isinstance(x, (dict, list)):
             return x
@@ -191,7 +331,12 @@ def _api_routes(api: Any, openenv: bool) -> list[dict[str, Any]]:
             return {} if isinstance(x, dict) else []
         if isinstance(x, dict):
             if "$ref" in x and isinstance(x["$ref"], str):
-                return resolve(comps.get(x["$ref"].split("/")[-1], {}), depth + 1)
+                target = api
+                if not x["$ref"].startswith("#/"):
+                    return {}
+                for key in x["$ref"][2:].split("/"):
+                    target = target.get(key.replace("~1", "/").replace("~0", "~"), {}) if isinstance(target, dict) else {}
+                return resolve(target, depth + 1)
             return {k: resolve(v, depth + 1) for k, v in x.items() if k != "$defs"}
         if isinstance(x, list):
             return [resolve(v, depth + 1) for v in x[:50]]
@@ -203,7 +348,9 @@ def _api_routes(api: Any, openenv: bool) -> list[dict[str, Any]]:
         if (not isinstance(ops, dict) or not isinstance(path, str) or not re.match(r"^/(?!/)[\w\-.~{}/]{0,199}$", path)
                 or ".." in path):
             continue
-        if path in STANDARD_ROUTES or path.startswith(("/web", "/login", "/logout", "/docs", "/redoc", "/static", "/gradio", "/assets")):
+        # A generic Gymnasium server's reset/step are ordinary HTTP routes, not
+        # evidence that it implements OpenEnv's WebSocket envelope protocol.
+        if path in STANDARD_ROUTES - {"/reset", "/step", "/state"} or path.startswith(("/web", "/login", "/logout", "/docs", "/redoc", "/static", "/gradio", "/assets")):
             continue
         if openenv and path in ("/healthz",):
             continue
@@ -213,15 +360,24 @@ def _api_routes(api: Any, openenv: bool) -> list[dict[str, Any]]:
                 continue
             body = (((op.get("requestBody") or {}).get("content") or {}).get("application/json") or {}).get("schema")
             schema = resolve(body) if body else None
+            parameters = {}
+            for p in [*(ops.get("parameters") or []), *(op.get("parameters") or [])]:
+                p = resolve(p)
+                if isinstance(p, dict) and p.get("in") == "query" and isinstance(p.get("name"), str):
+                    parameters[p["name"]] = p
+            query = {"type": "object", "properties": {k: {**(p.get("schema") or {}), "description": p.get("description") or "Query parameter"}
+                                                       for k, p in parameters.items()},
+                     "required": [k for k, p in parameters.items() if p.get("required")], "additionalProperties": False}
             out.append({"method": method.upper(), "path": path, "summary": str(op.get("summary") or op.get("description") or "")[:200],
                         "params": re.findall(r"\{([A-Za-z_][\w-]{0,40})\}", path),
-                        "schema": schema if isinstance(schema, dict) and schema.get("type") == "object" else None})
+                        "schema": schema if isinstance(schema, dict) else None,
+                        "body_required": bool((op.get("requestBody") or {}).get("required")), "query_schema": query})
         if len(out) >= 40:
             break
     return out
 
 
-def route_url(info: dict, method: str, path: str, params: dict[str, Any]) -> str:
+def route_url(info: dict, method: str, path: str, params: dict[str, Any], query: dict[str, Any] | None = None) -> str:
     """A route the server published, its path parameters filled in safely; anything else is refused."""
     route = next((r for r in info.get("api") or [] if r["method"] == method and r["path"] == path), None)
     if route is None:
@@ -229,9 +385,29 @@ def route_url(info: dict, method: str, path: str, params: dict[str, Any]) -> str
     filled = path
     for name in route["params"]:
         v = str((params or {}).get(name, ""))
-        if not re.match(r"^[\w.\-~]{1,200}$", v):
+        if not re.fullmatch(r"[\w.\-~]{1,200}", v) or v in (".", ".."):
             raise SpaceError(f"{name}: letters, digits, . - _ ~ only", 400)
         filled = filled.replace("{" + name + "}", v)
+    query = query or {}
+    schema = route.get("query_schema") or {}
+    if set(query) - set(schema.get("properties") or {}):
+        raise SpaceError("only this route's published query parameters are allowed", 400)
+    for key in schema.get("required") or []:
+        if key not in query:
+            raise SpaceError(f"query parameter {key} is required", 400)
+    pairs = []
+    for key, value in query.items():
+        for v in value if isinstance(value, list) else [value]:
+            if v is None:
+                continue
+            if not isinstance(v, (str, int, float, bool)):
+                raise SpaceError(f"query parameter {key} must be a scalar or array of scalars", 400)
+            pairs.append((key, str(v).lower() if isinstance(v, bool) else str(v)))
+    encoded = urlencode(pairs)
+    if len(encoded) > 8000:
+        raise SpaceError("query parameters are too large", 400)
+    if encoded:
+        filled += "?" + encoded
     return filled
 
 
@@ -239,8 +415,12 @@ def probe(spec: str, fresh: bool = False) -> dict[str, Any]:
     """Everything a running server says about itself, in one record. Asleep or broken: just the stage."""
     rec = record(spec, fresh=fresh)
     if rec["stage"] != UP or not rec["host"]:
-        return {"running": False, "stage": rec["stage"], "host": rec["host"], "base_path": rec["base_path"],
+        from .envs.capabilities import space_support
+        info = {"running": False, "stage": rec["stage"], "host": rec["host"], "base_path": rec["base_path"],
                 "last_seen": last_seen(rec["id"])}
+        from . import space_checks
+        space_checks.observe(spec, info)
+        return {**info, "support": space_support(info)}
 
     def fetch():
         with ThreadPoolExecutor(6) as pool:
@@ -253,23 +433,11 @@ def probe(spec: str, fresh: bool = False) -> dict[str, Any]:
             api, meta, schema, health, envs, ui = (f.result() for f in (f_api, f_meta, f_schema, f_health, f_envs, f_ui))
         routes = sorted((api or {}).get("paths", {}).keys()) if isinstance(api, dict) else []
         has = set(routes)
-        openenv = isinstance(schema, dict) and ("action" in schema or "observation" in schema)
-        tools, tools_error, rpc = _tools(rec) if ("/mcp" in has or openenv) else (None, None, None)
+        openenv = isinstance(schema, dict) and all(isinstance(schema.get(k), dict) for k in ("action", "observation", "state"))
+        tools, tools_error, rpc = _tools({**rec, "mcp_standard": not openenv}) if ("/mcp" in has or openenv) else (None, None, None)
         env_names = [e for e in envs if isinstance(e, str) and re.match(r"^[\w.-]{1,80}$", e)] if isinstance(envs, list) else []
-        task_api = bool(env_names) and "/{env_name}/splits" in has
-        splits = []
-        if task_api:
-            raw = _get_json(rec, f"/{env_names[0]}/splits")
-            for s in (raw or [])[:40] if isinstance(raw, list) else []:
-                if isinstance(s, dict) and isinstance(s.get("name"), str):
-                    splits.append({"name": s["name"], "type": s.get("type"), "num_tasks": s.get("num_tasks"), "default": s.get("default")})
-            missing = [s for s in splits if not isinstance(s["num_tasks"], int)][:12]
-            for s in missing:
-                try:
-                    r = _client.post(_url(rec, f"/{env_names[0]}/num_tasks"), json={"split": s["name"]}, timeout=8)
-                    s["num_tasks"] = int(_json(r).get("num_tasks")) if r.status_code == 200 else None
-                except Exception:  # noqa: BLE001
-                    s["num_tasks"] = None
+        from . import space_tasks
+        task_api = space_tasks.discover(rec, has, env_names)
         names = {t["name"] for t in tools or []}
         harbor = {"run_rollout", "capabilities"} <= names or "harbor_env" in env_names
         caps = _harbor_caps(rec) if "capabilities" in names and harbor else None
@@ -277,30 +445,37 @@ def probe(spec: str, fresh: bool = False) -> dict[str, Any]:
         version = (api.get("info") or {}).get("version") if isinstance(api, dict) and isinstance(api.get("info"), dict) else None
         info = {
             "running": True, "stage": rec["stage"], "host": rec["host"], "base_path": rec["base_path"],
-            "ui": ui, "openenv": openenv or "/reset" in has,
+            "ui": ui, "openenv": openenv,
             "metadata": meta if isinstance(meta, dict) else None, "health": health if isinstance(health, dict) else None,
             "schema": schema if isinstance(schema, dict) else None,
-            "step_api": "/reset" in has and "/step" in has, "docs": "/openapi.json" in has or api is not None,
+            "step_api": openenv and "/reset" in has and "/step" in has, "docs": "/openapi.json" in has or api is not None,
             "mcp": tools, "mcp_error": None if tools else tools_error,
-            "task_api": {"env": env_names[0], "splits": splits} if task_api else None,
+            "task_api": task_api,
             "harbor": harbor, "harbor_caps": caps,
             "rewards": bool(isinstance(obs, dict) and "reward" in (obs.get("properties") or {})),
             "graders": sorted(n for n in names if re.search(r"(grade|score|submit|verify|reward|judge)", n, re.I)),
             "routes": [r for r in routes if r not in STANDARD_ROUTES][:40],
-            "api": _api_routes(api, openenv or "/reset" in has),
+            "api": _api_routes(api, openenv),
             # which framework the server speaks, from what it serves
-            "framework": "harbor" if harbor else "openenv" if (openenv or "/reset" in has) else
+            "framework": "harbor" if harbor else "openenv" if openenv else
                          "nemo-gym" if {"/seed_session", "/verify"} <= has else
-                         "ors" if {"/create_session", "/{env_name}/call"} <= has else "mcp" if tools else "api" if api else None,
+                         "ors" if {"/create_session", "/{env_name}/call"} <= has else
+                         "gymnasium" if {"/reset", "/step"} <= has else "mcp" if tools else "api" if api else None,
             "openapi_version": version if isinstance(version, str) else None,
+            "endpoint_methods": {p: {m: {} for m in methods if m in ("get", "post")} for p, methods in (api or {}).get("paths", {}).items()
+                                 if p in ("/reset", "/step", "/state", "/mcp") and isinstance(methods, dict)} if isinstance(api, dict) else {},
             # OpenEnv's two modes: simulation serves /reset, /step and /state; production serves only MCP and /ws
-            "mode": ("simulation" if "/reset" in has else "production") if routes else None,
+            "mode": ("simulation" if "/reset" in has else "production") if openenv else None,
             "conformance": conformance({"openapi": api, "health": health, "metadata": meta, "schema": schema, "mcp": rpc,
                                         "mcp_tried": "/mcp" in has or openenv, "paths": routes}),
             "checked": time.time(),
         }
         if api is not None or isinstance(schema, dict) or isinstance(meta, dict) or tools:   # it answered: keep it
             remember(rec["id"], info)
+        from .envs.capabilities import space_support
+        info["support"] = space_support(info)
+        from . import space_checks
+        space_checks.observe(spec, info)
         return info
 
     if fresh:
@@ -518,17 +693,20 @@ def _withhold(v: Any, depth: int = 0) -> tuple[Any, list[str]]:
     return v, gone
 
 
-def _task_api(spec: str) -> tuple[dict, str]:
+def _task_api(spec: str, env: str = "") -> tuple[dict, str]:
     info = probe(spec)
     if not info.get("running"):
         raise SpaceError("this Space isn't running: wake it first", 409)
     if not info.get("task_api"):
         raise SpaceError("this server has no Task API", 404)
-    return record(spec), info["task_api"]["env"]
+    api = info["task_api"]
+    if env and env not in [e["env"] for e in api.get("environments", [api])]:
+        raise SpaceError("this environment is not in the Space's Task API", 400)
+    return record(spec), env or api["env"]
 
 
-def tasks(spec: str, split: str, start: int, stop: int) -> dict[str, Any]:
-    rec, env = _task_api(spec)
+def tasks(spec: str, split: str, start: int, stop: int, env: str = "") -> dict[str, Any]:
+    rec, env = _task_api(spec, env)
     start, stop = max(0, int(start)), max(0, int(stop))
     stop = min(stop, start + 50)
     try:
@@ -542,8 +720,8 @@ def tasks(spec: str, split: str, start: int, stop: int) -> dict[str, Any]:
     return {"tasks": rows, "start": start, "stop": stop, "withheld": sorted(set(gone))}
 
 
-def task(spec: str, split: str, index: int) -> dict[str, Any]:
-    rec, env = _task_api(spec)
+def task(spec: str, split: str, index: int, env: str = "") -> dict[str, Any]:
+    rec, env = _task_api(spec, env)
     try:
         r = _client.post(_url(rec, f"/{env}/task"), json={"split": split, "index": int(index)}, timeout=20)
     except httpx.HTTPError as e:
@@ -570,12 +748,18 @@ class Session:
         self.created = self.used = time.time()
         self.ws = None
         self.ws_failed = False
+        self.broken = False  # a dropped episode may only be recovered by an explicit reset
         self.http: httpx.Client | None = None   # the session's own cookie jar for the server's routes (NeMo Gym keeps state in a cookie)
+        self.remote_mcp: RemoteMCP | None = None
+        self.standard_mcp = False
         self.lock = threading.Lock()
         self.steps = 0
         self.rpc = 0
 
     def close(self) -> None:
+        if self.remote_mcp is not None:
+            self.remote_mcp.close()
+            self.remote_mcp = None
         if self.http is not None:
             try:
                 self.http.close()
@@ -625,6 +809,8 @@ def start(spec: str, owner: str) -> dict[str, Any]:
         if len(_sessions) >= TOTAL:
             raise SpaceError("too many live sessions on this explorer right now: try again in a few minutes", 429)
         s = Session(catalog.check_spec(spec), owner)
+        s.ws_failed = not bool(info.get("openenv"))
+        s.standard_mcp = not bool(info.get("openenv"))
         _sessions[s.id] = s
     return {"session": s.id}
 
@@ -660,6 +846,10 @@ def _open(s: Session) -> None:
 
 
 def _ws_send(s: Session, msg: dict, timeout: float) -> dict:
+    if s.broken and msg.get("type") != "reset":
+        raise SpaceError("the episode was disconnected: reset to start a new episode", 410)
+    if msg.get("type") == "reset":
+        s.broken = False
     if s.ws is None:
         _open(s)
     try:
@@ -667,9 +857,11 @@ def _ws_send(s: Session, msg: dict, timeout: float) -> dict:
         reply = json.loads(s.ws.recv(timeout=timeout))
     except TimeoutError:
         s.close()
+        s.broken = True
         raise SpaceError(f"the Space didn't answer within {int(timeout)} s; the session was closed", 504) from None
     except Exception as e:  # noqa: BLE001 - the socket dropped: the episode is gone
         s.close()
+        s.broken = True
         raise SpaceError(f"the session dropped ({type(e).__name__}): start a new episode", 502) from None
     if not isinstance(reply, dict):
         raise SpaceError("the Space answered something unexpected", 502)
@@ -680,7 +872,7 @@ def _ws_send(s: Session, msg: dict, timeout: float) -> dict:
 
 
 def _rpc(s: Session, method: str, params: dict, timeout: float) -> Any:
-    """An MCP call inside the session's episode; over plain HTTP (stateless) when the server has no socket for it."""
+    """Use OpenEnv's episode socket, standard HTTP MCP, or legacy OpenEnv HTTP fallback."""
     if not s.ws_failed:
         try:
             s.rpc += 1
@@ -696,6 +888,12 @@ def _rpc(s: Session, method: str, params: dict, timeout: float) -> Any:
                 err = data["error"] if isinstance(data["error"], dict) else {"message": str(data["error"])}
                 raise SpaceError(str(err.get("message") or "error")[:600], 422)
             return data.get("result") if isinstance(data, dict) else data
+    if s.standard_mcp:
+        if s.http is None:
+            s.http = SpaceClient(timeout=httpx.Timeout(120, connect=8), follow_redirects=False)
+        if s.remote_mcp is None:
+            s.remote_mcp = RemoteMCP(record(s.spec), s.http)
+        return s.remote_mcp.call(method, params, timeout)
     return mcp_call(record(s.spec), method, params, timeout=timeout)
 
 
@@ -705,14 +903,15 @@ def _http(s: Session, data: dict) -> dict[str, Any]:
     if method not in ("GET", "POST"):
         raise SpaceError("GET or POST only", 400)
     info = probe(s.spec)
-    path = route_url(info, method, str(data.get("path") or ""), data.get("params") if isinstance(data.get("params"), dict) else {})
+    path = route_url(info, method, str(data.get("path") or ""), data.get("params") if isinstance(data.get("params"), dict) else {},
+                     data.get("query") if isinstance(data.get("query"), dict) else {})
     rec = record(s.spec)
     if s.http is None:
-        s.http = httpx.Client(base_url=rec["host"], timeout=httpx.Timeout(120, connect=8), follow_redirects=False,
+        s.http = SpaceClient(base_url=rec["host"], timeout=httpx.Timeout(120, connect=8), follow_redirects=False,
                               headers={"User-Agent": "hf-rl-explorer (+https://huggingface.co/FineEnvs)"})
     body = data.get("body")
     try:
-        r = s.http.request(method, path, json=body if method == "POST" else None)
+        r = s.http.request(method, _url(rec, path), json=body if method == "POST" else None)
     except httpx.TimeoutException:
         raise SpaceError("the Space didn't answer within 120 s", 504) from None
     except httpx.HTTPError as e:
@@ -773,7 +972,8 @@ def act(sid: str, owner: str, op: str, data: dict | None = None) -> dict[str, An
             s.steps += 1
         else:
             raise SpaceError(f"unknown operation {op!r}", 400)
-        return {"result": out, "ms": int((time.time() - t0) * 1000), "steps": s.steps, "stateful": not s.ws_failed}
+        return {"result": out, "ms": int((time.time() - t0) * 1000), "steps": s.steps,
+                "stateful": op == "http" or s.standard_mcp or not s.ws_failed}
 
 
 def live_sessions() -> int:

app/vendor/nemo_gym/LICENSE

@@ -0,0 +1,201 @@
+                                 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 [yyyy] [name of copyright owner]
+
+   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.

app/vendor/nemo_gym/NOTICE

@@ -0,0 +1,5 @@
+NeMo Gym verification_utils.py from NVIDIA-NeMo/Gym
+Commit: 3ef478df1ee163134d32a3f291f0a9e5981d0e52
+Path: resources_servers/single_step_tool_use_with_argument_comparison/common/verification_utils.py
+SHA256: 41d82a49130adbf69fa9fca86c5f3eed28992ea6909e9dc05131b2830c0a1f89
+Unmodified. Copyright NVIDIA CORPORATION & AFFILIATES. Apache-2.0.

app/vendor/nemo_gym/verification_utils.py

@@ -0,0 +1,398 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+import json
+from collections import Counter
+from enum import StrEnum
+from json import JSONDecodeError
+from typing import Annotated, Any, Literal, Optional, TypeAlias, Union
+
+from pydantic import BaseModel, Field
+
+
+class MessageAction(BaseModel):
+    type: Literal["message"]
+    content: str
+
+
+class FunctionCallAction(BaseModel):
+    type: Literal["function_call"]
+    name: str
+    arguments: str
+
+
+class FunctionCallBatchAction(BaseModel):
+    type: Literal["function_call_batch"]
+    calls: list[FunctionCallAction] = Field(min_length=1)
+
+
+# Actions are canonical on both sides of a comparison: dataset rows deserialize into them, and model
+# responses are normalized into them by `response_utils.extract_action`. The alias keeps the name
+# that dataset validation tooling imports.
+ExpectedAction: TypeAlias = Annotated[
+    Union[MessageAction, FunctionCallAction, FunctionCallBatchAction],
+    Field(discriminator="type"),
+]
+
+
+def get_tool_calls(action: ExpectedAction) -> list[FunctionCallAction]:
+    """Flatten an action into the tool calls it represents, so single and parallel calls share a path."""
+    if isinstance(action, FunctionCallBatchAction):
+        return list(action.calls)
+
+    if isinstance(action, FunctionCallAction):
+        return [action]
+
+    return []
+
+
+class StepRewardCategory(StrEnum):
+    NO_ACTION_FOUND = "No tool call or chat message was found in the response"
+    NO_EXPECTED_TOOL_CALL = "No tool call was found when one was expected"
+    EXPECTED_CHAT_MESSAGE_FOUND = "A chat message was found as expected"
+    NO_EXPECTED_CHAT_MESSAGE = "A tool call was executed when a chat message was expected"
+    UNEXPECTED_TOOL = "The tool in a tool call is not the expected tool"
+    ARGUMENTS_DECODE_ERROR = "An error occurred when decoding the arguments string in a tool call as a JSON object"
+    ARGUMENT_VALUE_TYPE_DIFFERENT = "The type of an argument value in a tool call is different than the expected type"
+    ARGUMENT_OBJECT_KEYS_DIFFERENT = (
+        "The keys in an object in an argument value in a tool call are different than the keys in the expected object"
+    )
+    ARGUMENT_LIST_LENGTH_DIFFERENT = (
+        "A list in an argument value in a tool call has a different length than the expected list"
+    )
+    ARGUMENT_VALUE_DIFFERENT = "An argument value in a tool call is different than the expected value"
+    EXPECTED_TOOL_CALL = "A tool call that matches the expected tool call was found"
+    FUNCTION_CALL_BATCH_LENGTH_DIFFERENT = "The number of tool calls in a batch is different than expected"
+    EXPECTED_TOOL_CALL_BATCH = "A tool-call batch that matches the expected tool calls was found"
+
+
+class ParallelToolCallRewardMode(StrEnum):
+    """How an admissible parallel tool-call response converts its matched-call count into a reward."""
+
+    BINARY_STRICT = "binary_strict"
+    FRACTIONAL = "fractional"
+    F1 = "f1"
+
+
+class ActionComparisonResult(BaseModel):
+    reward: float
+    category: StepRewardCategory
+
+
+class ToolCallComparatorConfig(BaseModel):
+    word_count_similarity_threshold: float
+    floating_point_comparison_threshold: float = 1e-6
+
+    # Master switch: does the NUMBER of tool calls the model made affect its reward?
+    #
+    # False (default) turns parallel tool-call rewarding off entirely. The question asked of a
+    # response is only "did it make the expected call(s)?", so surplus calls are never penalized.
+    # This reproduces the behaviour that predates parallel tool-call support, which is why it is the
+    # default: existing datasets score exactly as they did before. It is also the honest default,
+    # because chat templates do not render differently for `parallel_tool_calls` (the Nemotron
+    # template never references the flag), so a model is never told how many calls it may make.
+    #
+    # True turns it on: the call count becomes part of the verdict, and the three settings below
+    # decide which counts are admissible and how partial matches are scored. Turn this on for
+    # datasets that use `expected_action.type: function_call_batch`.
+    parallel_tool_call_rewarding: bool = False
+
+    # The three settings below are only consulted when `parallel_tool_call_rewarding` is True.
+
+    # Cardinality gate: whether a response that makes fewer / more tool calls than expected is
+    # admissible at all. Both default to False, so the call count must match exactly.
+    allow_subset: bool = False
+    allow_superset: bool = False
+
+    # Scoring for responses that clear the gate. See `ActionComparator.compare_tool_calls`.
+    parallel_tool_call_reward_mode: ParallelToolCallRewardMode = ParallelToolCallRewardMode.BINARY_STRICT
+
+
+def find_maximum_matching(candidates: list[list[int]]) -> dict[int, int]:
+    """Maximum bipartite matching between expected and actual tool calls (Kuhn's algorithm).
+
+    `candidates[expected_index]` lists the actual-call indices that expected call could match, and the
+    returned mapping goes from actual index to the expected index it was matched with. Greedy pairing
+    is not enough here: argument matching is a fuzzy relation, so one actual call can satisfy several
+    expected calls and an early arbitrary pairing can strand a later expected call that had no
+    alternative. Augmenting paths undo those pairings and recover the true maximum.
+    """
+    matching: dict[int, int] = {}
+
+    # Matching the most constrained expected calls first keeps the number of augmenting paths small.
+    for expected_index in sorted(range(len(candidates)), key=lambda index: len(candidates[index])):
+        _augment_matching(expected_index, candidates, matching, set())
+
+    return matching
+
+
+def _augment_matching(
+    expected_index: int,
+    candidates: list[list[int]],
+    matching: dict[int, int],
+    visited_actual_indices: set[int],
+) -> bool:
+    for actual_index in candidates[expected_index]:
+        if actual_index in visited_actual_indices:
+            continue
+
+        visited_actual_indices.add(actual_index)
+        is_unmatched = actual_index not in matching
+        if is_unmatched or _augment_matching(matching[actual_index], candidates, matching, visited_actual_indices):
+            matching[actual_index] = expected_index
+            return True
+
+    return False
+
+
+class ActionComparator(BaseModel):
+    config: ToolCallComparatorConfig
+
+    def compare_action(self, expected_action: ExpectedAction, actual_action: ExpectedAction) -> ActionComparisonResult:
+        match expected_action:
+            case MessageAction():
+                # Currently, any chat message is assigned a reward of one.
+                if isinstance(actual_action, MessageAction):
+                    return ActionComparisonResult(reward=1.0, category=StepRewardCategory.EXPECTED_CHAT_MESSAGE_FOUND)
+
+                return ActionComparisonResult(reward=0.0, category=StepRewardCategory.NO_EXPECTED_CHAT_MESSAGE)
+
+            case FunctionCallAction() | FunctionCallBatchAction():
+                if isinstance(actual_action, MessageAction):
+                    return ActionComparisonResult(reward=0.0, category=StepRewardCategory.NO_EXPECTED_TOOL_CALL)
+
+                return self.compare_tool_calls(get_tool_calls(expected_action), get_tool_calls(actual_action))
+
+            case _:
+                raise NotImplementedError(f"Unsupported expected action: {expected_action!r}")
+
+    def compare_tool_calls(
+        self, expected_calls: list[FunctionCallAction], actual_calls: list[FunctionCallAction]
+    ) -> ActionComparisonResult:
+        """Score a set of tool calls against the expected set, ignoring the order they were emitted in.
+
+        `parallel_tool_call_rewarding` is the master switch. While it is False (the default) the number
+        of calls is simply not part of the verdict: the response is asked only whether it made the
+        expected call(s), and surplus calls cost nothing. That reproduces the behaviour that predates
+        parallel tool-call support.
+
+        Turning it on makes the call count matter, in two independent stages. The cardinality gate
+        (`allow_subset` / `allow_superset`) decides whether a response that under- or over-calls is
+        admissible at all; anything it rejects scores zero. `parallel_tool_call_reward_mode` then decides
+        how much credit an admissible response earns:
+
+        - `binary_strict` — 1.0 only if every required call matched, else 0.0.
+        - `fractional` — the matched fraction of the required calls. Surplus calls permitted by
+          `allow_superset` are free, so this rewards recall but not precision.
+        - `f1` — the harmonic mean of precision and recall, `2 * matched / (expected + actual)`. Missing
+          and surplus calls are penalized symmetrically, so a response only reaches 1.0 by matching the
+          expected calls exactly.
+        """
+        expected_count = len(expected_calls)
+        actual_count = len(actual_calls)
+
+        if expected_count == 1 and actual_count == 1:
+            # Preserve the single-call categories that predate parallel tool-call support.
+            return self.compare_tool_call(expected_calls[0], actual_calls[0])
+
+        if not self.is_call_count_admissible(expected_count, actual_count):
+            return ActionComparisonResult(reward=0.0, category=StepRewardCategory.FUNCTION_CALL_BATCH_LENGTH_DIFFERENT)
+
+        candidates, failure_categories = self.build_match_candidates(expected_calls, actual_calls)
+        matching = find_maximum_matching(candidates)
+        reward = self.score_matched_calls(len(matching), expected_count, actual_count)
+        if reward == 1.0:
+            # A single expected call keeps the category it had before parallel support existed.
+            category = (
+                StepRewardCategory.EXPECTED_TOOL_CALL
+                if expected_count == 1
+                else StepRewardCategory.EXPECTED_TOOL_CALL_BATCH
+            )
+            return ActionComparisonResult(reward=reward, category=category)
+
+        category = self.resolve_failure_category(
+            matched_expected_indices=set(matching.values()),
+            failure_categories=failure_categories,
+            expected_count=expected_count,
+            actual_count=actual_count,
+        )
+        return ActionComparisonResult(reward=reward, category=category)
+
+    def is_call_count_admissible(self, expected_count: int, actual_count: int) -> bool:
+        if actual_count == expected_count:
+            return True
+
+        # With parallel tool-call rewarding off, the call count is not part of the verdict at all.
+        if not self.config.parallel_tool_call_rewarding:
+            return True
+
+        if actual_count < expected_count:
+            return self.config.allow_subset
+
+        return self.config.allow_superset
+
+    def required_match_count(self, expected_count: int, actual_count: int) -> int:
+        """How many expected calls must match for full credit under `binary_strict` and `fractional`."""
+        if self.config.allow_subset:
+            return min(expected_count, actual_count)
+
+        return expected_count
+
+    def score_matched_calls(self, matched_count: int, expected_count: int, actual_count: int) -> float:
+        if not self.config.parallel_tool_call_rewarding:
+            # The call count is not part of the verdict, so neither the gate nor the reward mode
+            # applies: full credit exactly when every expected call was matched.
+            return 1.0 if matched_count == expected_count else 0.0
+
+        if self.config.parallel_tool_call_reward_mode == ParallelToolCallRewardMode.F1:
+            total_count = expected_count + actual_count
+            return 2 * matched_count / total_count if total_count else 0.0
+
+        required_count = self.required_match_count(expected_count, actual_count)
+        if self.config.parallel_tool_call_reward_mode == ParallelToolCallRewardMode.FRACTIONAL:
+            return matched_count / required_count if required_count else 0.0
+
+        return 1.0 if matched_count == required_count else 0.0
+
+    def build_match_candidates(
+        self, expected_calls: list[FunctionCallAction], actual_calls: list[FunctionCallAction]
+    ) -> tuple[list[list[int]], list[StepRewardCategory]]:
+        """Pair every expected call with the actual calls it matches, keeping why the others missed."""
+        candidates: list[list[int]] = []
+        failure_categories: list[StepRewardCategory] = []
+
+        for expected_call in expected_calls:
+            matching_actual_indices: list[int] = []
+            failure_category = StepRewardCategory.UNEXPECTED_TOOL
+
+            for actual_index, actual_call in enumerate(actual_calls):
+                result = self.compare_tool_call(expected_call, actual_call)
+                if result.reward == 1.0:
+                    matching_actual_indices.append(actual_index)
+
+                elif failure_category == StepRewardCategory.UNEXPECTED_TOOL:
+                    # Keep the first reason that got past the tool name; it explains the closest near miss.
+                    failure_category = result.category
+
+            candidates.append(matching_actual_indices)
+            failure_categories.append(failure_category)
+
+        return candidates, failure_categories
+
+    def resolve_failure_category(
+        self,
+        matched_expected_indices: set[int],
+        failure_categories: list[StepRewardCategory],
+        expected_count: int,
+        actual_count: int,
+    ) -> StepRewardCategory:
+        unmatched_expected_indices = [
+            expected_index
+            for expected_index in range(expected_count)
+            if expected_index not in matched_expected_indices
+        ]
+
+        # Either every expected call was matched and the only defect left is surplus calls, or every
+        # actual call was consumed and the only defect left is missing calls. Reporting an argument
+        # mismatch in those cases would point at a comparison that is not why the reward was docked.
+        if not unmatched_expected_indices or len(matched_expected_indices) == actual_count:
+            return StepRewardCategory.FUNCTION_CALL_BATCH_LENGTH_DIFFERENT
+
+        return failure_categories[unmatched_expected_indices[0]]
+
+    def compare_tool_call(
+        self, expected_tool_call: FunctionCallAction, actual_tool_call: FunctionCallAction
+    ) -> ActionComparisonResult:
+        if expected_tool_call.name != actual_tool_call.name:
+            return ActionComparisonResult(reward=0.0, category=StepRewardCategory.UNEXPECTED_TOOL)
+
+        # It is assumed that the expected arguments string is a string representation of a JSON object.
+        expected_arguments = json.loads(expected_tool_call.arguments)
+
+        try:
+            actual_arguments = json.loads(actual_tool_call.arguments)
+        except (JSONDecodeError, UnicodeDecodeError):
+            return ActionComparisonResult(reward=0.0, category=StepRewardCategory.ARGUMENTS_DECODE_ERROR)
+
+        arguments_match, category = self.compare_tool_call_arguments(expected_arguments, actual_arguments)
+        if arguments_match:
+            return ActionComparisonResult(reward=1.0, category=StepRewardCategory.EXPECTED_TOOL_CALL)
+
+        return ActionComparisonResult(reward=0.0, category=category)
+
+    def compare_tool_call_arguments(
+        self, expected_value: Any, actual_value: Any
+    ) -> tuple[bool, Optional[StepRewardCategory]]:
+        if not isinstance(actual_value, type(expected_value)):
+            return False, StepRewardCategory.ARGUMENT_VALUE_TYPE_DIFFERENT
+
+        if isinstance(expected_value, dict):
+            if set(expected_value.keys()) != set(actual_value.keys()):
+                return False, StepRewardCategory.ARGUMENT_OBJECT_KEYS_DIFFERENT
+
+            for expected_dict_key, expected_dict_value in expected_value.items():
+                actual_dict_value = actual_value[expected_dict_key]
+                dict_value_match, dict_value_category = self.compare_tool_call_arguments(
+                    expected_dict_value, actual_dict_value
+                )
+                if not dict_value_match:
+                    return dict_value_match, dict_value_category
+
+            return True, None
+
+        elif isinstance(expected_value, list):
+            if len(expected_value) != len(actual_value):
+                return False, StepRewardCategory.ARGUMENT_LIST_LENGTH_DIFFERENT
+
+            for expected_list_element, actual_list_element in zip(expected_value, actual_value):
+                list_element_match, list_element_category = self.compare_tool_call_arguments(
+                    expected_list_element, actual_list_element
+                )
+                if not list_element_match:
+                    return list_element_match, list_element_category
+
+            return True, None
+
+        elif isinstance(expected_value, float):
+            if abs(actual_value - expected_value) < self.config.floating_point_comparison_threshold:
+                return True, None
+            else:
+                return False, StepRewardCategory.ARGUMENT_VALUE_DIFFERENT
+
+        elif isinstance(expected_value, str):
+            # For now, strings are compared by using whitespace to split them into lower-case
+            # words, counting the words, and comparing the word counts using Jaccard similarity.
+            expected_word_counts = Counter(expected_value.strip().lower().split())
+            actual_word_counts = Counter(actual_value.strip().lower().split())
+            expected_word_total = expected_word_counts.total()
+            actual_word_total = actual_word_counts.total()
+
+            if expected_word_total < 2 or actual_word_total < 2:
+                if expected_value != actual_value:
+                    return False, StepRewardCategory.ARGUMENT_VALUE_DIFFERENT
+
+            else:
+                intersection_word_counts = expected_word_counts & actual_word_counts
+
+                word_count_similarity = intersection_word_counts.total() / (expected_word_total + actual_word_total)
+                if word_count_similarity < self.config.word_count_similarity_threshold:
+                    return False, StepRewardCategory.ARGUMENT_VALUE_DIFFERENT
+
+            return True, None
+
+        elif expected_value == actual_value:
+            return True, None
+
+        else:
+            return False, StepRewardCategory.ARGUMENT_VALUE_DIFFERENT

app/version.py

@@ -26,9 +26,9 @@ def app_version() -> str:
 @lru_cache(maxsize=1)
 def source_hash() -> str:
     h = hashlib.sha256()
-    for base in (ROOT / "app", ROOT / "web" / "js"):
+    for base in (ROOT / "app", ROOT / "web", ROOT / "web-admin"):
         for p in sorted(base.rglob("*")):
-            if p.is_file() and p.suffix in (".py", ".js", ".txt", ".json") and "__pycache__" not in p.parts:
+            if p.is_file() and p.suffix in (".py", ".js", ".txt", ".json", ".css", ".html") and "__pycache__" not in p.parts:
                 h.update(p.relative_to(ROOT).as_posix().encode())
                 h.update(p.read_bytes())
     return h.hexdigest()[:12]

pyproject.toml

@@ -9,6 +9,7 @@ dependencies = [
     "httpx>=0.27",
     "huggingface_hub>=1.29",
     "pyyaml>=6",
+    "packaging>=24.2",
     "cryptography>=44",
     "openenv",
     "harbor>=0.23",

scripts/deploy_spaces.py

@@ -42,8 +42,8 @@ SPACES = {
 }
 # never uploaded: local data and caches, the READMEs (each Space gets its own as README.md), editor and OS files
 IGNORE = [".venv/*", ".local-data/*", "*/__pycache__/*", "__pycache__/*", "*.pyc", ".pytest_cache/*", ".ruff_cache/*",
-          ".gradio/*", "node_modules/*", ".DS_Store", "*/.DS_Store", "README.md", "SPACE_README.md", "ADMIN_SPACE_README.md",
-          ".env", "*.env", ".git/*"]
+          ".gradio/*", "node_modules/*", ".DS_Store", "*/.DS_Store", "README.md", "SPACE_README.md", "ADMIN_SPACE_README.md", "EXPLORER_AUDIT.md",
+          ".env", ".env.*", "*/.env", "*/.env.*", "*.env", "*.pem", "*.key", ".git/*"]
 
 
 SKIP_DIRS = {".venv", ".local-data", "__pycache__", ".pytest_cache", ".ruff_cache", ".gradio", "node_modules", ".git"}
@@ -53,10 +53,10 @@ def files() -> list[str]:
     """What goes into the Space: walked without descending into local data, caches or the virtualenv."""
     out = []
     for root, dirs, names in os.walk(ROOT):
-        dirs[:] = sorted(d for d in dirs if d not in SKIP_DIRS)
+        dirs[:] = sorted(d for d in dirs if d not in SKIP_DIRS and not (Path(root) / d).is_symlink())
         for n in sorted(names):
             rel = (Path(root) / n).relative_to(ROOT).as_posix()
-            if not any(fnmatch.fnmatch(rel, pat) for pat in IGNORE):
+            if not (Path(root) / n).is_symlink() and not any(fnmatch.fnmatch(rel, pat) for pat in IGNORE):
                 out.append(rel)
     return out
 

tests/reward-stats.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { rewardDistribution } from '../web/js/reward-stats.js';
+
+test('negative and unbounded rewards remain in the histogram', () => {
+  const d = rewardDistribution([-100, -5, 0, 0.5, 1, 500]);
+  assert.equal(d.min, -100);
+  assert.equal(d.max, 500);
+  assert.equal(d.hist.reduce((a, b) => a+b), 6);
+  assert.equal(d.hist[0], 1);
+  assert.equal(d.hist[9], 1);
+});
+test('empty and normalized rewards keep a useful finite range', () => {
+  for (const xs of [[], [0, 0.5, 1], [NaN, Infinity]]) {
+    const d = rewardDistribution(xs);
+    assert.equal(d.min, 0);
+    assert.equal(d.max, 1);
+    assert.ok(d.hist.every(Number.isFinite));
+  }
+});

tests/schemaform.test.mjs

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { schemaForm, readForm, resolveSchema, validateValue } from '../web/js/schemaform.js';
+
+const form = (fields = [], root = null) => ({
+  querySelector: () => root,
+  querySelectorAll: () => fields.map(([k, t, value]) => ({ dataset: { k, t }, value })),
+});
+const plain = (v) => JSON.parse(JSON.stringify(v));
+
+test('optional booleans can be omitted, and explicit false remains false', () => {
+  const schema = { type: 'object', properties: { enabled: { type: 'boolean', default: true } } };
+  assert.deepEqual(plain(readForm(form([['enabled', 'bool', '']]), schema)), {});
+  assert.deepEqual(plain(readForm(form([['enabled', 'bool', 'false']]), schema)), { enabled: false });
+  assert.match(schemaForm(schema), /Use server default/);
+});
+
+test('integer inputs reject fractions rather than truncating actions', () => {
+  const s = { type: 'object', properties: { action: { type: 'integer', minimum: 0, maximum: 3 } }, required: ['action'] };
+  for (const value of ['1.5', '4', '-1', 'Infinity', '9007199254740992', '']) {
+    assert.throws(() => readForm(form([['action', 'int', value]]), s));
+  }
+  assert.equal(readForm(form([['action', 'int', '0']]), s).action, 0);
+});
+
+test('enum values retain their JSON type and never silently pick the first option', () => {
+  const s = { type: 'object', properties: { action: { enum: [0, 1, 'stop', null] } }, required: ['action'] };
+  assert.match(schemaForm(s), /Choose a value/);
+  assert.equal(readForm(form([['action', 'enum', '0']]), s).action, 0);
+  assert.equal(readForm(form([['action', 'enum', 'null']]), s).action, null);
+  assert.throws(() => readForm(form([['action', 'enum', '"bad"']]), s));
+});
+
+test('local references retain defaults and referenced discriminators', () => {
+  const s = { type: 'object', $defs: { Mode: { const: 'move' }, Count: { type: 'integer', default: 7 } },
+    properties: { type: { $ref: '#/$defs/Mode' }, count: { $ref: '#/$defs/Count' } } };
+  assert.match(schemaForm(s), /value="7"/);
+  assert.equal(readForm(form(), s).type, 'move');
+});
+
+test('recursive and missing references are bounded', () => {
+  const s = { $ref: '#/$defs/Loop', $defs: { Loop: { $ref: '#/$defs/Loop' } } };
+  assert.doesNotThrow(() => schemaForm(s));
+  assert.deepEqual(resolveSchema({ $ref: '#/$defs/missing' }, s), {});
+});
+
+test('root action unions use JSON without losing nested arguments', () => {
+  const s = { oneOf: [
+    { type: 'object', properties: { type: { const: 'move' }, position: { type: 'array', items: { type: 'number' }, minItems: 2 } }, required: ['type', 'position'] },
+    { type: 'object', properties: { type: { const: 'stop' } }, required: ['type'] },
+  ] };
+  assert.match(schemaForm(s), /data-root-json/);
+  assert.deepEqual(readForm(form([], { value: '{"type":"move","position":[1,2]}' }), s), { type: 'move', position: [1, 2] });
+  assert.throws(() => readForm(form([], { value: '{"type":"move"}' }), s));
+});
+
+test('open objects have a JSON editor rather than claiming no inputs', () => {
+  assert.match(schemaForm({ type: 'object' }), /data-root-json/);
+  assert.match(schemaForm({ type: 'object', additionalProperties: false }), /No inputs/);
+});
+
+test('all interpolated upstream schema values are escaped', () => {
+  const payload = '\"><img src=https://evil.test/>';
+  const s = { type: 'object', properties: { [payload]: { type: 'number', default: payload, minimum: payload } } };
+  const html = schemaForm(s, { prefix: payload });
+  assert.ok(!html.includes('<img'));
+  assert.ok(!html.includes('min="' + payload));
+});
+
+test('sanitized property names cannot create duplicate input ids', () => {
+  const html = schemaForm({ properties: { 'a.b': { type: 'string' }, 'a/b': { type: 'string' } } });
+  const ids = [...html.matchAll(/\bid="([^"]+)"/g)].map((x) => x[1]);
+  assert.equal(ids.length, new Set(ids).size);
+});
+
+test('prototype-like field names remain ordinary JSON properties', () => {
+  const schema = JSON.parse('{"type":"object","properties":{"__proto__":{"type":"object"}}}');
+  const result = readForm(form([['__proto__', 'json', '{"polluted":true}']]), schema);
+  assert.equal(Object.getPrototypeOf(result), null);
+  assert.equal({}.polluted, undefined);
+  assert.equal(JSON.parse(JSON.stringify(result)).__proto__.polluted, true);
+});
+
+test('nested required, size and additional-properties constraints report actionable errors', () => {
+  const s = { type: 'object', properties: { args: { type: 'object', properties: { text: { type: 'string', minLength: 2 } }, required: ['text'], additionalProperties: false } } };
+  assert.throws(() => validateValue({ args: {} }, s), /args.text is required/);
+  assert.throws(() => validateValue({ args: { text: '' } }, s), /at least 2/);
+  assert.throws(() => validateValue({ args: { text: 'ok', answer: 'secret' } }, s), /not an allowed field/);
+});

tests/space-media.test.mjs

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spaceMedia } from '../web/js/space-media.js';
+import { taskContent } from '../web/js/space-task-view.js';
+
+test('lazy Space media resolves against the serving Space without mutating observations', () => {
+  const raw = { observation: { asset_path: '/assets/hash?task_id=a', mime: 'audio/wav' } };
+  const out = spaceMedia(raw, 'https://owner-env.hf.space');
+  assert.equal(out.observation.media_url, 'https://owner-env.hf.space/assets/hash?task_id=a');
+  assert.equal(raw.observation.media_url, undefined);
+});
+
+test('media paths cannot change origin or use active URL schemes', () => {
+  for (const path of ['//evil.example/assets/a', 'javascript:alert(1)', 'https://evil.example/a', '/other/a'])
+    assert.equal(spaceMedia({ asset_path: path, mime: 'audio/wav' }, 'https://owner-env.hf.space').media_url, undefined);
+  assert.equal(spaceMedia({ asset_path: '/assets/a', mime: 'audio/wav' }, 'http://localhost').media_url, undefined);
+});
+
+test('task inputs are escaped and lazy media remains an available episode', () => {
+  const html = taskContent({ prompt: '<img src=x onerror=alert(1)>', task_id: 'a'.repeat(200), media_ready: false });
+  assert.ok(!html.includes('<img src=x'));
+  assert.ok(html.includes('Media loads when the episode starts'));
+  assert.ok(html.includes('Task record'));
+});

tests/test_admin_dashboard.py

@@ -0,0 +1,94 @@
+import time
+from contextlib import contextmanager
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app import admin, admin_app, auth, auto_index, catalog, community, search_api, settings, snapshot, space_checks, store
+
+client = TestClient(admin_app.app)
+
+
+@pytest.fixture
+def data(monkeypatch):
+    now = time.time()
+    checks = {name: {'id': name, 'stage': 'RUNNING', 'status': status, 'checked_at': at, 'interface': interface,
+                      'task_catalog': {'tasks': 50, 'counted_splits': 1, 'complete': True, 'checked_at': now}}
+              for name, status, at, interface in [('org/openenv', space_checks.PASS, now, None),
+                  ('org/stale', space_checks.PASS, now-7200, None), ('org/nemo', 'Checks failed', now, 'nemo-gym')]}
+    envs = [{'id':'org/harbor','key':'org/harbor','kind':'dataset','framework':'harbor','indexed':{'tasks':8}}]
+    envs += [{'id':name, 'key':'space:'+name, 'kind':'space', 'api_check':rec, 'declared_version':'0.3.0'} for name,rec in checks.items()]
+    base = {'user':'alice','dataset':'org/harbor','path':'task','title':'Example','status':'done','reward':1,
+            'visibility':'public','created_at':now,'updated_at':now,'avatar':'https://example.com/avatar.png'}
+    runs = [{**base,'id':'harbor','runner':'harbor','reward':-2}, {**base,'id':'mimo','runner':'mimo','domain':'code','visibility':'private'},
+            {**base,'id':'nemo','runner':'nemo_gym'}, {**base,'id':'hidden','runner':'harbor'},
+            {**base,'id':'restricted','runner':'harbor','restricted':True}, {**base,'id':'ungraded','reward':None},
+            {**base,'id':'live','runner':'mimo','status':'running','reward':None}]
+    monkeypatch.setattr(auth,'current_user',lambda request:{'name':'alice'})
+    monkeypatch.setattr(settings,'is_admin',lambda u:True)
+    monkeypatch.setattr(settings,'get',lambda k,d=None: ['hidden'] if k=='hidden_runs' else d)
+    monkeypatch.setattr(admin,'_runs',lambda:runs)
+    monkeypatch.setattr(admin,'avatar',lambda u:None)
+    monkeypatch.setattr(search_api,'environments',lambda **kw:envs)
+    monkeypatch.setattr(space_checks,'inventory',lambda:checks)
+    monkeypatch.setattr(catalog,'hidden',lambda:set())
+    monkeypatch.setattr(auto_index,'status',lambda:{'state':'idle','last_success':now-20,'next_at':now+600})
+    monkeypatch.setattr(snapshot,'status',lambda:{'built_at':'2026-10-04T00:00:00+00:00'})
+    @contextmanager
+    def use():
+        yield None,None
+    monkeypatch.setattr(snapshot,'use',use)
+    monkeypatch.setattr(search_api,'sql_extra',lambda conn,ctx,n,q:{'stats':{'datasets':1,'spaces':2,'tasks':8}})
+    return envs,runs,checks
+
+
+def test_overview_matches_community_eligibility_and_checked_spaces(data):
+    d=client.get('/api/admin/overview').json()
+    assert d['environments']['spaces']==3
+    assert d['environments']['checked_spaces']==2
+    assert d['environments']['openenv']==1
+    assert d['environments']['public']=={'datasets':1,'spaces':2,'tasks':8}
+    assert d['rollouts']['public']==2
+    assert d['rollouts']['private']==1
+    assert len(d['live'])==1
+    assert dict(d['rollouts']['by_runner'])=={'harbor':4,'mimo':2,'nemo-gym':1}
+
+
+def test_operations_show_expired_checks_without_counting_them_as_ready(data,monkeypatch):
+    monkeypatch.setattr(auto_index,'status',lambda:{'state':'indexing','next_at':time.time()-5000})
+    monkeypatch.setattr(catalog,'hidden',lambda:{'space:org/nemo'})
+    d=admin._operations(data[0])
+    assert d['indexer']['stale']
+    assert d['checks']['ready']==2
+    assert d['checks']['statuses']['Check expired']==1
+    assert d['task_catalog']['tasks']==50  # hidden and expired Spaces excluded
+    assert d['checks']['versions']==[('0.3.0',1)]
+
+
+def test_admin_runner_visibility_filters_and_safe_pagination(data):
+    d=client.get('/api/admin/rollouts?runner=nemo-gym&visibility=community').json()
+    assert d['total']==1 and d['runs'][0]['runner']=='nemo-gym'
+    assert d['runs'][0]['community']
+    assert d['runners']==['harbor','mimo','nemo-gym']
+    assert client.get('/api/admin/rollouts?visibility=community').json()['total']==2
+    assert client.get('/api/admin/rollouts?visibility=moderated').json()['total']==1
+    assert client.get('/api/admin/rollouts?visibility=private').json()['total']==1
+    assert client.get('/api/admin/rollouts?offset=-8&limit=1').json()['runs'][0]['id']=='harbor'
+
+
+def test_people_do_not_treat_reward_above_one_as_universal_success(data):
+    d=client.get('/api/admin/people').json()['people'][0]
+    assert 'solved' not in d
+    assert d['scored']==5 and d['public']==2
+
+
+def test_environment_admin_keeps_unverified_candidates_for_review(data):
+    rows=client.get('/api/admin/environments').json()['environments']
+    assert len(rows)==4
+    assert {r['id'] for r in rows if r['ready']}=={'org/harbor','org/openenv','org/nemo'}
+
+
+def test_public_eligibility_reused_for_admin_and_community(data):
+    hidden={'hidden'}
+    for r in data[1]:
+        assert admin._admin_view(r)['community']==community.is_public(r,hidden)

tests/test_audit_regressions.py

@@ -0,0 +1,163 @@
+"""Security and lifecycle regressions found during PR #33's explorer audit."""
+import gzip
+
+import httpx
+import pytest
+from fastapi.testclient import TestClient
+
+from app import config, main, runner, spaces_live as live
+
+
+def test_forwarded_addresses_require_a_trusted_proxy(monkeypatch):
+    from starlette.requests import Request
+    from app.http import client_ip
+    request = Request({"type": "http", "headers": [(b"x-forwarded-for", b"forged, proxy-appended")], "client": ("peer", 123)})
+    monkeypatch.setattr(config, "TRUST_PROXY", False)
+    assert client_ip(request) == "peer"
+    monkeypatch.setattr(config, "TRUST_PROXY", True)
+    assert client_ip(request) == "proxy-appended"
+
+
+def test_streamed_gzip_has_a_decompression_output_cap(monkeypatch):
+    monkeypatch.setattr(live, "MAX_REPLY", 1024)
+    class Stream(httpx.SyncByteStream):
+        def __iter__(self):
+            yield gzip.compress(b"x" * 10_000_000)
+    with live.SpaceClient(transport=httpx.MockTransport(lambda r: httpx.Response(200, headers={"content-encoding": "gzip"}, stream=Stream()))) as c:
+        with pytest.raises(live.SpaceError, match="too large"):
+            c.get("https://fixture.hf.space/")
+
+
+@pytest.mark.parametrize("headers", [
+    {"Origin": "https://evil.example", "X-Forwarded-Host": "evil.example"},
+    {"Origin": "http://testserver"},
+    {"Origin": "null"},
+    {"Origin": "https://testserver/path"},
+    {"Origin": "https://testserver@evil.example"},
+])
+def test_origin_must_match_scheme_and_authority(monkeypatch, headers):
+    monkeypatch.setattr(config, "PUBLIC_URL", "")
+    with TestClient(main.app, base_url="https://testserver") as c:
+        assert c.post("/api/logout", headers=headers).status_code == 403
+
+
+def test_valid_origin_and_explicit_public_origin(monkeypatch):
+    with TestClient(main.app, base_url="https://testserver") as c:
+        monkeypatch.setattr(config, "PUBLIC_URL", "")
+        assert c.post("/api/logout", headers={"Origin": "https://testserver:443"}).status_code == 200
+        monkeypatch.setattr(config, "PUBLIC_URL", "https://public.hf.space")
+        assert c.post("/api/logout", headers={"Origin": "https://public.hf.space"}).status_code == 200
+
+
+def test_personal_api_responses_are_not_cached():
+    with TestClient(main.app, base_url="https://testserver") as c:
+        assert c.get("/api/runs").headers["cache-control"] == "private, no-store"
+        assert c.get("/api/me").headers["cache-control"] == "private, no-store"
+
+
+@pytest.mark.parametrize("bad", [".", "..", "x\n", "x/y", "%2e%2e", "//elsewhere"])
+def test_path_parameters_cannot_change_the_published_route(bad):
+    info = {"api": [{"method": "GET", "path": "/tasks/{id}", "params": ["id"]}]}
+    with pytest.raises(live.SpaceError):
+        live.route_url(info, "GET", "/tasks/{id}", {"id": bad})
+
+
+def test_upstream_body_is_stopped_before_it_is_fully_buffered(monkeypatch):
+    monkeypatch.setattr(live, "MAX_REPLY", 64 * 1024)
+    reads = []
+
+    class Stream(httpx.SyncByteStream):
+        def __iter__(self):
+            for i in range(100):
+                reads.append(i)
+                yield b"x" * 64 * 1024
+
+    with live.SpaceClient(transport=httpx.MockTransport(lambda r: httpx.Response(200, stream=Stream()))) as c:
+        with pytest.raises(live.SpaceError, match="too large"):
+            c.get("https://fixture.hf.space/")
+    assert len(reads) <= 3
+
+
+def test_gzip_reply_is_decoded_once_and_limited(monkeypatch):
+    monkeypatch.setattr(live, "MAX_REPLY", 1024)
+    def response(r):
+        return httpx.Response(200, content=gzip.compress(b'{"ok":true}'), headers={"Content-Encoding": "gzip"})
+    with live.SpaceClient(transport=httpx.MockTransport(response)) as c:
+        assert c.get("https://fixture.hf.space/").json() == {"ok": True}
+    with live.SpaceClient(transport=httpx.MockTransport(lambda r: httpx.Response(200, content=gzip.compress(b"x" * 2048), headers={"Content-Encoding": "gzip"}))) as c:
+        with pytest.raises(live.SpaceError, match="too large"):
+            c.get("https://fixture.hf.space/")
+
+
+def test_disconnected_episode_is_not_silently_replaced(monkeypatch):
+    s = live.Session("fixture/env", "owner")
+    class Socket:
+        def send(self, message): pass
+        def recv(self, timeout): raise TimeoutError
+        def close(self): pass
+    s.ws = Socket()
+    with pytest.raises(live.SpaceError) as error:
+        live._ws_send(s, {"type": "step", "data": {}}, 1)
+    assert error.value.status == 504
+    monkeypatch.setattr(live, "_open", lambda s: pytest.fail("must not create a replacement episode"))
+    with pytest.raises(live.SpaceError) as error:
+        live._ws_send(s, {"type": "step", "data": {}}, 1)
+    assert error.value.status == 410
+
+
+@pytest.mark.parametrize("value", [float("nan"), float("inf"), -float("inf"), 1.5])
+def test_rollout_limits_reject_non_finite_and_fractional_values(value):
+    with pytest.raises(ValueError):
+        runner._check_fields([{"key": "steps", "type": "number", "step": 1, "min": 1, "max": 100}], {"steps": value})
+
+
+def test_raw_file_names_are_unicode_safe_and_cannot_inject_headers(monkeypatch):
+    monkeypatch.setattr(main.registry, "raw", lambda *a: (b"hello", "text/plain"))
+    c = TestClient(main.app, base_url="https://testserver")
+    for name in ['文件.txt', 'x\r\nInjected: true.txt']:
+        r = c.get('/api/env/org/ds/raw', params={"ref": "train/0", "f": name, "download": "true"})
+        assert r.status_code == 200
+        assert r.headers['content-disposition'].startswith("attachment; filename*=UTF-8''")
+        assert '\r' not in r.headers['content-disposition'] and '\n' not in r.headers['content-disposition']
+        assert 'Injected' not in r.headers
+        assert r.headers['content-security-policy'] == 'sandbox'
+
+
+def test_query_parameters_survive_route_discovery_and_are_encoded():
+    api = {"paths": {"/tasks/{id}": {"parameters": [{"name": "split", "in": "query", "required": True, "schema": {"type": "string"}}],
+          "get": {"parameters": [{"name": "limit", "in": "query", "schema": {"type": "integer", "default": 10}}]}}}}
+    info = {"api": live._api_routes(api, False)}
+    schema = info["api"][0]["query_schema"]
+    assert schema["required"] == ["split"] and schema["properties"]["limit"]["default"] == 10
+    assert live.route_url(info, "GET", "/tasks/{id}", {"id": "a"}, {"split": "x&admin=true"}) == '/tasks/a?split=x%26admin%3Dtrue'
+    with pytest.raises(live.SpaceError, match='required'):
+        live.route_url(info, "GET", "/tasks/{id}", {"id": "a"})
+    with pytest.raises(live.SpaceError, match='published'):
+        live.route_url(info, "GET", "/tasks/{id}", {"id": "a"}, {"url": "https://evil.example"})
+
+
+def test_mcp_routes_separate_body_path_and_query_and_keep_grading_routes(monkeypatch):
+    from app import mcp_bridge
+    api = {"paths": {"/verify/{id}": {"post": {
+        "parameters": [{"name": "id", "in": "query", "schema": {"type": "string"}}],
+        "requestBody": {"required": True, "content": {"application/json": {"schema": {"type": "object", "properties": {"id": {"type": "integer"}}, "required": ["id"]}}}},
+    }}}}
+    info = {"api": live._api_routes(api, False), "mcp": [{"name": "look", "inputSchema": {"type": "object"}}]}
+    tools = {t['name']: t for t in mcp_bridge._tools(info)}
+    assert {'look', 'verify_id'} == set(tools)
+    assert set(tools['verify_id']['inputSchema']['properties']) == {'path_params', 'query', 'body'}
+    captured = []
+    monkeypatch.setattr(mcp_bridge, '_play', lambda *a: 'session')
+    monkeypatch.setattr(live, 'act', lambda *args: captured.append(args[-1]) or {'result': {'json': {'reward': 1}, 'status': 200}})
+    args = {"path_params": {"id": "path-id"}, "query": {"id": "query-id"}, "body": {"id": 42}}
+    mcp_bridge._call('o/s', info, {"owner": "owner"}, 'verify_id', args)
+    assert captured[0]['params'] == args['path_params'] and captured[0]['body'] == args['body'] and captured[0]['query'] == args['query']
+
+
+def test_mcp_rate_limiter_does_not_accumulate_rejected_requests():
+    from app import mcp_bridge
+    owner = 'rate-regression'
+    for _ in range(mcp_bridge.RATE[0] * 3):
+        mcp_bridge._limited(owner)
+    assert len(mcp_bridge._hits[owner]) == mcp_bridge.RATE[0]
+    mcp_bridge._hits.pop(owner)

tests/test_auto_index.py

@@ -0,0 +1,86 @@
+import gzip
+import json
+import time
+
+import pytest
+
+from app import auto_index, config, indexer, snapshot
+
+
+@pytest.fixture(autouse=True)
+def storage(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "STORAGE_DIR", tmp_path)
+    monkeypatch.setattr(config, "CACHE_DIR", tmp_path / "cache")
+    monkeypatch.setenv("RLX_SNAPSHOT_STORE", str(tmp_path))
+
+
+def test_recent_full_listing_is_reused_without_extending_discovery_age(monkeypatch):
+    at = time.time() - 300
+    rows = [{"id": "owner/env", "kind": "dataset"}]
+    (config.STORAGE_DIR / "listing.json.gz").write_bytes(gzip.compress(json.dumps({"at": at, "full": True, "rows": rows}).encode()))
+    called = []
+    def run(store, **kwargs):
+        called.append(kwargs)
+        return {"counts": {"envs": 1, "tasks": 2}}
+    monkeypatch.setattr(indexer, "run", run)
+    auto_index.cycle()
+    assert called == [{"rows": rows, "listing_at": at, "budget_s": 90, "max_builds": 4}]
+    assert auto_index.status()["state"] == "idle"
+    assert auto_index.status()["last_success"] >= at
+    auto_index.cycle()
+    assert len(called) == 1  # app restarts and duplicate workers honor cadence
+    assert auto_index.cached_listing(at + 3601) == (None, None)
+    assert auto_index.cached_listing(at - 1) == (None, None)
+
+
+def test_locked_worker_cannot_publish_duplicate_snapshot(monkeypatch):
+    fcntl = pytest.importorskip("fcntl")
+    config.CACHE_DIR.mkdir()
+    monkeypatch.setattr(indexer, "run", lambda *a, **k: pytest.fail("duplicate indexer"))
+    with (config.CACHE_DIR / "auto-index.lock").open("a") as lease:
+        fcntl.flock(lease, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        auto_index.cycle()
+    assert auto_index.status() == {}
+
+
+def test_failure_preserves_published_pointer_and_backs_off(monkeypatch):
+    store = snapshot.open_store()
+    store.put_bytes(snapshot.POINTER, b"last-good-snapshot")
+    def fail(*a, **k):
+        raise ConnectionError("upstream response must not enter public status")
+    monkeypatch.setattr(indexer, "run", fail)
+    auto_index.cycle()
+    first = auto_index.status()
+    assert first["state"] == "retrying" and first["error"] == "ConnectionError"
+    assert first["next_at"] > time.time() + 590
+    assert store.read_bytes(snapshot.POINTER) == b"last-good-snapshot"
+    auto_index._save({**first, "next_at": 0})
+    auto_index.cycle()
+    assert auto_index.status()["failures"] == 2
+    assert auto_index.status()["next_at"] > time.time() + 1190
+
+
+def test_missing_or_partial_listing_requires_fresh_discovery():
+    assert auto_index.cached_listing(time.time()) == (None, None)
+    doc = {"at": time.time(), "full": False, "rows": [{"id": "owner/partial"}]}
+    (config.STORAGE_DIR / "listing.json.gz").write_bytes(gzip.compress(json.dumps(doc).encode()))
+    assert auto_index.cached_listing(time.time()) == (None, None)
+
+
+def test_shutdown_terminates_only_owned_indexer_child(monkeypatch):
+    calls = []
+    class Child:
+        def poll(self): return None
+        def terminate(self): calls.append("terminate")
+        def wait(self, **kwargs): calls.append("wait")
+    def popen(command, **kwargs):
+        assert command[-2:] == ["-m", "app.auto_index"]
+        assert kwargs["env"]["HF_HUB_DISABLE_IMPLICIT_TOKEN"] == "1"
+        return Child()
+    monkeypatch.setattr(auto_index.subprocess, "Popen", popen)
+    auto_index._stop.set()
+    try:
+        auto_index._child()
+    finally:
+        auto_index._stop.clear()
+    assert calls == ["terminate", "wait"]

tests/test_capabilities.py

@@ -0,0 +1,68 @@
+"""Support claims reflect runtime evidence, not a source's framework tag."""
+import pytest
+
+from app import spaces_live as live
+from app.envs.capabilities import dataset_support, space_support
+
+
+def state(support, feature):
+    return next(c["state"] for c in support["capabilities"] if c["id"] == feature)
+
+
+@pytest.mark.parametrize("framework,runner", [("Verifiers", "verifiers"), ("NeMo Gym", "nemo-gym"), ("verl", "verl"), ("SkyRL", "skyrl")])
+def test_native_framework_dataset_does_not_claim_local_execution(framework, runner):
+    support = dataset_support(framework, options=[{"runner": runner, "label": framework, "ok": False, "why": "Use its native harness"}])
+    assert state(support, "browse") == "available"
+    assert state(support, "run") == "external"
+    assert support["framework"]["docs"].startswith("https://")
+
+
+def test_task_support_distinguishes_blocked_from_runnable():
+    options = [{"runner": "harbor", "label": "Harbor", "ok": False, "why": "GPU required"}]
+    assert state(dataset_support("Harbor", options=options), "run") == "unavailable"
+    options[0]["ok"] = True
+    assert state(dataset_support("Harbor", options=options), "run") == "available"
+    assert state(dataset_support("Harbor"), "run") == "unknown"
+
+
+def test_sleeping_server_never_claims_live_capabilities():
+    s = space_support({"running": False, "stage": "SLEEPING", "last_seen": {"step_api": True}})
+    assert state(s, "play") == "unknown"
+    assert s["transport"] is None
+
+
+@pytest.mark.parametrize("protocol", ["openenv", "gymnasium", "nemo-gym", "mcp", "api"])
+def test_probe_uses_published_protocol_not_reset_route_or_tag(monkeypatch, protocol):
+    from app import catalog
+    catalog._memo.clear()
+    rec = {"id": "fixture/env", "stage": "RUNNING", "host": "https://fixture-env.hf.space", "base_path": None, "tags": ["openenv"]}
+    monkeypatch.setattr(live, "record", lambda *a, **k: rec)
+    paths = {"/reset": {"post": {}}, "/step": {"post": {}}} if protocol in {"openenv", "gymnasium"} else (
+        {"/seed_session": {"post": {}}, "/verify": {"post": {}}} if protocol == "nemo-gym" else {"/mcp": {"post": {}}} if protocol == "mcp" else {"/guess": {"post": {}}})
+    docs = {"/openapi.json": {"info": {"version": "1"}, "paths": paths}}
+    if protocol == "openenv":
+        docs["/schema"] = {k: {"type": "object", "properties": {}} for k in ("action", "observation", "state")}
+    monkeypatch.setattr(live, "_get_json", lambda rec, path: docs.get(path))
+    monkeypatch.setattr(live, "_ui_path", lambda rec: None)
+    monkeypatch.setattr(live, "_tools", lambda rec: ([{"name": "guess"}] if protocol == "mcp" else [], None, {}))
+    monkeypatch.setattr(live, "remember", lambda *a: None)
+    info = live.probe("fixture/env")
+    assert info["framework"] == protocol
+    assert info["openenv"] is (protocol == "openenv")
+    assert info["step_api"] is (protocol == "openenv")
+    if protocol == "gymnasium":
+        assert {r["path"] for r in info["api"]} == {"/reset", "/step"}
+        assert info["support"]["transport"] == "http"
+    assert state(info["support"], "play") == "available"
+
+
+def test_private_dataset_does_not_offer_public_mcp():
+    assert state(dataset_support("Harbor", restricted=True), "mcp") == "unavailable"
+
+
+def test_packed_harbor_rows_keep_the_harbor_lifecycle():
+    assert dataset_support("Harbor (packed)")["framework"]["id"] == "harbor"
+
+
+def test_unknown_runner_is_not_claimed_as_hosted():
+    assert state(dataset_support("Custom", options=[{"runner": "custom", "label": "Custom", "ok": True}]), "run") == "unavailable"

tests/test_community.py

@@ -0,0 +1,96 @@
+import json
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app import auth, community, main, settings, store
+
+client = TestClient(main.app)
+
+
+def record(id, runner="harbor", **fields):
+    return {"id": id, "dataset": f"org/{runner}", "path": "task/1", "title": "A task", "user": "hidden-user",
+            "runner": runner, "status": "done", "reward": 1, "visibility": "public", "model": "org/model",
+            "created_at": 10, **fields}
+
+
+@pytest.fixture
+def records(monkeypatch):
+    rows = [record("harbor", reward=-3, dataset="a/same"), record("mimo", "mimo", domain="code", reward=0.25),
+            record("nemo", "nemo-gym", reward=1, dataset="b/same"), record("future", "custom-runtime", reward=20),
+            record("private", visibility="private"), record("restricted", restricted=True),
+            record("failed", status="failed", reward=None), record("hidden")]
+    monkeypatch.setattr(store, "list_runs", lambda **kw: rows)
+    monkeypatch.setattr(store, "has_artifact", lambda *a: False)
+    monkeypatch.setattr(settings, "get", lambda key, default=None: ["hidden"] if key == "hidden_runs" else default)
+    return rows
+
+
+def test_all_saved_runners_share_the_feed_with_scoped_counts(records):
+    data = client.get("/api/community").json()
+    assert {r["id"] for r in data["runs"]} == {"harbor", "mimo", "nemo", "future"}
+    assert data["total"] == data["stats"]["runs"] == 4
+    assert data["stats"]["datasets"] == data["stats"]["runners"] == 4
+    assert not data["stats"]["comparable"]
+    assert "mean" not in data["stats"]  # no meaningless global reward average
+    assert {r["group"] for r in data["runs"]} >= {"a/same", "b/same"}
+    assert "hidden-user" not in json.dumps(data)
+    for runner in ("harbor", "mimo", "nemo-gym", "custom-runtime"):
+        subset = client.get("/api/community", params={"runner": runner}).json()
+        assert subset["total"] == subset["stats"]["runs"] == subset["stats"]["datasets"] == 1
+        assert {r["runner"] for r in subset["runs"]} == {runner}
+        assert len(subset["facets"]["runner"]) == 4  # own facet retains alternatives
+        assert len(subset["facets"]["dataset"]) == 1
+
+
+def test_search_includes_environment_runner_and_model_and_empty_counts(records):
+    for query, expected in (("b/same", "nemo"), ("nemo-gym", "nemo"), ("org/mimo model", "mimo")):
+        data = client.get("/api/community", params={"q": query}).json()
+        assert [r["id"] for r in data["runs"]] == [expected]
+    empty = client.get("/api/community?dataset=nobody/missing").json()
+    assert empty["total"] == empty["stats"]["datasets"] == empty["stats"]["models"] == empty["stats"]["runners"] == 0
+    assert empty["stats"]["results"] == []
+
+
+def test_reward_summaries_separate_metrics_domains_judges_and_revisions():
+    rows = [record("a", reward=-4), record("b", reward=-2)]
+    for field, value in (("reward_key", "latency"), ("domain", "code"), ("judge", "judge/new"), ("sha", "new-revision")):
+        rows.append(record(field, reward=100, **{field: value}))
+    data = community.stats(rows)
+    assert len(data["results"]) == 5
+    original = next(r for r in data["results"] if r["runs"] == 2)
+    assert original["mean"] == -3 and original["max"] == -2
+    assert community.stats([record("a", reward=1e308), record("b", reward=1e308)])["results"][0]["mean"] == 1e308
+
+
+@pytest.mark.parametrize("value", [None, "1", True, {}, float("nan"), float("inf"), 10**1000])
+def test_invalid_rewards_cannot_break_or_enter_public_feed(value, monkeypatch):
+    monkeypatch.setattr(settings, "get", lambda *a: [])
+    assert not main._shareable(record("bad", reward=value))
+
+
+def test_pagination_sort_and_negative_reward_band(records):
+    records.extend(record(f"r{i:02}", created_at=i, reward=-i, cost={"total": None}) for i in range(20))
+    all_rows = client.get("/api/community?sort=reward_asc").json()["runs"]
+    pages = [client.get("/api/community", params={"sort": "reward_asc", "offset": i, "limit": 5}).json()["runs"] for i in range(0, 24, 5)]
+    assert [r["id"] for page in pages for r in page] == [r["id"] for r in all_rows]
+    negative = client.get("/api/community?reward=zero").json()
+    assert negative["total"] == 21 and all(r["reward"] <= 0 for r in negative["runs"])
+    assert client.get("/api/community?sort=cost_asc").status_code == 200
+
+
+@pytest.mark.parametrize("runner,domain,events", [("harbor", None, False), ("mimo", "code", True), ("nemo-gym", "nemo-gym", True), (None, "code", True)])
+def test_trace_routes_match_runner_and_keep_public_scrubbing(monkeypatch, runner, domain, events):
+    from app.mimo.runner import core
+    r = record("trace", runner, domain=domain)
+    monkeypatch.setattr(store, "get", lambda id: r)
+    monkeypatch.setattr(settings, "get", lambda *a: [])
+    monkeypatch.setattr(auth, "current_user", lambda request: None)
+    monkeypatch.setattr(store, "read_artifact", lambda *a: b'[{"content":"hidden-user"}]')
+    monkeypatch.setattr(main.runner, "is_live", lambda *a: False)
+    monkeypatch.setattr(core, "live", lambda *a: None)
+    monkeypatch.setattr(core, "events", lambda *a: [{"content": "hidden-user"}])
+    response = client.get("/api/runs/trace")
+    assert response.status_code == 200 and "hidden-user" not in response.text
+    assert ("events" in response.json()) == events
+    assert response.json()["run"]["runner"] == (runner or "mimo")

tests/test_deploy_spaces.py

@@ -0,0 +1,12 @@
+from scripts import deploy_spaces
+
+
+def test_upload_manifest_excludes_local_secrets_and_symlinks(tmp_path, monkeypatch):
+    for name in ('app/main.py','web/app.css','.env','.env.production','sub/.env.local','sub/private.key','.local-data/run.json','.venv/env.py'):
+        path=tmp_path/name
+        path.parent.mkdir(parents=True,exist_ok=True)
+        path.write_text('sample')
+    (tmp_path/'linked.py').symlink_to(tmp_path/'.env')
+    (tmp_path/'linked-dir').symlink_to(tmp_path/'.local-data',target_is_directory=True)
+    monkeypatch.setattr(deploy_spaces,'ROOT',tmp_path)
+    assert deploy_spaces.files()==['app/main.py','web/app.css']

tests/test_discovery.py

@@ -0,0 +1,69 @@
+"""Discovery evidence is metadata, not a runtime attestation or an editorial decision."""
+from types import SimpleNamespace
+
+import pytest
+from huggingface_hub import SpaceInfo
+
+from app import catalog
+
+
+def space(sid="org/env", *, tags=(), files=(), **kw):
+    return SpaceInfo(id=sid, sdk="docker", private=False, tags=list(tags), likes=0,
+                     siblings=[{"rfilename": f} for f in files], **kw)
+
+
+@pytest.mark.parametrize("files", [("openenv.yaml",), ("my_env/openenv.yml",)])
+def test_manifest_discovery(files):
+    d = catalog._space_summary(space(files=files))
+    assert d["openenv"] and d["manifest"] == files[0]
+
+
+@pytest.mark.parametrize("file", ["src/openenv.yaml", "templates/openenv.yaml", "examples/openenv.yaml",
+                                 "build/openenv.yaml", "vendor/openenv.yaml", "envs/echo/openenv.yaml",
+                                 "src/openenv/cli/templates/openenv.yaml", ".venv/openenv.yaml"])
+def test_vendored_manifests_are_not_declarations(file):
+    d = catalog._space_summary(space(files=[file]))
+    assert not d["openenv"] and d["manifest"] is None
+
+
+@pytest.mark.parametrize("tag", ["openenv", "library:openenv", "openenv-0.7.0"])
+def test_tag_only_remains_a_candidate_without_a_manifest(tag):
+    d = catalog._space_summary(space(tags=[tag]))
+    assert d["openenv"] and d["manifest"] is None
+
+
+def test_names_and_generic_rl_mcp_tags_do_not_establish_openenv():
+    d = catalog._space_summary(space("openenv/not-an-env", tags=["rl-environment", "mcp-server"]))
+    assert not d["openenv"] and d["mcp"]
+
+
+def test_space_census_deduplicates_and_applies_visibility_to_featured(monkeypatch):
+    good = space(tags=["openenv"])
+    article = space("org/article", tags=["openenv", "research-article-template"])
+    private = space("org/private"); private.private = True
+    static = space("org/static"); static.sdk = "static"
+    by = {s.id: s for s in [good, article, private, static]}
+    monkeypatch.setattr(catalog, "collections", lambda: [{"ids": [f"space:{s}" for s in by]}])
+    monkeypatch.setattr(catalog, "_api", lambda: SimpleNamespace(list_spaces=lambda **kw: iter(by.values()),
+                                                               space_info=lambda sid, **kw: by[sid]))
+    assert [r["id"] for r in catalog.spaces()] == [good.id]
+
+
+def test_failed_full_census_is_not_silently_published(monkeypatch):
+    def listing(**kw):
+        yield space(tags=["openenv"])
+        raise ConnectionError("page two unavailable")
+
+    monkeypatch.setattr(catalog, "collections", lambda: [])
+    monkeypatch.setattr(catalog, "_api", lambda: SimpleNamespace(list_spaces=listing))
+    with pytest.raises(ConnectionError):
+        catalog.spaces(full=True)
+    assert len(catalog.spaces(full=False)) == 1   # a quick bootstrap may serve candidates while refreshing
+
+
+def test_collection_never_reclassifies_framework(monkeypatch):
+    d = catalog._space_summary(space(tags=["ors"]))
+    monkeypatch.setattr(catalog, "_listing_rows", lambda: [d])
+    monkeypatch.setattr(catalog, "collections", lambda: [{"id": "fineenvs", "ids": [d["key"]]}])
+    monkeypatch.setattr(catalog, "hidden", lambda: set())
+    assert catalog.environments()[0]["framework"] == "ors"

tests/test_frameworks.py

@@ -135,7 +135,9 @@ def test_nemo_gym_pivot_row_reads_as_a_conversation_and_hides_the_experts_next_s
     assert "--agent toolcall_schema_single_step_tool_use_with_argument_comparison_agent" in run and "gym eval run --no-serve" in run
     assert "--repo-id nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1" in run and "sed -n '1p'" in run
     opt = view["framework_run"]
-    assert opt["runner"] == "nemo-gym" and opt["ok"] is False and "NeMo Gym" in opt["why"]
+    # This browsing fixture mixes Chat Completions and Responses tool formats;
+    # execution requires the dataset's native Responses function definitions.
+    assert opt["runner"] == "nemo-gym" and opt["ok"] is False and "native NeMo Gym" in opt["why"]
     assert ["Step", "turn 6 · step 1"] in view["glance"] and card["chips"][0] == "turn 6 · step 1"
 
 
@@ -210,6 +212,8 @@ def test_nemo_gym_blends_route_each_row_and_run_without_one_agent():
 def test_nemo_gym_catalog_is_current_and_complete():
     cat = nemogym.catalog()
     assert len(cat["commit"]) == 40 and len(cat["agents"]) > 100 and len(cat["servers"]) > 100
+    assert cat["servers"]["instruction_following"]["verification"] == "Rule-based instruction checks"
+    assert cat["servers"]["math_proof_judgement"]["verification"] == "Deterministic answer parsing"
     for name in ("mcqa_simple_agent", "workplace_assistant_simple_agent", "calendar_simple_agent", "code_gen_simple_agent",
                  "instruction_following_simple_agent", "reasoning_gym_simple_agent"):
         a = cat["agents"][name]
@@ -406,3 +410,11 @@ def test_search_never_finds_a_row_through_its_withheld_answer(monkeypatch):
     files = rows.Files.__new__(rows.Files)
     monkeypatch.setattr(rows.Files, "_scan", lambda self, c, s, o, match, what: ({"rows": [h for h in found if match(h[1])]}, None))
     assert [i for i, _, _ in files.search("d", "train", "7", 0)[0]["rows"]] == []
+
+
+def test_verifiers_v1_taskdata_system_prompt_is_part_of_the_conversation():
+    row = {"prompt": "Solve the task", "system_prompt": "Use the supplied tools", "answer": "PRIVATE_REFERENCE"}
+    view, _, _, _, text = everything(verifiers_rows.Verifiers(), row, tags=["verifiers"])
+    turns = next(s for s in view["sections"] if s["id"] == "task")["body"][0]["data"]["turns"]
+    assert [(t["role"], t["text"]) for t in turns] == [("system", "Use the supplied tools"), ("user", "Solve the task")]
+    assert "PRIVATE_REFERENCE" not in text

tests/test_live.py

@@ -352,7 +352,7 @@ OPENAPI = {"paths": {
 
 def test_routes_are_plain_paths_on_non_openenv_servers_only():
     routes = live._api_routes(OPENAPI, openenv=False)
-    assert {(r["method"], r["path"]) for r in routes} == {("POST", "/guess"), ("GET", "/tasks/{task_id}"), ("POST", "/self")}
+    assert {(r["method"], r["path"]) for r in routes} == {("POST", "/guess"), ("GET", "/tasks/{task_id}"), ("POST", "/self"), ("POST", "/reset")}
     guess = next(r for r in routes if r["path"] == "/guess")
     assert guess["schema"]["properties"]["word"] == {"type": "string", "title": "Word"} and guess["schema"]["required"] == ["word"]
     assert next(r for r in routes if r["path"] == "/tasks/{task_id}")["params"] == ["task_id"]
@@ -383,8 +383,8 @@ def test_route_calls_keep_their_cookies_and_withhold_answers_from_gets(monkeypat
             return httpx.Response(200, json={"output": "ok"}, headers={"set-cookie": "session=abc; path=/"})
         return httpx.Response(200, json={"task_id": "t1", "prompt": "p", "answer": "SECRET", "meta": {"ground_truth": "TRUTHVAL"}})
 
-    real = httpx.Client
-    monkeypatch.setattr(live.httpx, "Client", lambda **kw: real(transport=httpx.MockTransport(handler), **kw))
+    real = live.SpaceClient
+    monkeypatch.setattr(live, "SpaceClient", lambda **kw: real(transport=httpx.MockTransport(handler), **kw))
     sid = live.start("org/env", "web:a")["session"]
     out = live.act(sid, "web:a", "http", {"method": "POST", "path": "/guess", "body": {"word": "crane"}})["result"]
     assert out["status"] == 200 and out["json"] == {"output": "ok"}
@@ -397,7 +397,7 @@ def test_route_calls_keep_their_cookies_and_withhold_answers_from_gets(monkeypat
 
 def test_a_reset_step_server_still_lists_its_tools(monkeypatch):
     """No MCP tools of its own (OpenEnv answers "Environment does not support MCP"): the page gets exactly what the MCP
-    bridge offers an agent, step taking the server's own action fields. A tool server gets nothing added."""
+    bridge offers an agent, step taking the server's own action fields. Tool servers use the same descriptor."""
     info = {"running": True, "stage": "RUNNING", "step_api": True, "mcp": None, "task_api": None,
             "schema": {"action": {"type": "object", "properties": {"latex": {"type": "string", "description": "Predicted LaTeX"}}, "required": ["latex"]}}}
     monkeypatch.setattr(live, "probe", lambda spec, fresh=False: info)
@@ -406,4 +406,4 @@ def test_a_reset_step_server_still_lists_its_tools(monkeypatch):
     assert "latex" in json.dumps(tools["step"]["inputSchema"])
     assert tools == {t["name"]: t for t in mcp_bridge._tools(info)}   # the page and the bridge never disagree
     monkeypatch.setattr(live, "probe", lambda spec, fresh=False: {**info, "mcp": [{"name": "look", "inputSchema": {"type": "object"}}]})
-    assert "bridge_tools" not in client.get("/api/spaces/o/geo/live").json()
+    assert {t["name"] for t in client.get("/api/spaces/o/geo/live").json()["bridge_tools"]} == {"look", "reset", "state"}