Deploy HF RL Explorer

.gitignore

@@ -3,3 +3,12 @@ __pycache__/
 .venv/
 .gradio/
 .ruff_cache/
+
+# Admin implementation is maintained outside this public repository.
+web-admin/
+app/admin.py
+app/admin_app.py
+app/admin_access.py
+tests/test_admin*.py
+ADMIN_SPACE_README.md
+EXPLORER_AUDIT.md

DESIGN.md

@@ -235,3 +235,10 @@ HF scheduled Job, hourly (scripts/schedule_indexer.py)          Explorer / admin
 5. **Smoke tests on the Space**: `/readyz`; `scripts/check_judge_relay.py`'s path through the Space's `/capture`
    (a model-graded rollout, e.g. a MiMo General twin with Inkling as judge: reward recorded, `judge_calls > 0`);
    `node tests/ui-audit.mjs https://<space>`.
+
+## Admin source boundary
+
+This public tooling directory contains only the Explorer. The dashboard application,
+its assets, membership checks, tests and deployment tooling are maintained separately
+in the private `FineEnvs/RL-Explorer-admin` Space. The Explorer reads shared settings
+and moderation requests from the data bucket without importing the admin app.

Dockerfile

@@ -1,4 +1,4 @@
-# HF RL Explorer as a Docker Space; the same image runs its admin Space with RLX_APP=app.admin_app:app.
+# Public HF RL Explorer Docker Space. The admin has a separate private deployment.
 #   /data         the private bucket FineEnvs/rl-explorer-data: indexes, packs, rollouts, admin settings; mounted by both
 #   /tmp/...      dataset files read while indexing and the tasks rollouts run on: many small files, local disk
 #   abcmidi       the MiMo release's music scorer renders a piece with abc2midi (app/mimo/vendor/music_scorer)

app/admin.py

@@ -1,379 +0,0 @@
-"""The admin dashboard's API, served by its own app (app/admin_app.py) on its own private Space, for members of the
-admin organization only (see app/settings.py). Every route checks the signed-in user against the organization on
-every request. Every change is written to the audit log with who made it.
-
-The admin app shares the explorer's bucket but not its process. It reads the run records the explorer writes, and
-what it changes goes into the shared settings file, which the explorer re-reads: collections, pins, hidden
-environments, the rollout switches, rollouts taken off Community, and requests to stop a running rollout.
-"""
-
-from __future__ import annotations
-
-import gzip
-import json
-import re
-import time
-from collections import Counter
-from typing import Any, Literal
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel, Field
-
-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
-
-router = APIRouter(prefix="/api/admin")
-KEY = re.compile(r"^(space:)?[A-Za-z0-9][\w.-]*/[\w.-]+$")
-
-
-def _admin(request: Request) -> dict[str, Any]:
-    u = auth.current_user(request)
-    if not u:
-        raise HTTPException(401, "sign in")
-    if not settings.is_admin(u):
-        raise HTTPException(403, f"only members of {settings.ADMIN_ORG} can open the admin dashboard")
-    return u
-
-
-# ── overview ─────────────────────────────────────────────────────────────────
-@router.get("/overview")
-def overview(request: Request):
-    _admin(request)
-    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(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(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)]
-                                for i in range(13, -1, -1)],
-                     "by_model": Counter(r.get("model") or "custom endpoint" for r in runs).most_common(8),
-                     "by_status": Counter(r.get("status") for r in runs).most_common()},
-        "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], "new_count": len(new),
-        "settings": _settings(),
-    }
-
-
-def _ts(iso: str) -> float:
-    from datetime import datetime
-
-    try:
-        return datetime.fromisoformat(iso.replace("Z", "+00:00")).timestamp()
-    except ValueError:
-        return 0.0
-
-
-_avatars: dict[str, tuple[float, str | None]] = {}
-
-
-def avatar(name: str | None) -> str | None:
-    """A Hub user's profile picture, looked up once a day (rollouts started before avatars were recorded have none)."""
-    if not name:
-        return None
-    hit = _avatars.get(name)
-    if hit and time.time() - hit[0] < 86400:
-        return hit[1]
-    import httpx
-
-    url = None
-    try:
-        r = httpx.get(f"https://huggingface.co/api/users/{name}/overview", timeout=6)
-        if r.status_code == 200:
-            url = r.json().get("avatarUrl")
-            url = url if isinstance(url, str) and url.startswith("https://") else None
-    except Exception:  # noqa: BLE001
-        pass
-    _avatars[name] = (time.time(), url)
-    return url
-
-
-def _live(r: dict[str, Any]) -> bool:
-    return r.get("status") in store.ACTIVE and time.time() - (r.get("updated_at") or 0) < STALE
-
-
-def _runs() -> list[dict[str, Any]]:
-    store.refresh(10)   # the explorer writes these; re-read them every few seconds
-    return store.list_runs(limit=100000)
-
-
-def _admin_view(r: dict[str, Any]) -> dict[str, Any]:
-    """A rollout for admins: everything but where a visitor's own endpoint lives."""
-    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", []))
-    return v
-
-
-# ── rollouts ─────────────────────────────────────────────────────────────────
-@router.get("/rollouts")
-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()
-    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 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")
-def cancel(run_id: str, request: Request):
-    """Ask the explorer to stop a running rollout: it watches the settings for these, and stops it within seconds."""
-    u = _admin(request)
-    r = store.get(run_id)
-    if not r:
-        raise HTTPException(404, "no such rollout")
-    asks = {k: v for k, v in settings.get("cancel_requests", {}).items() if time.time() - v < 3600}
-    asks[run_id] = time.time()
-    settings.save(u["name"], {"cancel_requests": asks}, note=f"asked to stop rollout {run_id}")
-    return {"cancelled": _live(r)}
-
-
-class Moderate(BaseModel):
-    hidden: bool
-
-
-@router.post("/rollouts/{run_id}/moderate")
-def moderate(run_id: str, body: Moderate, request: Request):
-    """Take a public rollout off Community (or put it back). Its owner still sees it."""
-    u = _admin(request)
-    r = store.get(run_id)
-    if not r:
-        raise HTTPException(404, "no such rollout")
-    gone = set(settings.get("hidden_runs", []))
-    gone = (gone | {run_id}) if body.hidden else (gone - {run_id})
-    settings.save(u["name"], {"hidden_runs": sorted(gone)}, note=f"{'hid' if body.hidden else 'restored'} rollout {run_id} on Community")
-    return {"run": _admin_view(r)}
-
-
-# ── people ───────────────────────────────────────────────────────────────────
-@router.get("/people")
-def people(request: Request):
-    """Everyone who has run a rollout: how much, how well, on what, and when last."""
-    _admin(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, "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["scored"] += r.get("status") == "done" and community.scalar_reward(r)
-        p["live"] += _live(r)
-        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
-        p["datasets"][r.get("dataset")] += 1
-    out = []
-    for p in sorted(by.values(), key=lambda x: -(x["last"] or 0)):
-        p["avatar"] = p["avatar"] or avatar(p["name"])
-        p["models"], p["datasets"] = p["models"].most_common(3), p["datasets"].most_common(3)
-        out.append(p)
-    return {"people": out, "me": auth.public(auth.current_user(request))}
-
-
-# ── environments: pin, hide, feature, index ──────────────────────────────────
-@router.get("/environments")
-def environments(request: Request):
-    _admin(request)
-    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, "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()}
-
-
-def _jobs() -> dict[str, Any]:
-    with catalog._jobs_lock:
-        return {k: {kk: vv for kk, vv in v.items() if kk not in ("sha",)} for k, v in catalog._jobs.items()
-                if v.get("state") not in ("done",)}
-
-
-class EnvAction(BaseModel):
-    key: str = Field(max_length=220)
-    action: Literal["pin", "unpin", "hide", "unhide", "feature", "unfeature", "index"]
-    collection: str | None = Field(None, max_length=40)
-
-
-@router.post("/environments")
-def env_action(body: EnvAction, request: Request):
-    u = _admin(request)
-    if not KEY.match(body.key):
-        raise HTTPException(400, "not an environment key")
-    key = body.key
-    if body.action in ("pin", "unpin"):
-        pins = [k for k in catalog.pinned() if k != key] + ([key] if body.action == "pin" else [])
-        settings.save(u["name"], {"pinned": pins}, note=f"{body.action} {key}")
-    elif body.action in ("hide", "unhide"):
-        gone = sorted((catalog.hidden() - {key}) | ({key} if body.action == "hide" else set()))
-        settings.save(u["name"], {"hidden": gone}, note=f"{body.action} {key}")
-    elif body.action in ("feature", "unfeature"):
-        cols = [dict(c, ids=[k for k in c["ids"] if k != key]) for c in catalog.collections()]
-        if body.action == "feature":
-            target = next((c for c in cols if c["id"] == body.collection), None)
-            if not target:
-                raise HTTPException(400, "no such collection")
-            target["ids"].append(key)
-        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, "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"}}
-    return {"ok": True}
-
-
-# ── collections ──────────────────────────────────────────────────────────────
-class Collection(BaseModel):
-    id: str = Field(pattern=r"^[a-z][a-z0-9-]{1,30}$")
-    group: str = Field(min_length=1, max_length=40)
-    about: str = Field("", max_length=80)
-    icon: str
-    color: str
-    ids: list[str] = Field(default_factory=list, max_length=80)
-
-
-class Collections(BaseModel):
-    collections: list[Collection] = Field(max_length=20)
-
-
-@router.get("/collections")
-def get_collections(request: Request):
-    _admin(request)
-    return {"collections": catalog.collections(), "icons": catalog.ICONS, "colors": catalog.COLORS}
-
-
-@router.put("/collections")
-def put_collections(body: Collections, request: Request):
-    u = _admin(request)
-    ids = [c.id for c in body.collections]
-    if len(set(ids)) != len(ids):
-        raise HTTPException(400, "two collections share an id")
-    for c in body.collections:
-        if c.icon not in catalog.ICONS or c.color not in catalog.COLORS:
-            raise HTTPException(400, f"{c.group}: pick an icon and a colour from the lists")
-        bad = [k for k in c.ids if not KEY.match(k)]
-        if bad:
-            raise HTTPException(400, f"{c.group}: not environment ids: {', '.join(bad[:3])}")
-    settings.save(u["name"], {"collections": [c.model_dump() for c in body.collections]}, note="edited collections")
-    return {"collections": catalog.collections()}
-
-
-# ── settings ─────────────────────────────────────────────────────────────────
-def _settings() -> dict[str, Any]:
-    return {"rollouts_enabled": settings.get("rollouts_enabled", True),
-            "max_active": settings.get("max_active", config.MAX_ACTIVE_ROLLOUTS),
-            "max_per_user": settings.get("max_per_user", config.MAX_ACTIVE_PER_USER),
-            "agents": settings.get("agents", [a["id"] for a in runner.AGENTS]),
-            "announcement": settings.get("announcement", ""),
-            "all_agents": runner.AGENTS, "admin_org": settings.ADMIN_ORG}
-
-
-class SettingsIn(BaseModel):
-    rollouts_enabled: bool
-    max_active: int = Field(ge=1, le=200)
-    max_per_user: int = Field(ge=1, le=20)
-    agents: list[str] = Field(max_length=20)
-    announcement: str = Field("", max_length=280)
-
-
-@router.get("/settings")
-def get_settings(request: Request):
-    _admin(request)
-    return _settings()
-
-
-@router.put("/settings")
-def put_settings(body: SettingsIn, request: Request):
-    u = _admin(request)
-    if any(a not in runner.AGENT_IDS for a in body.agents):
-        raise HTTPException(400, "unknown agent")
-    settings.save(u["name"], body.model_dump(), note="changed settings")
-    return _settings()
-
-
-# ── audit and storage ────────────────────────────────────────────────────────
-@router.get("/audit")
-def audit(request: Request, limit: int = 200):
-    _admin(request)
-    return {"entries": settings.audit(max(1, min(limit, 1000)))}
-
-
-@router.get("/indexes")
-def indexes(request: Request):
-    _admin(request)
-    out = []
-    for f in sorted(config.INDEX_DIR.glob("*.json.gz")):
-        head = {}
-        try:
-            head = json.loads(f.with_name(f.name.replace(".json.gz", ".head.json")).read_text())
-        except (OSError, ValueError):
-            try:
-                idx = json.loads(gzip.decompress(f.read_bytes()))
-                head = {"tasks": len(idx.get("tasks") or []), "version": idx.get("version"), "built": idx.get("built")}
-            except (OSError, ValueError):
-                pass
-        pack = config.PACK_DIR / f.name
-        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(), "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

@@ -1,79 +0,0 @@
-"""The HF RL Explorer admin: its own app, deployed as its own private Space, for members of the admin organization.
-
-    uv run uvicorn app.admin_app:app --port 8061      # locally, next to the explorer on 8060
-
-It mounts the same bucket as the explorer (/data on the Space) and shares nothing else with it: no process, no
-cookies (another origin), no rollout threads. What it changes goes into the bucket's settings file, which the
-explorer re-reads (see app/admin.py). The Space being private already limits it to the organization; every API
-route checks membership again.
-"""
-
-from __future__ import annotations
-
-import os
-
-from fastapi import FastAPI, Request
-from fastapi.middleware.gzip import GZipMiddleware
-from fastapi.responses import FileResponse
-from fastapi.staticfiles import StaticFiles
-
-from . import admin, auth, config, http, settings, version
-
-# where the public explorer is, for links to its datasets, Spaces and rollouts
-EXPLORER = os.environ.get("RLX_EXPLORER_URL", "http://localhost:8060" if config.LOCAL_MODE else "https://fineenvs-rl-explorer.hf.space").rstrip("/")
-
-app = FastAPI(title="HF RL Explorer admin", docs_url=None, redoc_url=None, openapi_url=None)
-app.include_router(auth.router)
-app.include_router(admin.router)
-app.add_middleware(GZipMiddleware, minimum_size=2048, compresslevel=5)
-http.install(app)
-ADMIN_WEB = config.ROOT / "web-admin"
-
-
-@app.on_event("startup")
-def _startup() -> None:
-    import threading
-
-    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
-    snapshot.start()
-    threading.Thread(target=lambda: search_api.environments(include_hidden=True), daemon=True, name="warm").start()
-
-
-@app.get("/healthz", include_in_schema=False)
-def healthz():
-    """Alive: the process answers."""
-    return {"ok": True}
-
-
-@app.get("/readyz", include_in_schema=False)
-def readyz():
-    """Ready: the bucket it keeps the settings in is mounted and writable (this app runs no rollouts or indexes)."""
-    from fastapi.responses import JSONResponse
-
-    try:
-        settings.DIR.mkdir(parents=True, exist_ok=True)
-        (settings.DIR / ".ready").write_text("ok")
-        store = "ok"
-    except OSError as e:
-        store = f"unwritable: {type(e).__name__}"
-    return JSONResponse({"ok": store == "ok", "store": store}, status_code=200 if store == "ok" else 503)
-
-
-@app.get("/api/me")
-def me(request: Request):
-    u = auth.current_user(request)
-    return {"user": auth.public(u), "local": config.LOCAL_MODE, "oauth": not config.LOCAL_MODE, "is_admin": settings.is_admin(u),
-            "admin_org": settings.ADMIN_ORG, "explorer": EXPLORER, "version": version.app_version(), "source": version.source_hash()}
-
-
-@app.get("/")
-def index():
-    return FileResponse(ADMIN_WEB / "index.html")
-
-
-app.mount("/admin", StaticFiles(directory=ADMIN_WEB), name="admin-web")
-app.mount("/", StaticFiles(directory=config.WEB_DIR), name="web")   # the explorer's stylesheets, icons and helpers

app/settings.py

@@ -4,8 +4,8 @@ One JSON file in the bucket (STORAGE_DIR/admin/settings.json) holds the collecti
 environments, the rollout switches and an announcement; every change is appended to admin/audit.jsonl with who
 made it. Values not set here fall back to the defaults in code.
 
-Admins are the members of one Hub organization (RLX_ADMIN_ORG, FineEnvs by default), checked against the Hub,
-plus any usernames in RLX_ADMINS.
+The separate private admin application writes these settings; this public module
+only supplies the shared storage contract.
 """
 
 from __future__ import annotations
@@ -19,8 +19,6 @@ from typing import Any
 
 from . import config
 
-ADMIN_ORG = os.environ.get("RLX_ADMIN_ORG", "FineEnvs")
-EXTRA_ADMINS = {u.strip() for u in os.environ.get("RLX_ADMINS", "").split(",") if u.strip()}
 DIR = config.STORAGE_DIR / "admin"
 PATH = DIR / "settings.json"
 AUDIT = DIR / "audit.jsonl"
@@ -90,37 +88,5 @@ def audit(limit: int = 200) -> list[dict[str, Any]]:
     return out
 
 
-# ── who is an admin ──────────────────────────────────────────────────────────
-_members: tuple[float, set[str]] | None = None
-_members_lock = threading.Lock()
-
-
-def _org_members() -> set[str]:
-    """The admin organization's members, from the Hub, refreshed every 10 minutes."""
-    global _members
-    with _members_lock:
-        if _members and time.time() - _members[0] < 600:
-            return _members[1]
-    from huggingface_hub import HfApi
-
-    try:
-        names = {m.username for m in HfApi(token=False).list_organization_members(ADMIN_ORG)}
-    except Exception:  # noqa: BLE001 - the Hub is down: keep the last list, else nobody
-        with _members_lock:
-            return _members[1] if _members else set()
-    with _members_lock:
-        _members = (time.time(), names)
-    return names
-
-
-def is_admin(user: dict[str, Any] | None) -> bool:
-    """Whether this signed-in user may open the admin dashboard. The name comes from the encrypted session, which
-    the Hub set at sign-in, so it can't be claimed by a request."""
-    if not user or not user.get("name"):
-        return False
-    # the org's public member list, or the memberships the Hub reported when this user signed in (private ones too)
-    return user["name"] in EXTRA_ADMINS or user["name"] in _org_members() or ADMIN_ORG in (user.get("orgs") or [])
-
-
 def path_for(name: str) -> Path:
     return DIR / name

app/version.py

@@ -26,7 +26,7 @@ def app_version() -> str:
 @lru_cache(maxsize=1)
 def source_hash() -> str:
     h = hashlib.sha256()
-    for base in (ROOT / "app", ROOT / "web", ROOT / "web-admin"):
+    for base in (ROOT / "app", ROOT / "web"):
         for p in sorted(base.rglob("*")):
             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())

scripts/check_judge_relay.py

@@ -1,57 +0,0 @@
-"""The judge relay end to end, minus the sandbox's network hop: a judge session made exactly as
-app/runner.Rollout._judge_session makes it, then the call a task's grader makes (its variables bound by app/judge.py: the
-per-rollout key, the relay URL, the judge model) to the capture proxy. Then a forged key, and the key after the session ends,
-both refused. Uses your HF token (`hf auth login`) for one judge call; prints no token.
-
-    uv run python scripts/check_judge_relay.py path/to/task.toml
-
-Last run 2026-10-03 on a MiMo General task: 200 with a correct grade in 49 s (Inkling is slow; the local gradio.live
-tunnel cuts requests at 60 s, so long judge prompts need the Space's own /capture), forged 401, 1 call, deleted 401."""
-import asyncio, os, secrets, sys, time
-from dataclasses import replace
-
-sys.path.insert(0, os.getcwd())
-os.environ.setdefault("RLX_WARM", "0")
-import httpx
-from huggingface_hub import get_token
-
-from app import config, judge, runner
-
-
-async def main():
-    runner._proxy_url()   # starts the capture server (and, locally, its tunnel)
-    svc = runner.service()
-    port = svc.capture.port
-    pool = svc.capture.app.state.upstreams
-    from openenv.core.harness.capture.sessions import Upstream
-
-    jup = Upstream(llm_url=config.ROUTER, model="thinkingmachines/Inkling", api_key=get_token(), provider="hf")
-    jclient, jlevel = await pool.resolve(jup)
-    sid = "j" + secrets.token_hex(16)
-    svc.capture.registry.create(sid, upstream=replace(jup, model=jclient.served_model or jup.model), capture_level=jlevel,
-                                purpose="eval", max_model_calls=runner.JUDGE_MAX_CALLS, role="judge", run="local-test")
-    toml = open(sys.argv[1]).read()
-    b = judge.bindings(judge.plan(toml), relay=f"http://127.0.0.1:{port}", capability=sid, judge="thinkingmachines/Inkling")["verifier"]
-    url_key = next(k for k in b if k.endswith("_URL")); key_key = next(k for k in b if k.endswith("_KEY") and b[k] == sid)
-    model = next(v for k, v in b.items() if "MODEL" in k)
-    print("grader gets", {k: ("<capability>" if v == sid else v) for k, v in b.items()})
-    t = time.time()
-    async with httpx.AsyncClient(timeout=180) as c:
-        r = await c.post(b[url_key] + "/chat/completions", headers={"Authorization": f"Bearer {b[key_key]}"},
-                         json={"model": model, "temperature": 0, "max_tokens": 200,
-                               "messages": [{"role": "system", "content": "You grade answers. Reply with JSON {\"score\": 0 or 1, \"why\": str}."},
-                                            {"role": "user", "content": "Rubric: the answer states that 7*8=56. Answer: 7 times 8 is 56."}]})
-        # a forged key and a model the session doesn't serve
-        bad = await c.post(b[url_key] + "/chat/completions", headers={"Authorization": "Bearer jforged"}, json={"model": model, "messages": [{"role": "user", "content": "hi"}]})
-    print("judge reply", r.status_code, round(time.time() - t, 1), "s:", (r.json().get("choices") or [{}])[0].get("message", {}).get("content", r.text)[:200])
-    print("forged key ->", bad.status_code)
-    sess = svc.capture.registry.get(sid)
-    print("session calls:", sess.graph.stats()["n_turns"])
-    svc.capture.registry.delete(sid)
-    print("after delete, same key ->", httpx.post(b[url_key] + "/chat/completions", headers={"Authorization": f"Bearer {sid}"},
-                                               json={"model": model, "messages": [{"role": "user", "content": "hi"}]}, timeout=30).status_code)
-
-
-asyncio.run(main())
-for t in __import__("gradio.tunneling", fromlist=["x"]).CURRENT_TUNNELS:
-    t.kill()

scripts/deploy_spaces.py

@@ -1,115 +0,0 @@
-"""Deploy HF RL Explorer from this folder: the public explorer Space and its private admin Space.
-
-    uv run python scripts/deploy_spaces.py                       # the plan, nothing changed
-    uv run python scripts/deploy_spaces.py --apply               # create or update both Spaces
-    uv run python scripts/deploy_spaces.py --apply --only admin  # one of them
-    uv run python scripts/deploy_spaces.py --apply --listing-from-store   # once the indexer Job runs (DESIGN.md)
-
-Both run this image (Dockerfile); the admin with RLX_APP=app.admin_app:app. They share only the bucket
-FineEnvs/rl-explorer-data, mounted read-write at /data; the explorer also mounts the MiMo explorer's repository
-snapshots read-only (one copy, the one MiMo's own runs use). Each Space has its own SESSION_SECRET: created once,
-never printed, never replaced (replacing it signs everyone out). Each Space gets one commit with its own README,
-so one build, and files no longer here are removed from it.
-"""
-
-from __future__ import annotations
-
-import argparse
-import fnmatch
-import os
-import secrets
-import sys
-from pathlib import Path
-
-from huggingface_hub import CommitOperationAdd, CommitOperationDelete, HfApi, Volume
-
-ROOT = Path(__file__).resolve().parents[1]
-BUCKET = "FineEnvs/rl-explorer-data"
-EXPLORER_URL = "https://fineenvs-rl-explorer.hf.space"
-DATA = Volume(type="bucket", source=BUCKET, mount_path="/data")
-SPACES = {
-    "explorer": {
-        "repo": "FineEnvs/RL-Explorer", "private": False, "readme": "SPACE_README.md", "hardware": "cpu-basic",
-        "variables": {"MIMO_SNAPSHOT_DIR": "/mimo-snapshots"},
-        "volumes": [DATA, Volume(type="bucket", source="FineEnvs/mimo-explorer-runs", mount_path="/mimo-snapshots",
-                                 path="repo-snapshots", read_only=True)],
-    },
-    "admin": {
-        "repo": "FineEnvs/RL-Explorer-admin", "private": True, "readme": "ADMIN_SPACE_README.md", "hardware": "cpu-basic",
-        "variables": {"RLX_APP": "app.admin_app:app", "RLX_OAUTH_SCOPES": "openid profile read-memberships", "RLX_EXPLORER_URL": EXPLORER_URL},
-        "volumes": [DATA],
-    },
-}
-# 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", "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"}
-
-
-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 and not (Path(root) / d).is_symlink())
-        for n in sorted(names):
-            rel = (Path(root) / n).relative_to(ROOT).as_posix()
-            if not (Path(root) / n).is_symlink() and not any(fnmatch.fnmatch(rel, pat) for pat in IGNORE):
-                out.append(rel)
-    return out
-
-
-def deploy(api: HfApi, name: str, spec: dict, listing_from_store: bool, apply: bool) -> None:
-    repo = spec["repo"]
-    variables = {**spec["variables"], **({"RLX_LISTING_FROM_STORE": "1"} if listing_from_store else {})}
-    paths = files()
-    print(f"\n{name}: {repo} ({'private' if spec['private'] else 'public'}, {spec['hardware']})")
-    print(f"  volumes: " + "; ".join(f"{v.source}{'/' + v.path if v.path else ''} -> {v.mount_path}{' (read-only)' if v.read_only else ''}" for v in spec["volumes"]))
-    print(f"  variables: {variables}")
-    print(f"  files: {len(paths)} + README.md from {spec['readme']}")
-    if not apply:
-        return
-    api.create_repo(repo, repo_type="space", space_sdk="docker", private=spec["private"], exist_ok=True,
-                    space_hardware=spec["hardware"])
-    info = api.space_info(repo)
-    if bool(info.private) != spec["private"]:
-        api.update_repo_settings(repo, repo_type="space", private=spec["private"])
-    api.set_space_volumes(repo, spec["volumes"])
-    for k, v in variables.items():
-        api.add_space_variable(repo, k, v)
-    if "SESSION_SECRET" not in {getattr(x, "key", x) for x in api.get_space_secrets(repo)}:   # names, or objects with .key
-        api.add_space_secret(repo, "SESSION_SECRET", secrets.token_urlsafe(48), description="signs this Space's sessions")
-        print("  SESSION_SECRET: created")
-    runtime = api.get_space_runtime(repo)
-    if (runtime.requested_hardware or runtime.hardware) != spec["hardware"]:
-        api.request_space_hardware(repo, spec["hardware"])
-    ops = [CommitOperationAdd(path_in_repo=rel, path_or_fileobj=str(ROOT / rel)) for rel in paths]
-    ops.append(CommitOperationAdd(path_in_repo="README.md", path_or_fileobj=str(ROOT / spec["readme"])))
-    keep = set(paths) | {"README.md", ".gitattributes"}
-    ops += [CommitOperationDelete(path_in_repo=f) for f in api.list_repo_files(repo, repo_type="space") if f not in keep]
-    commit = api.create_commit(repo, repo_type="space", operations=ops, commit_message="Deploy HF RL Explorer")
-    print(f"  pushed {commit.oid[:10]}: https://huggingface.co/spaces/{repo}")
-
-
-def main() -> None:
-    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    ap.add_argument("--apply", action="store_true", help="create or update the Spaces (without it, print the plan)")
-    ap.add_argument("--only", choices=sorted(SPACES), help="deploy one Space")
-    ap.add_argument("--listing-from-store", action="store_true", help="read the indexer Job's listing (set once the Job runs)")
-    args = ap.parse_args()
-    api = HfApi()
-    me = api.whoami()
-    orgs = {o["name"]: o.get("roleInOrg") for o in me.get("orgs", [])}
-    if orgs.get("FineEnvs") not in ("admin", "write", "contributor"):
-        sys.exit(f"{me['name']} can't write to FineEnvs (role: {orgs.get('FineEnvs')})")
-    for name, spec in SPACES.items():
-        if not args.only or args.only == name:
-            deploy(api, name, spec, args.listing_from_store, args.apply)
-    if not args.apply:
-        print("\nNothing changed: run with --apply.")
-
-
-if __name__ == "__main__":
-    main()

scripts/schedule_indexer.py

@@ -1,146 +0,0 @@
-"""Schedule the catalog indexer (app/indexer.py) as an HF scheduled Job. Prints what it would create; --apply creates it.
-
-    uv run python scripts/schedule_indexer.py                       # print the Job and the equivalent `hf` command
-    uv run python scripts/schedule_indexer.py --apply               # create it (asks nothing; needs write access to
-                                                                    # FineEnvs' Jobs, and the explorer Space built)
-    uv run python scripts/schedule_indexer.py --apply --replace     # replace one created before (same name label)
-
-What the Job is:
-
-  image     the explorer Space's own image, `hf.co/spaces/FineEnvs/RL-Explorer` (same code, same lockfile, already built
-            by the Space; a Job can run any Space's image). The Space must exist and have built once.
-  command   `python -m app.indexer --store /data --budget-min 40 --use-token`, from the image's app folder through
-            uv, like the Space's own CMD.
-  schedule  @hourly, with concurrency off: a run still going when the next is due makes the next one wait, never two
-            writers. The run's own budget (40 min of index rebuilds) and the Job's timeout (55 min) keep it inside the
-            hour.
-  flavor    cpu-upgrade (8 vCPU, 32 GB): the full listing (every Space with its files) and a big dataset's index
-            (13,825 tasks) fit with room to spare; SQLite builds on the container's local disk.
-  volume    the private bucket FineEnvs/rl-explorer-data mounted read-write at /data (`Volume(type="bucket")`, the
-            platform's hf-mount, the same volume the explorer and admin Spaces mount). STORAGE_DIR=/data, so catalog's
-            own writers put indexes, packs and listing.json.gz exactly where the Spaces read them.
-  secret    HF_TOKEN, a token of the Job's owner: raises the Hub's rate limits for downloading public dataset files
-            (--use-token; listings and access checks stay anonymous, so nothing private is ever indexed). It's sent
-            as a Job secret (encrypted, not shown in the Job's settings) and never printed here.
-
-How the Job writes to the bucket. Two ways exist: the mounted volume (files written under /data are uploaded when
-closed; a rename is one bucket batch, adding the new path and deleting the old, so temp-then-rename is atomic for
-readers; other mounts see a change within their metadata TTL, ~10 s, and a full listing poll, ~30 s), or the bucket API
-(`HfApi.batch_bucket_files`, one commit per call). The indexer writes through the mount: catalog's index writers
-already work that way on the Spaces, and its snapshot store (`--store /data`) writes the database to a temp name,
-renames it into `snapshots/`, checks it landed whole, then writes the pointer `snapshots/LATEST.v<SCHEMA>.json` last
-the same way. `--store hf://buckets/FineEnvs/rl-explorer-data` publishes the snapshot through the bucket API instead
-(the same two-step order: database, then pointer) if the mount ever proves unreliable for a large file.
-
-The apps pick a new snapshot up on their own: each looks at the pointer every 60 s (app/snapshot.py). Nothing else
-changes on the Spaces.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import shlex
-import sys
-
-NAMESPACE = "FineEnvs"
-NAME = "rl-explorer-indexer"
-IMAGE = "hf.co/spaces/FineEnvs/RL-Explorer"
-BUCKET = "FineEnvs/rl-explorer-data"
-APP_DIR = "/home/user/app"   # the Dockerfile's WORKDIR
-
-
-def spec(args: argparse.Namespace) -> dict:
-    run = (f"cd {APP_DIR} && exec uv run --frozen --no-dev python -m app.indexer --store /data "
-           f"--budget-min {args.budget_min:g} --max-builds {args.max_builds} --keep {args.keep}"
-           + (" --use-token" if args.with_token else ""))
-    return {
-        "namespace": args.namespace,
-        "name": args.name,
-        "image": args.image,
-        "command": ["sh", "-c", run],
-        "schedule": args.schedule,
-        "concurrency": False,
-        "flavor": args.flavor,
-        "timeout": args.timeout,
-        "env": {"STORAGE_DIR": "/data", "RLX_CACHE_DIR": "/tmp/rlx-cache", "HF_HOME": "/tmp/hf-home", "PYTHONUNBUFFERED": "1"},
-        # anonymous by default: public datasets need no token. --with-token sends RLX_INDEXER_TOKEN (a read-only token
-        # made for this) as HF_TOKEN, for the Hub's higher rate limits; never your login token, which can write
-        "secrets": ["HF_TOKEN"] if args.with_token else [],
-        "volumes": [{"type": "bucket", "source": args.bucket, "mount_path": "/data"}],
-        "labels": {"app": "rl-explorer", "role": "indexer"},
-    }
-
-
-def cli(s: dict) -> str:
-    """The same Job with the `hf` CLI."""
-    parts = ["hf", "jobs", "scheduled", "run", s["schedule"], "--namespace", s["namespace"], "--name", s["name"],
-             "--flavor", s["flavor"], "--timeout", s["timeout"], "--no-concurrency",
-             "-v", f"hf://buckets/{s['volumes'][0]['source']}:{s['volumes'][0]['mount_path']}"]
-    for k, v in s["env"].items():
-        parts += ["-e", f"{k}={v}"]
-    for k in s["secrets"]:
-        parts += ["--secrets", k]
-    for k, v in s["labels"].items():
-        parts += ["-l", f"{k}={v}"]
-    parts += [s["image"], *s["command"]]
-    return " ".join(shlex.quote(p) for p in parts)
-
-
-def apply(s: dict, replace: bool) -> int:
-    from huggingface_hub import HfApi, Volume, get_token
-
-    import os
-
-    token = get_token()
-    if not token:
-        print("No HF token: run `hf auth login` (a token that can create Jobs in the FineEnvs organization).", file=sys.stderr)
-        return 2
-    job_token = os.environ.get("RLX_INDEXER_TOKEN")
-    if s["secrets"] and not job_token:
-        print("--with-token needs RLX_INDEXER_TOKEN: a read-only token made for the indexer (not your login token).", file=sys.stderr)
-        return 2
-    api = HfApi(token=token)
-    existing = [j for j in api.list_scheduled_jobs(namespace=s["namespace"], labels={"name": s["name"]})]
-    if existing and not replace:
-        print(f"A scheduled Job named {s['name']} exists already ({', '.join(j.id for j in existing)}): --replace to replace it.",
-              file=sys.stderr)
-        return 1
-    for j in existing:
-        api.delete_scheduled_job(scheduled_job_id=j.id, namespace=s["namespace"])
-        print(f"deleted scheduled Job {j.id}")
-    job = api.create_scheduled_job(
-        image=s["image"], command=s["command"], schedule=s["schedule"], concurrency=s["concurrency"], env=s["env"],
-        secrets={k: job_token for k in s["secrets"]} or None, flavor=s["flavor"], timeout=s["timeout"], name=s["name"],
-        labels=s["labels"], volumes=[Volume(**v) for v in s["volumes"]], namespace=s["namespace"])
-    print(f"created scheduled Job {job.id} ({s['schedule']}); runs: hf jobs scheduled inspect {job.id} --namespace {s['namespace']}")
-    return 0
-
-
-def main(argv: list[str] | None = None) -> int:
-    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    ap.add_argument("--apply", action="store_true", help="create the scheduled Job (otherwise only print it)")
-    ap.add_argument("--replace", action="store_true", help="with --apply: delete a scheduled Job of the same name first")
-    ap.add_argument("--with-token", action="store_true", help="send RLX_INDEXER_TOKEN (a read-only token) as the Job's HF_TOKEN")
-    ap.add_argument("--namespace", default=NAMESPACE)
-    ap.add_argument("--name", default=NAME)
-    ap.add_argument("--image", default=IMAGE, help="a Docker image with this app: the explorer Space's, by default")
-    ap.add_argument("--bucket", default=BUCKET)
-    ap.add_argument("--schedule", default="@hourly", help='a preset (@hourly) or a cron expression ("17 * * * *")')
-    ap.add_argument("--flavor", default="cpu-upgrade")
-    ap.add_argument("--timeout", default="55m")
-    ap.add_argument("--budget-min", type=float, default=40, help="minutes of index rebuilds per run")
-    ap.add_argument("--max-builds", type=int, default=100)
-    ap.add_argument("--keep", type=int, default=5, help="snapshots kept in the bucket")
-    args = ap.parse_args(argv)
-    s = spec(args)
-    print(json.dumps(s, indent=1))
-    print("\n# the same with the hf CLI:\n" + cli(s))
-    if not args.apply:
-        print("\n# nothing created: run again with --apply to create it")
-        return 0
-    return apply(s, args.replace)
-
-
-if __name__ == "__main__":
-    sys.exit(main())

tests/conftest.py

@@ -1,9 +0,0 @@
-"""One sandbox for every test module: storage and caches in a temp folder, a fixed session secret, no warm-up."""
-
-import os
-import tempfile
-
-_TMP = tempfile.mkdtemp(prefix="rlx-test-")
-os.environ.setdefault("RLX_TEST_TMP", _TMP)
-os.environ.update(STORAGE_DIR=os.environ["RLX_TEST_TMP"], RLX_CACHE_DIR=f"{os.environ['RLX_TEST_TMP']}/cache", OAUTH_CLIENT_ID="test-client",
-                  SESSION_SECRET="test-secret", RLX_WARM="0", RLX_ADMIN_ORG="FineEnvs")

tests/reward-stats.test.mjs

@@ -1,20 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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_agents_install.py

@@ -1,60 +0,0 @@
-"""How agents get into a task's sandbox: OpenCode from its release binary, Harbor's npm install only as the fallback."""
-
-from __future__ import annotations
-
-import asyncio
-from types import SimpleNamespace
-
-from app import runner
-
-
-class FakeEnv:
-    def __init__(self, ok: bool):
-        self.ok, self.calls = ok, []
-
-    async def exec(self, command, user=None, env=None, cwd=None, timeout_sec=None, **_):
-        self.calls.append((command, user))
-        install = "releases/download" in command
-        return SimpleNamespace(return_code=0 if (self.ok or not install) else 1, stdout="", stderr="no route")
-
-
-def _agent(tmp_path):
-    from harbor.agents.installed.opencode import OpenCode
-
-    return OpenCode(logs_dir=tmp_path, model_name="p/m")
-
-
-def test_opencode_installs_from_the_release_binary(tmp_path):
-    runner._patch_opencode_install()
-    from harbor.agents.installed.opencode import OpenCode
-
-    env = FakeEnv(ok=True)
-    asyncio.run(OpenCode.install(_agent(tmp_path), env))
-    assert "releases/download" in env.calls[0][0] and env.calls[0][1] == "root"
-    assert not any("npm i -g" in c for c, _ in env.calls)   # no apt, nvm or npm
-
-
-def test_opencode_falls_back_to_harbors_install(monkeypatch, tmp_path):
-    runner._patch_opencode_install()
-    from harbor.agents.installed.opencode import OpenCode
-
-    fell_back = []
-    monkeypatch.setattr(runner, "log", SimpleNamespace(warning=lambda *a, **k: fell_back.append(a)))
-    env = FakeEnv(ok=False)
-    try:
-        asyncio.run(OpenCode.install(_agent(tmp_path), env))
-    except Exception:  # noqa: BLE001 - Harbor's own install against a fake sandbox: only that it was tried matters
-        pass
-    assert fell_back
-    assert len(env.calls) > 1   # Harbor's install ran after the binary failed
-
-
-def test_a_failed_agent_reads_as_what_went_wrong_not_its_command():
-    out = ('RuntimeError: Command failed (exit 1): opencode run -- \'Prepare the 401(k) note for Sarah ...\' | tee x\n'
-           'stdout: {"type":"error","error":{"name":"APIError","data":{"message":"Gateway Time-out","statusCode":504,'
-           '"metadata":{"url":"https://abc.gradio.live/v1/chat/completions"}}}}\n\nstderr: None')
-    msg = runner._friendly_text(out)
-    assert msg.startswith("The agent's model calls failed with Gateway Time-out (504) at the gradio.live tunnel")
-    assert "401(k)" not in msg and "Sign in again" not in msg   # the prompt's "401" is not an auth failure
-    other = runner._friendly_text("RuntimeError: Command failed (exit 2): python run.py --prompt 'the whole task'\nstdout: boom")
-    assert "the whole task" not in other and "exit 2" in other and "boom" in other

tests/test_audit_regressions.py

@@ -1,163 +0,0 @@
-"""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

@@ -1,86 +0,0 @@
-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

@@ -1,68 +0,0 @@
-"""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

@@ -1,96 +0,0 @@
-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_contract.py

@@ -1,175 +0,0 @@
-"""The environment contract (app/envs/contract.py): a new format plugs in by registering an adapter, and then the
-pages' API, the runner, rollouts across a task's forms and the MCP server all work for it, with nothing else changed
-(no network: the Hub is stubbed).
-
-What is checked: the surest adapter that confirms reads a source, and one that hands a source over isn't kept;
-views come back without an adapter's private keys and with run options and aliases; files and folders go through the
-adapter; a run is refused unless the task's chosen run option says it can run, with its own inputs checked and its
-agents limited; rollouts of the same task elsewhere are listed with it; linkers add links; the dataset MCP server
-lists, reads and withholds through the same adapter; row refs round-trip.
-"""
-
-from __future__ import annotations
-
-import json
-import time
-from pathlib import Path
-from types import SimpleNamespace
-
-import pytest
-from fastapi.testclient import TestClient
-
-from app import auth, main, models, runner, settings, store
-from app.envs import contract as c, registry, rows
-
-client = TestClient(main.app, base_url="https://testserver")
-TOKEN = "hf_contract_secret_token_0003"
-
-
-def cookie() -> dict[str, str]:
-    session = {"token": TOKEN, "name": "carol", "avatar": None, "via": "token", "exp": time.time() + 3600}
-    return {"Cookie": f"{auth.COOKIE}={auth._box.encrypt(json.dumps(session).encode()).decode()}"}
-
-
-class Toy(c.Adapter):
-    """A made-up format: tasks are numbered puzzles; puzzle 2 holds its answer in a file; "3" can't run."""
-    id, name, framework = "toy", "Toy puzzles", "Toy"
-    about = "Each task is a numbered puzzle."
-
-    def detect(self, kind, meta):
-        return 0.95 if meta["id"].startswith("toy/") else 0.0
-
-    def summary(self, env, subset=None):
-        return {"state": "ready", "total": 3, "inline": True, "search": True, "subsets": [], "how": {"framework": "Toy", "name": self.name, "about": self.about},
-                "facets": [c.facet("level", "Level", "level")], "overview": [c.section("graded", "How it's graded", [c.kv([("Reward", "1 if solved")])])]}
-
-    def tasks(self, env, *, subset=None, q="", filters=None, offset=0, everything=False):
-        cards = [c.card(f"p/{i}", f"Puzzle {i}", facets={"level": ["easy" if i < 2 else "hard"]}) for i in (1, 2, 3)]
-        return {"cards": cards, "total": 3, "offset": 0, "page": 3}
-
-    def task(self, env, ref):
-        if ref not in ("p/1", "p/2", "p/3"):
-            raise LookupError("no such puzzle")
-        return {"ref": ref, "title": f"Puzzle {ref[2:]}", "sections": [c.section("task", "The task", [c.markdown("Solve it."),
-                c.files([{"path": "README.md", "size": 3}, {"path": "answer.txt", "size": 2, "withheld": True}])])],
-                "glance": [["Level", "easy"]], "withheld": ["answer"], "links": [], "_secret": "never shown"}
-
-    def file(self, env, ref, path):
-        return {"path": path, "withheld": True} if path == "answer.txt" else {"path": path, "text": "hi\n", "size": 3}
-
-    def random(self, env, subset=None):
-        return "p/1"
-
-    def run_options(self, env, ref, view):
-        return [c.run_option("harbor", "Harbor", ok=ref != "p/3", why="no image", default=True,
-                             fields=[c.field("judge", "Judge", "select", default="a", options=["a", "b"]), c.field("hint", "Hint", "bool", default=False)],
-                             harnesses=["opencode"])]
-
-    def run_task(self, env, ref):
-        return {"title": f"Puzzle {ref[2:]}", "restricted": False, "sha": "abc", "bytes": 10, "runnable": {"ok": True, "how": "image"}, "image": "python:3.12"}
-
-    def aliases(self, env, ref):
-        return [("toy/converted", f"tasks/{ref[2:]}")]
-
-
-class Unsure(c.Adapter):
-    """Sure of everything at first, then hands every source over (a Harbor tag on a dataset of rows)."""
-    id = "unsure"
-
-    def detect(self, kind, meta):
-        return 0.99 if meta["id"].startswith("toy/") else 0.0
-
-    def confirm(self, env):
-        return False
-
-
-@pytest.fixture(autouse=True)
-def toy(monkeypatch):
-    monkeypatch.setattr(registry, "_meta", lambda kind, spec, token: {"id": spec, "sha": "abc", "restricted": False})
-    monkeypatch.setattr(registry, "ADAPTERS", [Unsure(), Toy(), *registry.ADAPTERS])
-    monkeypatch.setattr(registry, "_choice", {})
-    monkeypatch.setattr(models, "get", lambda mid: {"id": mid, "tools": True, "provider": "x"})
-    monkeypatch.setattr(runner.Rollout, "execute", lambda self: None)
-    monkeypatch.setattr(settings, "_org_members", lambda: set())
-
-
-def test_the_surest_adapter_that_confirms_reads_it():
-    env = registry.resolve("dataset", "toy/puzzles")
-    assert env.adapter.id == "toy"
-    d = client.get("/api/env/toy/puzzles").json()
-    assert d["env"]["adapter"] == "toy" and d["env"]["framework"] == "Toy" and d["total"] == 3 and d["inline"]
-    assert d["overview"][0]["blocks"][0] == {"type": "kv", "rows": [["Reward", "1 if solved"]]}
-
-
-def test_task_views_are_public_and_complete():
-    v = client.get("/api/env/toy/puzzles/task?ref=p/1").json()
-    assert "_secret" not in json.dumps(v)
-    assert v["env"]["adapter"] == "toy" and v["run"]["options"][0]["ok"] and v["run"]["note"] == ""
-    assert v["aliases"] == [{"env": "toy/converted", "ref": "tasks/1"}]
-    assert client.get("/api/env/toy/puzzles/task?ref=nope").status_code == 404
-    assert client.get("/api/env/toy/puzzles/file?ref=p/2&f=answer.txt").json()["withheld"] is True
-    assert client.get("/api/env/toy/puzzles/random").json() == {"ref": "p/1"}
-    assert client.get("/api/env/toy/puzzles/folder?ref=p/1&f=x/").status_code == 404   # lists its folders up front
-
-
-def test_linkers_add_links_without_either_adapter_knowing(monkeypatch):
-    monkeypatch.setattr(registry, "LINKERS", [lambda env, ref, view: [c.link("Raw row", "/t/raw/ds/train/1", rel="same")]])
-    v = client.get("/api/env/toy/puzzles/task?ref=p/1").json()
-    assert v["links"] == [{"label": "Raw row", "href": "/t/raw/ds/train/1", "note": "", "rel": "same"}]
-
-
-def test_runs_follow_the_chosen_run_option():
-    post = lambda **kw: client.post("/api/runs", json={"dataset": "toy/puzzles", "path": "p/1", "model": "m/x", **kw}, headers=cookie())
-    r = post(fields={"judge": "b"})
-    assert r.status_code == 200, r.text
-    run = r.json()["run"]
-    assert run["adapter"] == "toy" and run["runner"] == "harbor" and run["fields"] == {"judge": "b", "hint": False} and run["env"] == "toy/puzzles"
-    assert TOKEN not in r.text
-    assert post(fields={"judge": "zzz"}).status_code == 400              # not one of its choices
-    assert post(fields={"other": 1}).status_code == 400                  # an input it doesn't take
-    assert post(fields={"hint": "yes"}).status_code == 400               # not a bool
-    assert post(runner="mimo").status_code == 400                        # no such runner for this task
-    assert post(runner="Bad Runner!").status_code == 422
-    assert post(harness="terminus-2").status_code == 400                 # this runner drives only opencode
-    r = client.post("/api/runs", json={"dataset": "toy/puzzles", "path": "p/3", "model": "m/x"}, headers=cookie())
-    assert r.status_code == 400 and "no image" in r.json()["detail"]
-
-
-def test_rollouts_of_the_same_task_elsewhere_are_listed_with_it():
-    base = {"user": "carol", "title": "T", "model": "m/x", "harness": "opencode", "status": "done", "reward": 1.0, "visibility": "public"}
-    here = store.create({**base, "id": "20260102-000000-aaaaaa", "dataset": "toy/puzzles", "path": "p/2", "task_id": "toy/puzzles:p/2"})
-    there = store.create({**base, "id": "20260102-000000-bbbbbb", "dataset": "toy/converted", "path": "tasks/2", "task_id": "toy/converted:tasks/2", "user": "dave"})
-    other = store.create({**base, "id": "20260102-000000-cccccc", "dataset": "toy/converted", "path": "tasks/3", "task_id": "toy/converted:tasks/3"})
-    d = client.get("/api/env/toy/puzzles/runs?ref=p/2", headers=cookie()).json()
-    assert [r["id"] for r in d["mine"]] == [here["id"]]
-    assert [r["id"] for r in d["public"]] == [there["id"]] and "user" not in d["public"][0]
-    assert other["id"] not in json.dumps(d)
-    assert d["elsewhere"] == [{"env": "toy/converted", "ref": "tasks/2"}]
-
-
-def test_the_dataset_mcp_server_uses_the_same_adapter():
-    def rpc(method, params=None, **headers):
-        return client.post("/mcp/d/toy/puzzles", json={"jsonrpc": "2.0", "id": 1, "method": method, "params": params or {}}, headers=headers)
-
-    init = rpc("initialize", {"protocolVersion": "2025-06-18"})
-    assert init.status_code == 200 and init.headers.get("mcp-session-id") and "Toy" in init.json()["result"]["serverInfo"]["name"]
-    names = [t["name"] for t in rpc("tools/list").json()["result"]["tools"]]
-    assert names == ["describe", "list_tasks", "get_task", "read_file", "random_task"]
-    call = lambda name, args: rpc("tools/call", {"name": name, "arguments": args}).json()["result"]
-    assert json.loads(call("list_tasks", {"filters": {"level": ["hard"]}})["content"][0]["text"])["total"] == 2
-    assert json.loads(call("list_tasks", {"query": "puzzle 3"})["content"][0]["text"])["tasks"][0]["ref"] == "p/3"
-    text = call("get_task", {"ref": "p/2"})["content"][0]["text"]
-    assert "Solve it." in text and "answer.txt (withheld)" in text and "never shown" not in text
-    assert "withheld" in call("read_file", {"ref": "p/2", "path": "answer.txt"})["content"][0]["text"]
-    assert call("get_task", {"ref": "nope"})["isError"] is True
-    assert rpc("tools/list", Origin="https://evil.example").status_code == 403
-
-
-def test_row_refs_round_trip():
-    for config, split, i in (("default", "train", 0), ("code", "train", 6), ("a/b", "test", 12)):
-        ref = rows.ref_of(config, split, i)
-        assert rows.parse_ref(ref) == (config, split, i)
-    assert rows.ref_of("default", "train", 3) == "train/3" and rows.ref_of("code", "train", 6) == "code/train/6"
-    assert rows.subset_id("default", "train") == "train" and rows.parse_subset("code/train") == ("code", "train")
-    with pytest.raises(LookupError):   # a 404, not a 500
-        rows.parse_ref("train/x")

tests/test_deploy_spaces.py

@@ -1,12 +0,0 @@
-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

@@ -1,69 +0,0 @@
-"""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_envs.py

@@ -1,307 +0,0 @@
-"""Rows datasets (app/envs) and big Harbor datasets walked folder by folder (no network: rows and the Hub are stubbed).
-
-What is checked: each processor claims the datasets it should; answers never come back (named columns, nested
-keys, a packed task's solution and answer files, MiMo's patches); archives can't escape their folder or blow up;
-filters can't inject; the direct reader pages JSON Lines right; the walker finds tasks without listing whole repos,
-and a task's unlisted folders can't be used to reach files outside it.
-"""
-
-from __future__ import annotations
-
-import base64
-import io
-import json
-import tarfile
-from types import SimpleNamespace
-
-import pytest
-from fastapi.testclient import TestClient
-
-from app import catalog, envs, main
-from app.envs import base, direct, processors
-
-client = TestClient(main.app, base_url="https://testserver")
-
-
-def ds(columns, rows, tags=(), spec="org/ds"):
-    return base.Dataset(spec=spec, tags=list(tags), card={}, splits=[{"config": "default", "split": "train"}],
-                        features=[{"name": c, "type": {}} for c in columns], sample=rows)
-
-
-def tarball(files: dict[str, bytes], prefix="task_0/") -> str:
-    buf = io.BytesIO()
-    with tarfile.open(fileobj=buf, mode="w:gz") as t:
-        for name, data in files.items():
-            info = tarfile.TarInfo(prefix + name if not name.startswith(("..", "/")) else name)
-            info.size = len(data)
-            t.addfile(info, io.BytesIO(data))
-    return base64.b64encode(buf.getvalue()).decode()
-
-
-TASK = {
-    "task.toml": b'[metadata]\ntitle = "Count the words"\ndifficulty = "easy"\ngold_answer = "42"\n[environment]\ndocker_image = "python:3.12"\n',
-    "instruction.md": b"# Count the words\n\nCount the words in /app/a.txt.\n",
-    "tests/test.sh": b"#!/bin/bash\nexpected=42\necho 1 > /logs/verifier/reward.txt\n",
-    "tests/expected_output.json": b'{"answer": 42}',
-    "solution/solve.sh": b"echo 42\n",
-    "task_manifest.json": b'{"original_bash": "wc -w /app/a.txt"}',
-    "environment/Dockerfile": b"FROM python:3.12\n",
-    "../escape.txt": b"nope",
-}
-
-
-# ── which processor reads what ───────────────────────────────────────────────
-def test_processors_claim_their_formats():
-    pick = lambda d: envs.pick(d).id  # noqa: E731
-    assert pick(ds(["path", "task_binary"], [{"path": "t", "task_binary": "x"}], tags=["library:harbor"])) == "harbor-packed"
-    assert pick(ds(["data_source", "prompt", "ability", "reward_model", "extra_info", "agent_name"], [{}], spec="XiaomiMiMo/MiMo-V2.6-RL-oss")) == "mimo"
-    assert pick(ds(["id", "responses_create_params", "kwargs"], [{}])) == "nemo-gym"
-    assert pick(ds(["data_source", "prompt", "reward_model"], [{}])) == "verl"
-    conv = [{"role": "user", "content": "do it"}, {"role": "assistant", "content": "done"}]
-    assert pick(ds(["conversations", "agent", "result"], [{"conversations": conv, "agent": "a", "result": "pass"}])) == "traces"
-    assert pick(ds(["question", "answer"], [{"question": "q", "answer": "a"}], tags=["library:verifiers"])) == "verifiers"
-    assert pick(ds(["question", "answer"], [{"question": "q", "answer": "a"}])) == "generic"
-
-
-def test_generic_roles_and_answers():
-    rows = [{"task_id": f"t{i}", "instruction": f"You are an agent.\nWork carefully.\n\nQuestion {i}: what is {i}?", "question": f"what is {i}?",
-             "answer": str(i), "reward_mode": "exact", "atol": 0.0, "files": ["a.csv"], "difficulty": "easy"} for i in range(5)]
-    d = ds(list(rows[0]), rows)
-    p = envs.pick(d)
-    roles = p.roles(d)
-    assert roles["task"] == "instruction" and roles["id"] == "task_id" and roles["answer"] == ["answer"]
-    assert roles["title"] == "question"                       # the instructions share a preamble: titled by the question
-    assert set(roles["grading"]) == {"reward_mode", "atol"} and roles["environment"] == ["files"]
-    view = p.view(rows[3], 3, d, roles)
-    assert '"3"' not in json.dumps([s["body"] for s in view["sections"] if s["id"] != "task"]) and view["withheld"] == ["answer"]
-    card = p.card(rows[3], 3, roles)
-    assert card["title"] == "what is 3?" and card["id"] == "t3"
-
-
-def test_nested_answers_are_withheld_everywhere():
-    clean, gone = base.withhold({"meta": {"oracle_commands": ["rm"], "level": 1}, "items": [{"gold": 1, "x": 2}], "prompt": "p"})
-    assert clean == {"meta": {"level": 1}, "items": [{"x": 2}], "prompt": "p"}
-    assert set(gone) == {"meta.oracle_commands", "items.gold"}
-    clean, _ = base.withhold({"label": "tw_1", "x": 1}, keep=("label",))   # a label that is the row's id stays
-    assert clean["label"] == "tw_1"
-
-
-def test_retitle_drops_a_shared_preamble():
-    cards = [{"title": "Setup", "snippet": "", "_text": f"# Setup\nrun setup.sh\n\n# Goal\nTask number {i} is hard\nmore"} for i in range(4)]
-    base.retitle(cards)
-    assert [c["title"] for c in cards] == [f"Task number {i} is hard" for i in range(4)]
-    assert all("_text" not in c for c in cards)
-
-
-# ── Harbor tasks packed into rows ────────────────────────────────────────────
-def test_packed_tasks_unpack_without_escaping_and_withhold_answers():
-    files = processors.unpack(tarball(TASK))
-    assert "task.toml" in files and "tests/test.sh" in files        # the folder around them stripped
-    assert not any(".." in n for n in files)
-    p, d = processors.PackedHarbor(), ds(["path", "task_binary"], [], tags=["library:harbor"])
-    row = {"path": "task_0", "task_binary": tarball(TASK)}
-    view = p.view(row, 0, d, p.roles(d))
-    text = json.dumps(view)
-    assert "gold_answer" not in json.dumps([s for s in view["sections"] if s["id"] == "metadata"])
-    assert "solution/solve.sh" in view["withheld"] and "tests/expected_output.json" in view["withheld"] and "task_manifest.json" in view["withheld"]
-    assert p.file(row, d, "task_manifest.json")["withheld"] is True
-    assert view["title"] == "Count the words" and "Count the words in /app/a.txt" in text
-    assert p.file(row, d, "solution/solve.sh") == {"path": "solution/solve.sh", "size": 8, "withheld": True}
-    assert p.file(row, d, "tests/expected_output.json")["withheld"] is True
-    assert "42" not in p.file(row, d, "task.toml")["text"]
-    assert "42" not in p.file(row, d, "tests/test.sh")["text"]           # expected=42 masked
-    assert p.file(row, d, "../escape.txt")["error"]
-    card = p.card(row, 0, {})
-    assert card["title"] == "Count the words" and "easy" in card["chips"]
-
-
-def test_data_files_naming_the_answer_are_withheld():
-    assert catalog._withheld("task_manifest.json", json.dumps({"original_nl": "do x", "mutated_bash": "grep -c x f", "captured_output_path": "tests/o"}))
-    assert catalog._withheld("meta.yaml", "task: x\nexpected_output: 42\n")
-    assert catalog._withheld("data.jsonl", '{"q": 1, "answer": 2}\n')
-    assert not catalog._withheld("config.json", json.dumps({"captured_output_path": "x", "timeout": 3, "name": "t"}))
-    assert not catalog._withheld("instruction.md", "the expected_output is printed")      # only data files by key
-
-
-def test_bad_archives_are_empty_not_errors():
-    assert processors.unpack("not base64 !!!") == {}
-    assert processors.unpack(base64.b64encode(b"\x00" * 64).decode()) == {}
-    assert processors.unpack(12) == {}
-    big = base64.b64encode(b"x" * (processors.MAX_TAR + 10)).decode()
-    assert processors.unpack(big) == {}
-
-
-# ── MiMo's raw release ───────────────────────────────────────────────────────
-def test_mimo_rows_withhold_patches_and_link_their_harbor_twin(monkeypatch):
-    inst = {"instance_id": "Repo_Task-001", "docker_image": "img:1", "problem_statement": "fix it", "test_patch": "diff --git a/t b/t",
-            "patch": "diff --git a/src b/src SECRET", "poc": "crash bytes"}
-    row = {"data_source": "x", "ability": "swe", "agent_name": "a", "prompt": [{"role": "user", "content": "fix it"}],
-           "reward_model": {"style": "rule", "ground_truth": "SECRET2"}, "extra_info": {"instance_id": "Repo_Task-001", "instance_json": json.dumps(inst)}}
-    monkeypatch.setattr(catalog, "_read_index", lambda spec, sha=None: {"tasks": [{"path": "tasks/repo_task-001"}]} if spec.endswith("-code") else None)
-    p = processors.MiMo()
-    d = ds(list(row), [row], spec="XiaomiMiMo/MiMo-V2.6-RL-oss")
-    roles = {**p.roles(d), "_config": "code"}
-    view = p.view(row, 0, d, roles)
-    text = json.dumps(view)
-    assert "SECRET" not in text and "crash bytes" not in text
-    assert view["run"]["dataset"] == "FineEnvs/MiMo-V2.6-RL-harbor-code" and view["run"]["path"] == "tasks/repo_task-001"
-    assert any(s["id"] == "tests" for s in view["sections"])          # hidden tests are shown: they're how it's graded
-
-
-# ── filters and the direct reader ────────────────────────────────────────────
-def test_filters_are_quoted_and_limited_to_known_columns():
-    w = envs._where({"difficulty": "x' OR '1'='1", "nope": "1", 'a"b': "v"}, ["difficulty", 'a"b'])
-    assert w == "\"difficulty\"='x'' OR ''1''=''1' AND \"a\"\"b\"='v'"
-
-
-def test_env_api_rejects_bad_filter_json():
-    assert client.get("/api/env/org/ds/tasks?f=nope").status_code == 400
-    assert client.get("/api/env/org/ds/tasks?f=[1]").status_code == 400
-    assert client.get("/api/env/org/ds/tasks?f=" + json.dumps({f"k{i}": ["v"] for i in range(20)})).status_code == 400
-
-
-def test_jsonl_rows_page_by_line(tmp_path, monkeypatch):
-    p = tmp_path / "data.jsonl"
-    p.write_text("\n".join(json.dumps({"id": i, "prompt": f"p{i}"}) for i in range(10)) + "\n\n")
-    monkeypatch.setattr(direct, "_background", lambda *a, **k: {"state": "done", "local": str(p)})
-    monkeypatch.setattr(direct.Source, "_size", lambda self, path: 100)
-    src = direct.Source("org/ds", {"sha": "abc"}, ["data.jsonl"], None)
-    assert src.total() == 10
-    assert [i for i, _ in src.read(8, 5)] == [8, 9] and src.read(8, 5)[0][1]["prompt"] == "p8"
-    hits, cut = direct.scan(src, lambda r: r["id"] % 3 == 0)
-    assert [i for i, _ in hits] == [0, 3, 6, 9] and not cut
-
-
-def test_a_file_still_coming_serves_its_first_rows(monkeypatch):
-    monkeypatch.setattr(direct, "_background", lambda *a, **k: {"state": "running"})
-    monkeypatch.setattr(direct, "_head", lambda *a, **k: ([{"i": n} for n in range(30)], False))
-    monkeypatch.setattr(direct.Source, "_size", lambda self, path: 10**9)
-    src = direct.Source("org/ds", {"sha": "abc"}, ["big.jsonl"], None)
-    assert src.total() is None
-    assert [r["i"] for _, r in src.read(0, 24)] == list(range(24))
-    with pytest.raises(direct.DirectError) as e:
-        src.read(100, 24)
-    assert e.value.status == 409
-
-
-def test_data_files_follow_the_card_configs(monkeypatch):
-    files = [("data/train-00000.parquet", 10), ("data/test-00000.parquet", 10), ("extra/notes.json", 5)]
-    monkeypatch.setattr(catalog, "_cached", lambda key, ttl, fn: files if key[0] == "data-files" else {
-        "configs": [{"config_name": "default", "data_files": [{"split": "train", "path": "data/train-*"}, {"split": "test", "path": "data/test-*"}]}]})
-    got = direct.data_files("org/ds", {"sha": "abc"}, None)
-    assert got == {"default": {"train": ["data/train-00000.parquet"], "test": ["data/test-00000.parquet"]}}
-
-
-# ── big Harbor datasets, walked folder by folder ─────────────────────────────
-class FakeHub:
-    """A repo of 3 splits x 40 task folders, each with a big app folder that must never be listed."""
-
-    def __init__(self):
-        self.listed, self.info_calls = [], 0
-        self.dirs = {"": ["tasks"], "tasks": ["tasks/a", "tasks/b", "tasks/c"]}
-        self.files = {}
-        for s in ("a", "b", "c"):
-            self.dirs[f"tasks/{s}"] = [f"tasks/{s}/t{i}" for i in range(40)]
-            for i in range(40):
-                d = f"tasks/{s}/t{i}"
-                self.files.update({f"{d}/task.toml": 10, f"{d}/instruction.md": 20, f"{d}/tests/test.sh": 5})
-                self.dirs[d] = [f"{d}/app", f"{d}/tests"]
-
-    def list_repo_tree(self, spec, repo_type=None, revision=None, path_in_repo=None, recursive=False):
-        from huggingface_hub.hf_api import RepoFile, RepoFolder
-
-        p = path_in_repo or ""
-        self.listed.append(p)
-        assert not p.endswith("/app"), "a task's app folder was listed"
-        out = [RepoFolder(path=d, oid="x", tree_id="x") for d in self.dirs.get(p, [])]
-        out += [RepoFile(path=f, size=n, oid="x") for f, n in self.files.items() if f.rsplit("/", 1)[0] == p]
-        return iter(out)
-
-    def get_paths_info(self, spec, paths, repo_type=None, revision=None):
-        from huggingface_hub.hf_api import RepoFile
-
-        self.info_calls += 1
-        assert len(paths) <= 500
-        return [RepoFile(path=p, size=self.files[p], oid="x") for p in paths if p in self.files]
-
-
-def test_walker_finds_every_task_with_few_calls(monkeypatch):
-    hub = FakeHub()
-    monkeypatch.setattr(catalog, "_api", lambda token=None: hub)
-    job = {}
-    out = catalog._walk("org/big", "abc", None, job)
-    assert len(out["tasks"]) == 120 and out["tasks"][0] == "tasks/a/t0"
-    assert out["files"]["tasks/a/t0"] == {"task.toml": 10, "instruction.md": 20, "tests/test.sh": 5}
-    assert len(hub.listed) <= 6                        # root, tasks/, three splits (+0): never a task folder
-    assert hub.info_calls <= 6 and job["tasks"] == 120
-
-
-def test_a_task_folder_listing_stays_inside_the_task(monkeypatch):
-    monkeypatch.setattr(catalog, "_task_row", lambda spec, path, token=None: ({"path": path}, {"sha": "abc", "info": {}}))
-    for bad in ("../other", "..", "", "/", "a/../../b"):
-        with pytest.raises(ValueError):
-            catalog.task_folder("org/ds", "tasks/t1", bad)
-
-
-def test_listing_falls_back_to_walking_when_too_slow(monkeypatch):
-    hub = FakeHub()
-
-    def slow(*a, recursive=False, **k):
-        if recursive:
-            for n in range(10_000):
-                yield SimpleNamespace(path=f"f{n}")
-        else:
-            yield from hub.list_repo_tree(*a, recursive=False, **k)
-
-    monkeypatch.setattr(catalog, "_api", lambda token=None: SimpleNamespace(list_repo_tree=slow, get_paths_info=hub.get_paths_info))
-    monkeypatch.setattr(catalog, "LIST_BUDGET", -1)
-    files, walked = catalog._listing("org/big", "abc", None, {})
-    assert files == {} and walked and len(walked["tasks"]) == 120
-
-
-# ── when the viewer can't filter or search ───────────────────────────────────
-def test_filter_and_search_fall_back_to_reading_a_small_split(monkeypatch):
-    rows = [(i, {"id": f"t{i}", "q": f"question {i}", "tier": "hard" if i % 3 == 0 else "easy", "answer": "zebra" if i == 4 else "x"}) for i in range(50)]
-
-    def no(*a, **k):
-        raise envs.ViewerError("the dataset index is loading")
-
-    monkeypatch.setattr(envs.viewer, "filter_rows", no)
-    monkeypatch.setattr(envs.viewer, "search", no)
-    monkeypatch.setattr(envs.rows, "_all_rows", lambda spec, config, split, tok: rows)
-    envs._broken.clear()
-    v = envs.Viewer("org/ds", None)
-    page, _ = v.filter("default", "train", {"tier": "hard"}, ["tier"], 0)
-    assert page["total"] == 17 and all(r["tier"] == "hard" for _, r, _ in page["rows"])
-    page, _ = v.search("default", "train", "question 4", 0)
-    assert {r["id"] for _, r, _ in page["rows"]} >= {"t4", "t40", "t41"}
-    page, _ = v.search("default", "train", "zebra", 0)
-    assert page["total"] == 0                                    # searching an answer finds nothing
-    assert ("org/ds", "filter") in envs._broken                  # next time straight to the fallback
-
-
-def test_one_slow_viewer_answer_does_not_send_a_dataset_to_its_files(monkeypatch):
-    calls = {"n": 0}
-
-    def flaky(spec, tok=None):
-        calls["n"] += 1
-        if calls["n"] == 1:
-            raise envs.ViewerError("timeout", 502)
-        return [{"config": "default", "split": "train"}]
-
-    monkeypatch.setattr(catalog, "info", lambda spec, token=None: {"sha": "abc", "restricted": False})
-    monkeypatch.setattr(envs.viewer, "splits", flaky)
-    monkeypatch.setattr(envs.viewer, "rows", lambda *a, **k: {"rows": [], "total": 0, "features": []})
-    envs._choice.clear()
-    _, be = envs._backend("org/ds", None)
-    assert be.kind == "viewer" and calls["n"] == 2
-
-
-def test_harbor_layouts_are_found_whatever_the_tags(monkeypatch):
-    hub = FakeHub()
-    monkeypatch.setattr(catalog, "_api", lambda token=None: hub)
-    catalog._memo.clear()
-    assert catalog.looks_harbor("org/big", "abc") is True
-    hub.files = {}
-    catalog._memo.clear()
-    assert catalog.looks_harbor("org/big", "abc") is False

tests/test_frameworks.py

@@ -1,420 +0,0 @@
-"""The framework readers: NeMo Gym (app/envs/nemogym.py), verl / SkyRL (verl_rows.py) and Verifiers (verifiers_rows.py),
-with the conversation and tool reader they share (convo.py). No network: rows are built here in each framework's real
-field names, and the Prime Environments Hub and file listings are stubbed.
-
-Checked first and most: no answer ever leaves a reader (not in the task view, its cards, the dataset overview, nor
-what search looks at), for every framework's real answer fields. Then: each reader says what the policy is asked
-(the conversation, its tools), how it's graded and by what, and how to run it with its own framework, honestly not
-here.
-"""
-
-from __future__ import annotations
-
-import json
-
-import pytest
-
-from app.envs import base, convo, nemogym, processors, rows, verifiers_rows, verl_rows
-from app.envs.base import withhold
-
-
-def ds(columns, sample, spec="org/ds", tags=(), splits=None):
-    return base.Dataset(spec=spec, tags=list(tags), card={}, splits=splits or [{"config": "default", "split": "train"}],
-                        features=[{"name": c, "type": {}} for c in columns], sample=sample)
-
-
-def everything(proc, row, spec="org/ds", tags=(), splits=None):
-    """A row through a reader the way the pages get it: its view, its card, and the dataset's overview."""
-    d = ds(list(row), [row], spec=spec, tags=tags, splits=splits)
-    roles = {**proc.roles(d), "_config": "default", "_split": "train"}
-    view = proc.view(row, 0, d, roles)
-    card = proc.card(row, 0, roles)
-    overview = proc.overview(d, roles, [], "default", "train")
-    return view, card, overview, roles, json.dumps([view, card, overview, {k: v for k, v in roles.items() if not k.startswith("_")}], ensure_ascii=False)
-
-
-@pytest.fixture(autouse=True)
-def _offline(monkeypatch):
-    monkeypatch.setattr(verifiers_rows, "_hub", lambda env_id: {"runtime": "VERIFIERS_V1", "description": "a taskset"})
-    monkeypatch.setattr(verifiers_rows, "_card_env", lambda spec, meta: None)
-
-
-# ── conversations and tools ──────────────────────────────────────────────────
-RESPONSES_INPUT = [
-    {"role": "system", "content": "You are a finance assistant."},
-    {"role": "user", "content": "Pull up the balance sheet for Suncor."},
-    {"id": "rs_1", "type": "reasoning", "summary": [{"type": "summary_text", "text": "I need the symbol."}]},
-    {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "Is **SU** right?", "annotations": []}]},
-    {"role": "user", "content": "Yes, SU."},
-    {"type": "function_call", "name": "get_balance_sheet", "arguments": "{\"symbol\": \"SU\"}", "call_id": "c1"},
-    {"type": "function_call_output", "call_id": "c1", "output": "{\"assets\": 1}"},
-    {"role": "user", "content": "Now the earnings, please."},
-]
-TOOLS = [{"type": "function", "name": "get_balance_sheet", "description": "Balance sheets. Annual and quarterly.", "strict": True,
-          "parameters": {"type": "object", "properties": {"symbol": {"type": "string", "description": "Ticker"},
-                                                          "period": {"type": "string", "enum": ["annual", "quarter"]}}, "required": ["symbol"]}},
-         {"type": "function", "function": {"name": "get_earnings", "description": "EPS", "parameters": {"type": "object", "properties": {
-             "symbol": {"type": "string"}, "years": {"type": "array", "items": {"type": "integer"}}}}}}]
-
-
-def test_responses_items_become_a_transcript_with_outputs_paired_to_calls():
-    ts = convo.turns(RESPONSES_INPUT)
-    kinds = [(t["kind"], t["role"]) for t in ts]
-    assert kinds == [("message", "system"), ("message", "user"), ("reasoning", "assistant"), ("message", "assistant"), ("message", "user"),
-                     ("call", "assistant"), ("message", "user")]
-    call = ts[5]
-    assert call["name"] == "get_balance_sheet" and json.loads(call["args"]) == {"symbol": "SU"} and "\n" in call["args"]   # pretty-printed
-    assert json.loads(call["output"]) == {"assets": 1}   # JSON outputs are pretty-printed too
-    assert ts[3]["text"] == "Is **SU** right?" and ts[2]["text"] == "I need the symbol."
-    assert convo.first_user(ts).startswith("Pull up") and convo.last_user(ts) == "Now the earnings, please."
-    assert "get_balance_sheet" in convo.transcript_text(ts)
-
-
-def test_chat_tool_calls_pair_with_tool_replies_in_order():
-    msgs = [{"role": "user", "content": "go"},
-            {"role": "assistant", "content": None, "reasoning_content": "think", "tool_calls": [
-                {"id": "a", "type": "function", "function": {"name": "f", "arguments": "{}"}},
-                {"id": "b", "type": "function", "function": {"name": "g", "arguments": "{\"x\": 1}"}}]},
-            {"role": "tool", "tool_call_id": "b", "content": "from g"}, {"role": "tool", "content": "from f"}]
-    ts = convo.turns(msgs)
-    calls = [t for t in ts if t["kind"] == "call"]
-    assert [c["output"] for c in calls] == ["from f", "from g"]
-    assert ts[1]["kind"] == "reasoning" and not any(t["kind"] == "output" for t in ts)
-
-
-def test_tools_read_as_signatures_whatever_their_shape():
-    ts = convo.tools(TOOLS)
-    assert [t["name"] for t in ts] == ["get_balance_sheet", "get_earnings"]
-    sym, period = ts[0]["params"]
-    assert sym == {"name": "symbol", "type": "string", "required": True, "description": "Ticker"}
-    assert period["enum"] == ["annual", "quarter"] and not period["required"]
-    assert ts[1]["params"][1]["type"] == "array of integer"
-    assert convo.tools([{"name": "mcp_tool", "input_schema": {"properties": {"q": {"type": "string"}}, "required": ["q"]}}])[0]["params"][0]["required"]
-
-
-def test_titles_skip_tags_templates_and_preambles():
-    assert convo.task_title("<uploaded_files>\n/workspace/x\n</uploaded_files>\n\n<issue>\n**Title:** Mask ignored on assignment\n") == "Mask ignored on assignment"
-    tpl = "Answer the following question. Reply with 'Answer: X'.\n\n{problem}"
-    assert convo.task_title("Answer the following question. Reply with 'Answer: A/B'.\n\nWhat is 2+2?\nA: 4\nB: 5", tpl) == "What is 2+2?"
-    assert convo.headline("Task:\nIn the sheet, sum column B.") == "In the sheet, sum column B."
-    assert convo.headline("<image> As shown in the figure, find x.") == "As shown in the figure, find x."
-    long = "We need a shortlist of films " + "with many constraints " * 12
-    assert convo.headline(long).endswith("…") and len(convo.headline(long)) <= 182
-
-
-def test_withhold_takes_dotted_names_through_lists():
-    v, gone = withhold({"rubric": [{"question": "Q1?", "pass_criteria": "YES"}], "verifier_metadata": {"unit_tests": {"outputs": ["9"]}, "x": 1}},
-                       hide=frozenset({"rubric.pass_criteria", "verifier_metadata.unit_tests"}))
-    assert v == {"rubric": [{"question": "Q1?"}], "verifier_metadata": {"x": 1}}
-    assert gone == ["rubric.pass_criteria", "verifier_metadata.unit_tests"]
-
-
-# ── NeMo Gym ─────────────────────────────────────────────────────────────────
-def pivot_row():
-    return {"trajectory_id": 3344, "info": {"turn": 6, "step": 1, "depth": 12},
-            "responses_create_params": {"input": RESPONSES_INPUT, "tools": TOOLS, "parallel_tool_calls": True},
-            "expected_action": {"type": "function_call", "name": "get_earnings", "arguments": "{\"symbol\": \"SECRET-NEXT-STEP\"}"},
-            "agent_ref": {"type": "responses_api_agents", "name": "toolcall_schema_single_step_tool_use_with_argument_comparison_agent"}}
-
-
-def test_nemo_gym_pivot_row_reads_as_a_conversation_and_hides_the_experts_next_step():
-    view, card, overview, roles, text = everything(nemogym.NemoGym(), pivot_row(), spec="nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1")
-    assert "SECRET-NEXT-STEP" not in text
-    assert view["withheld"] == ["expected_action"] and roles["answer"] == ["expected_action"]
-    assert view["title"] == "Pull up the balance sheet for Suncor." and card["snippet"].startswith("Latest: Now the earnings")
-    sec = {s["id"]: s for s in view["sections"]}
-    tr = sec["task"]["body"][0]
-    assert tr["type"] == "custom" and tr["renderer"] == "rl" and tr["kind"] == "transcript"
-    assert any(t["kind"] == "call" and t.get("output") for t in tr["data"]["turns"]) and "expert" in tr["data"]["next"]["text"]
-    assert sec["tools"]["body"][0]["kind"] == "tools" and len(sec["tools"]["body"][0]["data"]["tools"]) == 2
-    grading = json.dumps(sec["grading"]["body"])
-    assert "single_step_tool_use_with_argument_comparison" in grading and "expected_action" in grading
-    run = sec["run"]["body"][0]["text"]
-    assert "gym env start" in run and "resources_servers/single_step_tool_use_with_argument_comparison/configs/" \
-                                      "toolcall_schema_single_step_tool_use_with_argument_comparison.yaml" in run
-    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"]
-    # 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"
-
-
-NEMO_ANSWERS = [
-    # (row, the secret strings, the withheld names)
-    ({"responses_create_params": {"input": [{"role": "user", "content": "Which? A: x B: y"}]}, "expected_answer": "SECRET-LETTER-C",
-      "options": [{"A": "x"}, {"B": "y"}], "agent_ref": {"type": "responses_api_agents", "name": "mcqa_simple_agent"}},
-     ["SECRET-LETTER-C"], ["expected_answer"]),
-    ({"id": 0, "responses_create_params": {"input": [{"role": "user", "content": "Reply to carlos"}], "tools": TOOLS},
-      "ground_truth": [{"name": "email_reply_email", "arguments": "{\"body\": \"SECRET-REPLY\"}"}], "category": "email",
-      "environment_name": "workplace_assistant", "agent_ref": {"type": "responses_api_agents", "name": "workplace_assistant_simple_agent"}},
-     ["SECRET-REPLY"], ["ground_truth"]),
-    ({"responses_create_params": {"input": [{"role": "user", "content": "add a meeting"}]}, "exp_cal_state": {"0": {"min_time": "SECRET-10:00"}},
-      "agent_ref": {"type": "responses_api_agents", "name": "calendar_simple_agent"}}, ["SECRET-10:00"], ["exp_cal_state"]),
-    ({"responses_create_params": {"input": [{"role": "user", "content": "solve"}]}, "verifier_metadata": {"unit_tests": {"inputs": ["1"], "outputs": ["SECRET-OUT"]}},
-      "hash_id": "h", "agent_ref": {"type": "responses_api_agents", "name": "code_gen_simple_agent"}}, ["SECRET-OUT"], ["verifier_metadata.unit_tests"]),
-    ({"trajectory_id": 1, "responses_create_params": {"input": [{"role": "user", "content": "<issue>fix</issue>"}]},
-      "ref_patch": "SECRET-PATCH", "ref_message": {"role": "assistant", "content": "SECRET-MSG"}, "expected_action": {"type": "message", "content": "SECRET-ACT"},
-      "agent_ref": {"type": "responses_api_agents", "name": "single_step_tool_use_with_argument_comparison_swe"}},
-     ["SECRET-PATCH", "SECRET-MSG", "SECRET-ACT"], ["expected_action", "ref_message", "ref_patch"]),
-    ({"uuid": "u", "responses_create_params": {"input": [{"role": "user", "content": "plan a snack"}]},
-      "rubric": [{"question": "Did it avoid peanuts?", "pass_criteria": "SECRET-YES"}], "agent_ref": {"type": "responses_api_agents", "name": "multichallenge_simple_agent"}},
-     ["SECRET-YES"], ["rubric.pass_criteria"]),
-    ({"task_id": "t", "responses_create_params": {"input": [{"role": "system", "content": "bank"}]}, "customer": "C1", "opening_message": "Hi, a statement please",
-      "user_scenario": {"persona": "p"}, "initial_state": {}, "evaluation_criteria": {"actions": [{"name": "SECRET-ACTION"}], "communicate_info": ["SECRET-FACT"],
-                                                                                   "nl_assertions": ["no mutation"]}},
-     ["SECRET-ACTION", "SECRET-FACT"], ["evaluation_criteria.actions", "evaluation_criteria.communicate_info"]),
-    ({"id": "j", "responses_create_params": {"input": [{"role": "user", "content": "how to"}]}, "response_policy_mapped": "SECRET-POLICY",
-      "agent_ref": {"type": "responses_api_agents", "name": "jailbreak_detection_simple_agent"}}, ["SECRET-POLICY"], ["response_policy_mapped"]),
-    ({"uuid": "r", "responses_create_params": {"input": [{"role": "user", "content": "knights"}]}, "question": "knights", "answer": "SECRET-ANS",
-      "metadata": {"solution": "SECRET-SOLUTION"}, "agent_ref": {"type": "responses_api_agents", "name": "reasoning_gym_simple_agent"}},
-     ["SECRET-ANS", "SECRET-SOLUTION"], ["answer", "metadata"]),
-    ({"responses_create_params": {"input": [{"role": "user", "content": "cite"}]}, "verifier": {"type": "string_match", "patterns": ["SECRET-RE"],
-                                                                                              "expected_markers": ["SECRET-MARK"]},
-      "agent_ref": {"type": "responses_api_agents", "name": "citation_format_simple_agent"}}, ["SECRET-RE", "SECRET-MARK"], ["verifier"]),
-]
-
-
-@pytest.mark.parametrize(("row", "secrets", "names"), NEMO_ANSWERS)
-def test_nemo_gym_answer_fields_never_leave(row, secrets, names):
-    view, card, overview, roles, text = everything(nemogym.NemoGym(), row)
-    for s in secrets:
-        assert s not in text, s
-    assert set(names) <= set(view["withheld"]), view["withheld"]
-
-
-def test_nemo_gym_names_the_config_that_runs_a_renamed_or_unnamed_agent():
-    a = nemogym.agent_of({"agent_ref": {"type": "responses_api_agents", "name": "turing_vif_simple_agent"}}, "org/x")
-    assert a["known"] and a["renamed"] and a["config_name"] == "verifif_simple_agent" and a["resources_server"] == "verifif"
-    a = nemogym.agent_of({"agent_ref": {"name": "single_step_tool_use_with_argument_comparison_swe"}}, "org/x")
-    assert a["config_name"] == "swe_pivot_single_step_tool_use_with_argument_comparison_agent"
-    a = nemogym.agent_of({"task_id": "t", "customer": "C", "user_scenario": {}, "evaluation_criteria": {}, "initial_state": {}, "opening_message": "hi"}, "org/x")
-    assert a["inferred"] and a["resources_server"] == "indian_banking"
-    a = nemogym.agent_of({"question": "q", "expected_answer": "1"}, "nvidia/Nemotron-RL-math-OpenMathReasoning")   # no agent_ref: the config naming the dataset
-    assert a["resources_server"] == "math_with_judge"
-    a = nemogym.agent_of({"agent_ref": {"name": "nobody_knows_agent"}}, "org/x")
-    assert not a["known"] and a["name"] == "nobody_knows_agent"
-
-
-def test_nemo_gym_blends_route_each_row_and_run_without_one_agent():
-    rows_ = [{"responses_create_params": {"input": [{"role": "user", "content": f"q{i}"}]},
-              "agent_ref": {"type": "responses_api_agents", "name": n}} for i, n in enumerate(["mcqa_simple_agent", "workplace_assistant_simple_agent"])]
-    d = ds(["responses_create_params", "agent_ref"], rows_, spec="nvidia/Nemotron-RL-Ultra-Training-Blends")
-    p = nemogym.NemoGym()
-    roles = p.roles(d)
-    assert roles["_mixed"] and p.card(rows_[0], 0, roles)["lead"] == "mcqa_simple_agent"
-    ov = p.overview(d, roles, [], "rlvr1", "train")
-    run = next(s for s in ov if s["id"] == "run")["blocks"][0]["text"]
-    assert run.count("--config ") == 2 and "--agent" not in run and "load_dataset('nvidia/Nemotron-RL-Ultra-Training-Blends', 'rlvr1'" in run
-
-
-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]
-        assert a["config"].startswith("resources_servers/") and a["resources_server"] in cat["servers"]
-
-
-# ── verl / SkyRL ─────────────────────────────────────────────────────────────
-def verl_row(**kw):
-    return {"data_source": "openai/gsm8k", "prompt": [{"role": "user", "content": "Natalia sold clips to 48 friends. How many? Let's think step by step."}],
-            "ability": "math", "reward_model": {"style": "rule", "ground_truth": "SECRET-72"},
-            "extra_info": {"split": "train", "index": 0, "answer": "SECRET-WORKED-SOLUTION", "question": "Natalia sold clips to 48 friends. How many?",
-                           "tools_kwargs": {"calc_gsm8k_reward": {"create_kwargs": {"ground_truth": "SECRET-TOOL-GT"}}}}, **kw}
-
-
-def test_verl_rows_hide_every_ground_truth_and_name_their_scorer():
-    view, card, overview, roles, text = everything(verl_rows.Verl(), verl_row(agent_name="tool_agent"))
-    for s in ("SECRET-72", "SECRET-WORKED-SOLUTION", "SECRET-TOOL-GT"):
-        assert s not in text, s
-    assert {"reward_model.ground_truth", "extra_info.answer"} <= set(view["withheld"])
-    assert view["title"] == "Natalia sold clips to 48 friends. How many?" and ["Scorer", "`gsm8k`"] in view["glance"]
-    sec = {s["id"]: s for s in view["sections"]}
-    assert "calc_gsm8k_reward" in json.dumps(sec["tools"]["body"])
-    run = sec["run"]["body"][0]["text"]
-    assert "python3 -m verl.trainer.main_ppo" in run and "multi_turn.enable=True" in run and "custom_reward_function" not in run
-    assert view["framework_run"]["runner"] == "verl" and view["framework_run"]["ok"] is False
-
-
-@pytest.mark.parametrize(("source", "scorer"), [("openai/gsm8k", "gsm8k"), ("HuggingFaceH4/MATH-500", "math_reward"), ("aime24", "math_dapo"),
-                                                ("numina_olympiads", "prime_math"), ("codeforces", "sandbox_fusion / prime_code"),
-                                                ("searchR1_nq", "search_r1_like_qa_em"), ("DeepScaleR-Preview", None)])
-def test_verl_routes_data_sources_as_default_compute_score_does(source, scorer):
-    got = verl_rows.scorer(source)
-    assert (got[0] if got else None) == scorer
-
-
-def test_verl_rows_with_no_built_in_scorer_get_a_custom_reward_in_the_command():
-    view, *_ = everything(verl_rows.Verl(), {**verl_row(), "data_source": "sheet_arena"})
-    run = next(s for s in view["sections"] if s["id"] == "run")["body"][0]["text"]
-    assert "reward.custom_reward_function.path=" in run
-
-
-def test_compressed_blobs_and_skyrl_sql_answers_are_withheld():
-    blob = "H4sI" + "A" * 400
-    row = {"data_source": "synsql", "prompt": [{"role": "user", "content": "Write SQL for the question"}], "env_class": "text2sql",
-           "reward_spec": {"method": "rule", "ground_truth": "SECRET-GT"}, "sql": "SELECT SECRET_SQL", "output_seq": "SECRET-REASONING",
-           "db_id": "shop", "extra_info": {"part_1": blob}}
-    view, card, overview, roles, text = everything(verl_rows.Verl(), row)
-    for s in ("SECRET-GT", "SECRET_SQL", "SECRET-REASONING", blob):
-        assert s not in text
-    assert view["framework"] == "SkyRL" and "extra_info.part_1" in view["withheld"]
-    run = next(s for s in view["sections"] if s["id"] == "run")["body"][0]["text"]
-    assert "skyrl.train.entrypoints.main_base" in run and "environment.env_class=text2sql" in run and "org/ds:train" in run
-
-
-def test_mimo_no_longer_claims_verl_rows_that_name_an_agent_loop():
-    row = {"data_source": "sheet_arena", "agent_name": "tool_agent", "prompt": [{"role": "user", "content": "x"}], "ability": "spreadsheet",
-           "reward_model": {"style": "rule", "ground_truth": "id"}, "extra_info": {"id": "x"}}
-    assert rows.pick(ds(list(row), [row])).id == "verl"
-    mimo = {**row, "extra_info": {"instance_json": "{}"}}
-    assert rows.pick(ds(list(mimo), [mimo])).id == "mimo"
-
-
-# ── Verifiers ────────────────────────────────────────────────────────────────
-def test_verifiers_swe_rows_withhold_gold_patches_tests_and_solutions():
-    row = {"repo_name": "orange3", "docker_image": "namanjain12/orange3:abc", "commit_hash": "abc",
-           "problem_statement": "[ISSUE]\n**Title:** Context migration fails\n\n**Description:** It raises.\n[/ISSUE]",
-           "prompt": "Write an issue for this commit SECRET-COMMIT-PROMPT", "parsed_commit_content": "SECRET-GOLD-DIFF",
-           "execution_result_content": "SECRET-TESTS", "expected_output_json": "{\"test_a\": \"SECRET-PASSED\"}", "modified_files": ["SECRET/file.py"],
-           "relevant_files": ["SECRET/rel.py"], "modified_entity_summaries": "SECRET-SUMMARY"}
-    view, card, overview, roles, text = everything(verifiers_rows.Verifiers(), row, spec="PrimeIntellect/R2E-Gym-Subset-Verified")
-    for s in ("SECRET-COMMIT-PROMPT", "SECRET-GOLD-DIFF", "SECRET-TESTS", "SECRET-PASSED", "SECRET/file.py", "SECRET/rel.py", "SECRET-SUMMARY"):
-        assert s not in text, s
-    assert view["title"] == "Context migration fails"
-    assert ["Image", "`namanjain12/orange3:abc`"] in view["glance"] and ["API", "v1"] in view["glance"]
-    run = next(s for s in view["sections"] if s["id"] == "run")["body"][0]["text"]
-    assert "prime env install primeintellect/r2e-gym" in run and "uv run eval primeintellect/r2e-gym" in run and "eval.toml" not in run
-
-
-def test_multi_swe_bench_shows_the_issues_and_hides_the_fixing_pr():
-    row = {"org": "facebook", "repo": "zstd", "number": 3942, "title": "Fix #3719: SECRET-PR-TITLE", "body": "SECRET-PR-BODY",
-           "resolved_issues": {"title": ["zstd won't remove the file"], "body": ["Steps to reproduce"], "number": [3719]},
-           "fix_patch": "SECRET-FIX", "test_patch": "SECRET-TEST-PATCH", "f2p_tests": {"t": "SECRET-F2P"}, "run_result": {"x": "SECRET-RUN"},
-           "instance_id": "facebook__zstd-3942", "hints": "SECRET-HINT"}
-    view, card, overview, roles, text = everything(verifiers_rows.Verifiers(), row, spec="PrimeIntellect/Multi-SWE-bench",
-                                                   splits=[{"config": "default", "split": "test"}])
-    for s in ("SECRET-PR-TITLE", "SECRET-PR-BODY", "SECRET-FIX", "SECRET-TEST-PATCH", "SECRET-F2P", "SECRET-RUN", "SECRET-HINT"):
-        assert s not in text, s
-    assert view["title"] == "zstd won't remove the file" and roles["task"] == "resolved_issues"
-    run = next(s for s in view["sections"] if s["id"] == "run")["body"][0]["text"]
-    assert 'dataset_name = "PrimeIntellect/Multi-SWE-bench"' in run and 'id = "primeintellect/multiswe"' in run   # not the taskset's default dataset
-
-
-def test_verifiers_v0_rows_show_the_prompt_and_withhold_the_answer():
-    row = {"question": "What is 6*7?", "answer": "SECRET-42", "info": {"difficulty": "easy", "solution": "SECRET-STEPS"}, "task": "arith"}
-    view, card, overview, roles, text = everything(verifiers_rows.Verifiers(), row, tags=["verifiers"])
-    assert "SECRET-42" not in text and "SECRET-STEPS" not in text
-    assert view["title"] == "What is 6*7?" and {"answer", "info.solution"} <= set(view["withheld"])
-    assert "difficulty" in json.dumps(view["sections"])
-    run = next(s for s in view["sections"] if s["id"] == "run")["body"][0]["text"]
-    assert "prime env install <owner>/<environment>" in run   # no environment named: says how to find it, invents none
-
-
-def test_verifiers_known_v0_environment_uses_the_legacy_runner(monkeypatch):
-    monkeypatch.setattr(verifiers_rows, "_hub", lambda env_id: {"runtime": "VERIFIERS_V0"})
-    view, *_ = everything(verifiers_rows.Verifiers(), {"prompt": "The community in Bruck was merged into it"}, spec="PrimeIntellect/Reverse-Text-RL")
-    task = next(s for s in view["sections"] if s["id"] == "task")["body"][0]["data"]["turns"]
-    assert task[0]["role"] == "system" and "<reversed_text>" in task[0]["text"]
-    run = next(s for s in view["sections"] if s["id"] == "run")["body"][0]["text"]
-    assert "uv run vf-eval reverse-text" in run and "prime env install primeintellect/reverse-text" in run
-
-
-def test_rule_induction_rows_hide_the_rule():
-    row = {"rule_id": "red_cards", "label": "red cards", "family": "single_axis", "code": "return card.color == 'red'"}
-    view, card, overview, roles, text = everything(verifiers_rows.Verifiers(), row, spec="nph4rd/eleusis-simple-rules", tags=["verifiers"])
-    assert "red_cards" not in text and "red cards" not in text and "card.color" not in text
-
-
-# ── the rows adapter ─────────────────────────────────────────────────────────
-def test_search_never_looks_at_framework_answers():
-    row = {"expected_action": {"content": "SECRET"}, "ref_patch": "SECRET", "exp_cal_state": "SECRET", "fix_patch": "SECRET", "prompt": "find me"}
-    assert "SECRET" not in json.dumps(rows._searchable(row)) and "find me" in json.dumps(rows._searchable(row))
-
-
-def test_framework_rows_offer_their_own_framework_as_the_way_to_run():
-    opt = nemogym.run_option({"resources_server": "mcqa"})
-    assert rows.RowsAdapter().run_options(None, "train/0", {"_framework_run": opt}) == [opt]
-    assert opt["ok"] is False and opt["why"] and "**Run it with NeMo Gym**" in opt["about"]
-
-
-def test_a_dataset_opens_on_its_train_split_not_its_leftovers():
-    assert rows._first([{"config": "default", "split": "dropped"}, {"config": "default", "split": "resolved"}])["split"] == "resolved"
-    assert rows._first([{"config": "a", "split": "test"}, {"config": "a", "split": "train"}, {"config": "b", "split": "train"}]) == {"config": "a", "split": "train"}
-
-
-def test_processors_hidden_union_covers_every_framework():
-    assert {"expected_action", "sql", "fix_patch"} <= processors.HIDDEN
-
-
-def test_a_config_the_viewer_cant_read_is_read_from_its_files(monkeypatch):
-    class BrokenViewer:
-        kind, tok = "viewer", None
-
-        def page(self, config, split, offset, length):
-            raise rows.ViewerError("The dataset generation failed", 502)
-
-    class FakeFiles:
-        kind = "files"
-
-        def __init__(self, spec, meta, tok):
-            pass
-
-        def splits(self):
-            return [{"config": "rlvr1", "split": "train"}]
-
-        def page(self, config, split, offset, length):
-            return {"rows": [(0, {"responses_create_params": {"input": "hi"}}, [])], "total": 1, "features": []}
-
-    monkeypatch.setattr(rows, "Files", FakeFiles)
-    rows._split_files.clear()
-    be, page = rows._first_page("org/blend", {"sha": "abc"}, BrokenViewer(), {"config": "rlvr1", "split": "train"})
-    assert be.kind == "files" and page["total"] == 1
-    be, _ = rows._first_page("org/blend", {"sha": "abc"}, BrokenViewer(), {"config": "rlvr1", "split": "train"})   # remembered
-    assert be.kind == "files"
-    with pytest.raises(rows.ViewerError):   # a split the files don't have either: the viewer's error stands
-        rows._first_page("org/blend", {"sha": "abc"}, BrokenViewer(), {"config": "other", "split": "train"})
-
-
-def test_blend_rows_are_pivots_only_when_they_carry_an_expert_step_and_placeholders_say_where_from():
-    plain = {"responses_create_params": {"input": [{"role": "user", "content": "q"}]}, "expected_action": None, "ref_message": None,
-             "agent_ref": {"type": "responses_api_agents", "name": "mcqa_simple_agent"}}
-    assert not nemogym.is_pivot(plain) and nemogym.is_pivot(pivot_row())
-    ph = {"question": "", "responses_create_params": {"input": [{"role": "user", "content": ""}]}, "expected_answer": "",
-          "agent_ref": {"type": "responses_api_agents", "name": "math_with_judge_simple_agent"},
-          "_hf_question_placeholder": {"mode": "canonical", "dataset": "Skywork/Skywork-OR1-RL-Data", "split": "math", "row": 246}}
-    view, card, *_ = everything(nemogym.NemoGym(), ph)
-    assert card["title"] == "A question from Skywork/Skywork-OR1-RL-Data (math, row 246)"
-    assert "fills it in from" in json.dumps(view["sections"][0]["body"])
-
-
-def test_search_never_finds_a_row_through_its_withheld_answer(monkeypatch):
-    """The dataset viewer's search matches every column; a hit found only through an answer is dropped, and the total
-    then says nothing about how many rows hold it. Rows read from files are searched without their answers too."""
-    from app.envs import rows, viewer
-
-    found = [(0, {"prompt": "add 2 and 3", "reward_model": {"ground_truth": "5"}}, []),
-             (1, {"prompt": "the answer is 5 apples", "reward_model": {"ground_truth": "7"}}, [])]
-    monkeypatch.setattr(viewer, "search", lambda *a, **k: {"rows": found, "total": 900, "features": []})
-    rows._broken.clear()
-    page, _ = rows.Viewer("o/ds", None).search("default", "train", "5", 0)
-    assert [i for i, _, _ in page["rows"]] == [1] and page["total"] == 1
-    page, _ = rows.Viewer("o/ds", None).search("default", "train", "apple", 0)   # a stemmed word still counts as visible
-    assert [i for i, _, _ in page["rows"]] == [1]
-
-    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_harbor_spec.py

@@ -1,340 +0,0 @@
-"""Harbor's task.toml as Harbor 0.23 reads it (app/catalog.py), and what a task page shows of it (app/envs/harbor.py).
-No network: each task is a folder written to a temp dir, indexed by catalog._row, and served through stubs.
-
-What is checked: multi-step tasks read their instructions from steps/<name>/instruction.md; a grader in a container of
-its own is said to run there, built from tests/Dockerfile; legacy `memory = "4G"` is converted; tasks that ask for a
-GPU, a Windows container or no network for one phase can't run here (and say why); nested metadata and other tables are
-kept; a model judge is a real model call, not a mention; healthchecks and MCP servers are shown; a step's solution and
-the answers in its tests stay out.
-"""
-
-from __future__ import annotations
-
-import json
-
-import pytest
-
-from app import catalog
-from app.envs import contract as c
-from app.envs.harbor import HarborAdapter
-
-TB = """schema_version = "1.4"
-[task]
-name = "org/{name}"
-[metadata]
-difficulty = "easy"
-[verifier]
-timeout_sec = 300
-[agent]
-timeout_sec = 600
-[environment]
-docker_image = "python:3.12-slim"
-"""
-TEST_SH = "#!/bin/bash\npytest /tests/test_outputs.py && echo 1 > /logs/verifier/reward.txt\n"
-
-
-def dump(x) -> str:
-    return json.dumps(x, ensure_ascii=False)
-
-
-def build(tmp_path, files: dict[str, str], name: str = "t1"):
-    """A task folder on disk, indexed the way build_index indexes it: (row, the pack's texts, file sizes, picks)."""
-    root = tmp_path / name
-    for rel, text in files.items():
-        p = root / rel
-        p.parent.mkdir(parents=True, exist_ok=True)
-        p.write_text(text)
-    sizes = {rel: len(text.encode()) for rel, text in files.items()}
-    picks = catalog._pick(sizes)
-    row, kept = catalog._row(0, name, tmp_path, sizes, picks, {})
-    return row, kept, sizes, picks
-
-
-def view(monkeypatch, tmp_path, files: dict[str, str]):
-    """The task page's view of a task folder, through HarborAdapter.task, with the index and the pack stubbed."""
-    row, kept, sizes, picks = build(tmp_path, files)
-    monkeypatch.setattr(catalog, "_task_row", lambda s, p, t=None: (row, {"sha": "abc", "info": {}}))
-    monkeypatch.setattr(catalog, "_task_texts", lambda s, sha, p, t: (sizes, kept, set(picks)))
-    monkeypatch.setattr(catalog, "_walked_root", lambda s, idx, p, t: ({}, []))
-    monkeypatch.setattr(catalog, "collection", lambda s: None)
-    adapter = HarborAdapter()
-    return adapter.task(c.Env("dataset", "org/ds", {"sha": "abc"}, adapter), "t1"), row, kept
-
-
-def section(v, sid: str) -> dict:
-    return next(s for s in v["sections"] if s["id"] == sid)
-
-
-def rows_of(sec: dict) -> dict:
-    """A section's kv rows as {label: value} (the first of a repeated label)."""
-    out: dict = {}
-    for b in sec["blocks"]:
-        if b["type"] == "kv":
-            for k, v in b["rows"]:
-                out.setdefault(k, v)
-    return out
-
-
-# ── multi-step tasks ─────────────────────────────────────────────────────────
-MULTI = """version = "1.0"
-multi_step_reward_strategy = "final"
-[environment]
-docker_image = "python:3.12"
-[[steps]]
-name = "write"
-min_reward = 0.5
-[steps.agent]
-timeout_sec = 120
-[[steps]]
-name = "extend"
-"""
-
-
-def test_multi_step_instructions_come_from_each_steps_folder(tmp_path, monkeypatch):
-    files = {"task.toml": MULTI, "tests/test.sh": TEST_SH,
-             "steps/write/instruction.md": "Implement greet(name) in /app/greeting.py.\n\nReturn a greeting.",
-             "steps/write/tests/test.sh": "echo 1 > /logs/verifier/reward.txt\n",
-             "steps/write/workdir/setup.sh": "mkdir -p /app\n",
-             "steps/extend/instruction.md": "Extend greet with an uppercase flag.",
-             "steps/extend/solution/solve.sh": "echo SECRET-STEP-SOLUTION\n"}
-    assert catalog._wanted("steps/write/instruction.md", 100) and catalog._wanted("steps/write/tests/test.sh", 100)
-    v, row, kept = view(monkeypatch, tmp_path, files)
-    assert row["steps"] == 2 and row["spec"]["step_names"] == ["write", "extend"]
-    assert row["spec"]["multi"] == {"strategy": "final", "min_reward": {"write": 0.5}}
-    assert row["title"].startswith("Implement greet(name)")   # no instruction.md: the first step's
-    assert "steps/write/instruction.md" in kept and "steps/write/tests/test.sh" in kept
-    assert row["run"] == "image" and row["solution"]   # a step's solution counts as the task's reference solution
-    steps = section(v, "steps")
-    text = dump(steps)
-    assert "Implement greet(name)" in text and "Extend greet with an uppercase flag." in text
-    assert "`tests/test.sh`" in text and "`setup.sh`" in text and "reward ≥ 0.5" in text
-    assert section(v, "task")["title"] == "The task, in 2 steps"
-    assert "the last step's reward" in dump(section(v, "config"))
-    assert "SECRET-STEP-SOLUTION" not in dump(v)
-
-
-def test_an_inline_step_instruction_is_flagged(tmp_path, monkeypatch):
-    toml = 'version = "1.0"\n[environment]\ndocker_image = "x"\n[[steps]]\nname = "only"\ninstruction = "Do the thing."\n'
-    v, row, _ = view(monkeypatch, tmp_path, {"task.toml": toml, "tests/test.sh": TEST_SH})
-    text = dump(section(v, "steps"))
-    assert "Do the thing." in text and "no longer reads it" in text
-
-
-# ── a grader in a container of its own ───────────────────────────────────────
-SEPARATE = TB + """[verifier.environment]
-cpus = 2
-memory = "4G"
-"""
-
-
-def test_separate_verifier_is_said_to_run_in_its_own_container(tmp_path, monkeypatch):
-    toml = SEPARATE.format(name="sep").replace("[verifier]\n", '[verifier]\nenvironment_mode = "separate"\n')
-    files = {"task.toml": toml, "instruction.md": "Do it.", "tests/test.sh": TEST_SH,
-             "tests/Dockerfile": "FROM python:3.12-slim\nRUN pip install pytest\nCOPY . /tests\n"}
-    v, row, _ = view(monkeypatch, tmp_path, files)
-    sep = row["verifier"]["separate"]
-    assert sep["own"] and sep["dockerfile"] and sep["ok"] and not sep.get("image")
-    runs = rows_of(section(v, "grading"))["Runs"]
-    assert "separate container" in runs and "tests/Dockerfile" in runs and "same sandbox" not in runs
-    assert "4 GB memory" in rows_of(section(v, "config"))["Grader's container"]
-    assert ["Grader", "in its own container"] in v["glance"]
-    assert catalog.runnable(row, {})["ok"]
-
-
-def test_separate_verifier_without_an_image_or_dockerfile_cant_run(tmp_path):
-    toml = TB.format(name="sep2").replace('docker_image = "python:3.12-slim"\n', "") + '[verifier.environment]\ncpus = 1\n'
-    row, *_ = build(tmp_path, {"task.toml": toml, "instruction.md": "x", "tests/test.sh": TEST_SH,
-                               "environment/Dockerfile": "FROM python:3.12\n"})
-    r = catalog.runnable(row, {"environment/Dockerfile": "FROM python:3.12\n"})
-    assert not r["ok"] and "container of its own" in r["why"]
-
-
-# ── what Harbor converts, and what an HF Sandbox can't do ────────────────────
-def test_legacy_memory_and_storage_strings_are_converted(tmp_path, monkeypatch):
-    toml = TB.format(name="m").replace("[environment]\n", '[environment]\ncpus = 1\nmemory = "4G"\nstorage = "512M"\n')
-    v, row, _ = view(monkeypatch, tmp_path, {"task.toml": toml, "instruction.md": "x", "tests/test.sh": TEST_SH})
-    assert row["env"]["memory_mb"] == 4096 and row["env"]["storage_mb"] == 512
-    assert rows_of(section(v, "config"))["Resources"] == "1 CPU · 4 GB memory · 512 MB storage"
-
-
-@pytest.mark.parametrize("patch,why", [
-    ('[environment]\ngpus = 1\ngpu_types = ["L4"]\n', "GPU"),
-    ('[environment]\nos = "Windows"\n', "Windows"),
-    ('[environment]\ntpu = { type = "v6e", topology = "2x4" }\n', "TPU"),
-])
-def test_what_hf_sandboxes_cant_give_is_not_runnable(tmp_path, patch, why):
-    toml = TB.format(name="g").replace("[environment]\n", patch)
-    row, *_ = build(tmp_path, {"task.toml": toml, "instruction.md": "x", "tests/test.sh": TEST_SH, "tests/test.bat": "@echo off\n"})
-    r = catalog.runnable(row, {})
-    assert row["run"] is None and not r["ok"] and why in r["why"]
-
-
-@pytest.mark.parametrize("section_,label", [("agent", "agent"), ("verifier", "grader")])
-def test_a_phase_without_internet_is_not_runnable(tmp_path, monkeypatch, section_, label):
-    toml = TB.format(name="n").replace(f"[{section_}]\n", f'[{section_}]\nnetwork_mode = "no-network"\n')
-    v, row, _ = view(monkeypatch, tmp_path, {"task.toml": toml, "instruction.md": "x", "tests/test.sh": TEST_SH})
-    assert row["env"]["network"] is None and row["env"]["phases"] == {section_: "no-network"}
-    r = catalog.runnable(row, {})
-    assert not r["ok"] and f"the {label} asks for no internet access" in r["why"]
-    assert f"{label}: no internet" in rows_of(section(v, "config"))["Network"]
-    assert not v["_runnable"]["ok"]
-
-
-def test_an_allowlist_lists_its_hosts(tmp_path, monkeypatch):
-    toml = TB.format(name="a").replace("[environment]\n", '[environment]\nnetwork_mode = "allowlist"\nallowed_hosts = ["pypi.org", "*.github.com"]\n')
-    v, row, _ = view(monkeypatch, tmp_path, {"task.toml": toml, "instruction.md": "x", "tests/test.sh": TEST_SH})
-    assert row["env"]["hosts"] == ["pypi.org", "*.github.com"] and not catalog.runnable(row, {})["ok"]
-    assert "`pypi.org`" in rows_of(section(v, "config"))["Allowed hosts"]
-
-
-def test_a_task_toml_harbor_rejects_is_read_as_written_and_cant_run(tmp_path):
-    toml = '[task]\nname = "no-org-slash"\n[environment]\ndocker_image = "x"\nmemory = "2G"\n'
-    row, *_ = build(tmp_path, {"task.toml": toml, "instruction.md": "x", "tests/test.sh": TEST_SH})
-    assert "task.name" in row["spec"]["harbor_error"] and row["env"]["memory_mb"] == 2048
-    r = catalog.runnable(row, {})
-    assert not r["ok"] and "Harbor itself rejects" in r["why"]
-
-
-# ── metadata ────────────────────────────────────────��────────────────────────
-NESTED = TB + """[metadata.repo2env]
-recipe = "tasksmith"
-fail_to_pass_count = 14
-gold_patch = "diff --git SECRET-PATCH"
-[metadata.repo2env.evaluation]
-status = "verified"
-[metadata.expected_result]
-value = "SECRET-NESTED"
-[scoring]
-difficulty_label = "hard"
-"""
-
-
-def test_nested_metadata_and_other_tables_are_kept_answers_left_out(tmp_path, monkeypatch):
-    v, row, kept = view(monkeypatch, tmp_path, {"task.toml": NESTED.format(name="nm"), "instruction.md": "x", "tests/test.sh": TEST_SH})
-    assert row["meta"]["repo2env.recipe"] == "tasksmith" and row["meta"]["repo2env.evaluation.status"] == "verified"
-    assert row["meta"]["scoring.difficulty_label"] == "hard"
-    assert "repo2env.gold_patch" in row["withheld"] and "expected_result" in row["withheld"]
-    assert not any("gold" in k or "expected" in k for k in row["meta"])
-    meta = dump(section(v, "metadata"))
-    assert "tasksmith" in meta and "verified" in meta and "hard" in meta
-    assert "SECRET" not in dump(v) and "SECRET" not in kept["task.toml"]   # nor in the raw task.toml shown
-
-
-def test_masked_toml_hides_multi_line_values_and_answer_tables():
-    out = catalog._masked_toml('[metadata]\nexpected = [\n  "a1",\n  "a2",\n]\ntags = [\n  "x",\n]\n[metadata.gold]\nv = 42\n'
-                               '[solution.env]\nFOO = "${FOO}"\n')
-    assert "a1" not in out and "42" not in out and '"x"' in out and 'FOO = "${FOO}"' in out
-    import tomllib
-
-    assert tomllib.loads(out)["metadata"]["gold"] == {"v": "‹withheld›"}
-
-
-# ── a model judge is a model call ────────────────────────────────────────────
-GRADER_CALLS = """import os
-from openai import OpenAI
-
-client = OpenAI(base_url=os.environ["JUDGE_URL"])
-resp = client.chat.completions.create(model="gpt-4o", messages=[{"role": "user", "content": "grade"}])
-"""
-GRADER_MENTIONS = """# compare with an OpenAI-style judge later, maybe
-def grade(answer: str, judge: bool = False) -> float:
-    llm_judge = None
-    return float(answer.strip() == open('/app/out.txt').read().strip())
-"""
-
-
-@pytest.mark.parametrize("grader,judge", [(GRADER_CALLS, True), (GRADER_MENTIONS, False)])
-def test_judge_is_a_real_model_call_not_a_mention(tmp_path, grader, judge):
-    row, *_ = build(tmp_path, {"task.toml": TB.format(name="j"), "instruction.md": "x",
-                               "tests/test.sh": "python3 /tests/grade.py > /logs/verifier/reward.txt\n", "tests/grade.py": grader})
-    assert row["verifier"]["judge"] is judge
-
-
-def test_judge_from_the_graders_model_key():
-    toml = TB.format(name="k") + '[verifier.env]\nOPENAI_API_KEY = "${OPENAI_API_KEY}"\n'
-    assert catalog.verifier_kind("", "", toml_text=toml, sources={})["judge"]
-    assert not catalog.verifier_kind("", "", ["SOME_API_KEY"], toml_text=TB.format(name="k"), sources={})["judge"]   # a key's name isn't a judge
-    js = "import OpenAI from 'openai';\nconst r = await client.responses.create({model: 'x', input: 'y'});\n"
-    assert catalog._calls_model(js) and not catalog._calls_model("import openai  # unused\nprint('judge')\n")
-
-
-# ── what the agent gets besides the instruction ──────────────────────────────
-def test_healthcheck_mcp_servers_and_settings_are_shown(tmp_path, monkeypatch):
-    toml = TB.format(name="h").replace("[agent]\n", '[agent]\nuser = "learner"\n') + """workdir = "/testbed"
-skills_dir = "/skills"
-[environment.healthcheck]
-command = "test -f /ready"
-interval_sec = 2
-retries = 5
-[[environment.mcp_servers]]
-name = "docs"
-transport = "streamable-http"
-url = "http://docs:8000/mcp"
-[[verifier.collect]]
-command = "pg_dump > /logs/db.sql"
-service = "db"
-[[artifacts]]
-source = "/app/out"
-exclude = ["*.pyc"]
-"""
-    v, row, _ = view(monkeypatch, tmp_path, {"task.toml": toml, "instruction.md": "x", "tests/test.sh": TEST_SH, "trajectory.json": "{}"})
-    assert row["env"]["healthcheck"] and row["env"]["mcp"] == ["docs"] and row["env"]["workdir"] == "/testbed"
-    assert row["verifier"]["collect"] == 1 and row["spec"]["agent_user"] == "learner" and row["spec"]["artifacts"] == ["/app/out"]
-    cfg = rows_of(section(v, "config"))
-    assert "`test -f /ready`" in cfg["Healthcheck"] and "every 2 s" in cfg["Healthcheck"] and "5 failed tries" in cfg["Healthcheck"]
-    assert cfg["MCP server"].startswith("`docs` · streamable-http") and "`http://docs:8000/mcp`" in cfg["MCP server"]
-    assert cfg["Users"] == "agent as `learner`" and cfg["Working directory"] == "`/testbed`" and "`/skills`" in cfg["Skills"]
-    assert "`pg_dump > /logs/db.sql` in `db`" in cfg["Collect hooks"] and "`/app/out`" in cfg["Artifacts"]
-    assert cfg["Name"] == "`org/h`" and "Prior context" in cfg
-    assert any(b["type"] == "disclose" and b["label"].startswith("task.toml") for b in section(v, "config")["blocks"])
-    assert "trajectory.json" in dump(section(v, "task"))
-
-
-def test_summary_facets_name_what_sets_tasks_apart(tmp_path, monkeypatch):
-    plain, *_ = build(tmp_path, {"task.toml": TB.format(name="p"), "instruction.md": "x", "tests/test.sh": TEST_SH}, "p")
-    multi, *_ = build(tmp_path, {"task.toml": MULTI, "tests/test.sh": TEST_SH, "steps/write/instruction.md": "a",
-                                 "steps/extend/instruction.md": "b"}, "m")
-    rows = [plain, multi]
-    catalog._group(rows)
-    for r in rows:
-        r.pop("_paras", None)
-        r["brief"] = ""
-    idx = {"tasks": rows, "summary": catalog.summarize(rows), "info": {}, "sha": "abc"}
-    monkeypatch.setattr(catalog, "index_status", lambda spec, token=None: {"state": "done", "index": idx})
-    adapter = HarborAdapter()
-    env = c.Env("dataset", "org/ds", {"sha": "abc"}, adapter)
-    assert "setup" in [f["key"] for f in adapter.summary(env)["facets"]]
-    cards = {x["ref"]: x for x in adapter.tasks(env, everything=True)["cards"]}
-    assert cards["m"]["facets"]["setup"] == ["Multi-step"] and cards["p"]["facets"]["setup"] == []
-    assert "2 steps" in cards["m"]["chips"]
-
-
-# ── answers stay out of steps ────────────────────────────────────────────────
-@pytest.mark.parametrize("rel,text,withheld", [
-    ("steps/s1/solution/solve.sh", None, True),
-    ("steps/s1/solution/notes.md", "anything", True),
-    ("steps/s1/tests/test.sh", "pytest", False),
-    ("steps/s1/tests/grade.py", "import json", False),
-    ("steps/s1/tests/expected.json", None, True),
-    ("steps/s1/tests/data.csv", None, True),
-    ("steps/s1/tests/check.py", "GOLD = {'gold_answer': 42}", True),
-    ("steps/s1/instruction.md", "Write it.", False),
-])
-def test_step_answers_are_withheld(rel, text, withheld):
-    assert catalog._withheld(rel, text) is withheld
-
-
-def test_a_step_solution_is_never_served(tmp_path, monkeypatch):
-    files = {"task.toml": MULTI, "tests/test.sh": TEST_SH, "steps/write/instruction.md": "a", "steps/extend/instruction.md": "b",
-             "steps/write/tests/test.sh": 'EXPECTED="SECRET-42"\n[ "$(cat /app/x)" = "$EXPECTED" ] && echo 1 > /logs/verifier/reward.txt\n',
-             "steps/write/solution/solve.sh": "echo SECRET-SOLVE\n"}
-    row, kept, sizes, picks = build(tmp_path, files)
-    assert "steps/write/solution/solve.sh" not in kept and "SECRET-42" not in kept["steps/write/tests/test.sh"]
-    monkeypatch.setattr(catalog, "_task_row", lambda s, p, t=None: (row, {"sha": "abc", "info": {}}))
-    monkeypatch.setattr(catalog, "_task_texts", lambda s, sha, p, t: (sizes, kept, set(picks)))
-    monkeypatch.setattr(catalog, "_walked_root", lambda s, idx, p, t: ({}, []))
-    monkeypatch.setattr(catalog, "_fetch", lambda *a, **k: pytest.fail("a withheld file was fetched"))
-    got = catalog.task_file("org/ds", "t1", "steps/write/solution/solve.sh")
-    assert got.get("withheld") and "text" not in got
-    tree = {f["path"]: f["withheld"] for f in catalog.task("org/ds", "t1")["tree"]}
-    assert tree["steps/write/solution/solve.sh"] is True and tree["steps/write/instruction.md"] is False

tests/test_judge.py

@@ -1,99 +0,0 @@
-"""A Harbor task's variables and model-graded tasks (app/judge.py), on the patterns real datasets use (MiMo's
-conversions, skilltrainbench, data-agent, WildClawBench): what each variable gets in a rollout here, in which phase,
-and that nothing the agent sees is a key of ours."""
-
-from __future__ import annotations
-
-from app import judge
-
-MIMO_GENERAL = '''
-[verifier.env]
-GA_JUDGE_KEY = "${HF_TOKEN}"
-GA_JUDGE_URL = "${MIMO_JUDGE_URL:-https://router.huggingface.co/v1}"
-GA_JUDGE_MODEL = "${MIMO_TEXT_JUDGE:-thinkingmachines/Inkling}"
-VERIFY_DETERMINISTIC = "1"
-'''
-MIMO_WEBDEV = '''
-[verifier.env]
-WEBDEV_JUDGE_KEY = "${HF_TOKEN}"
-WEBDEV_JUDGE_URL = "${MIMO_JUDGE_URL:-https://router.huggingface.co/v1}"
-WEBDEV_JUDGE_MODEL = "${MIMO_VISION_JUDGE:-meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8}"
-'''
-HEALTHBENCH = '''
-[verifier.env]
-STBENCH_JUDGE_BASE_URL = "${STBENCH_JUDGE_BASE_URL}"
-STBENCH_JUDGE_API_KEY = "${STBENCH_JUDGE_API_KEY}"
-STBENCH_JUDGE_MODEL = "${STBENCH_JUDGE_MODEL}"
-STBENCH_JUDGE_TEMPERATURE = "${STBENCH_JUDGE_TEMPERATURE}"
-'''
-HLE = '''
-[verifier.env]
-OPENAI_API_KEY = "${OPENAI_API_KEY}"
-OPENAI_BASE_URL = "${OPENAI_BASE_URL:-}"
-JUDGE_MODEL = "o3-mini-2025-01-31"
-'''
-DATA_AGENT = '''
-[environment.env]
-HF_TOKEN = "${HF_TOKEN}"
-'''
-NEEDS_SERVICE = '''
-[environment.env]
-DATABASE_URL = "${DATABASE_URL}"
-'''
-
-
-def test_a_model_graded_task_gets_the_relay_in_its_grading_phase_only():
-    p = judge.plan(MIMO_GENERAL)
-    assert p["judge"] == {"requested": "thinkingmachines/Inkling", "vision": False, "anthropic": False, "keys": ["GA_JUDGE_KEY", "GA_JUDGE_URL"]}
-    assert p["missing"] == [] and p["agent_keys"] == []
-    b = judge.bindings(p, relay="https://x.hf.space/capture", capability="jcap", judge="thinkingmachines/Inkling")
-    assert b["verifier"]["GA_JUDGE_KEY"] == "jcap" and b["verifier"]["HF_TOKEN"] == "jcap"
-    assert b["verifier"]["GA_JUDGE_URL"] == "https://x.hf.space/capture/v1"   # never the real router: the relay holds the token
-    assert b["verifier"]["GA_JUDGE_MODEL"] == "thinkingmachines/Inkling"
-    assert "jcap" not in b["environment"].values()
-
-
-def test_a_vision_grader_asks_for_a_vision_judge():
-    assert judge.plan(MIMO_WEBDEV)["judge"]["vision"] is True
-
-
-def test_a_judge_without_defaults_gets_the_picked_model_and_deterministic_settings():
-    p = judge.plan(HEALTHBENCH)
-    assert p["judge"] and p["missing"] == []
-    b = judge.bindings(p, relay="https://r", capability="c", judge="openai/gpt-oss-120b")["verifier"]
-    assert b["STBENCH_JUDGE_MODEL"] == "openai/gpt-oss-120b" and b["STBENCH_JUDGE_TEMPERATURE"] == "0"
-    assert b["STBENCH_JUDGE_BASE_URL"] == "https://r/v1" and b["STBENCH_JUDGE_API_KEY"] == "c"
-
-
-def test_an_openai_client_with_an_empty_default_url_is_pointed_at_the_relay():
-    p = judge.plan(HLE)
-    assert p["judge"]["requested"] == "o3-mini-2025-01-31"
-    b = judge.bindings(p, relay="https://r", capability="c", judge="deepseek-ai/DeepSeek-V4-Pro")["verifier"]
-    assert b["OPENAI_BASE_URL"] == "https://r/v1" and b["OPENAI_API_KEY"] == "c"   # not api.openai.com with our key
-
-
-def test_a_key_the_agent_would_see_is_left_empty():
-    p = judge.plan(DATA_AGENT)
-    assert p["judge"] is None and p["agent_keys"] == ["HF_TOKEN"] and p["missing"] == []
-    assert judge.bindings(p)["environment"]["HF_TOKEN"] == ""
-
-
-def test_a_variable_nothing_here_provides_stops_the_task():
-    p = judge.plan(NEEDS_SERVICE)
-    assert p["missing"] == ["DATABASE_URL"]
-
-
-def test_without_a_judge_nothing_is_bound_to_a_relay():
-    b = judge.bindings(judge.plan(MIMO_GENERAL))
-    assert b["verifier"]["GA_JUDGE_KEY"] == "" and "GA_JUDGE_URL" not in b["verifier"]   # no capability: an empty key, the task's defaults
-
-
-def test_the_table_says_how_each_variable_is_filled():
-    rows = dict(judge.table(judge.plan(MIMO_GENERAL)))
-    assert any("judge relay" in v for v in rows.values())
-    assert not any("hf_" in v for v in rows.values())
-
-
-def test_a_broken_toml_is_not_a_crash():
-    p = judge.plan("this is = = not toml")
-    assert p["invalid"] and p["vars"] == []

tests/test_live.py

@@ -1,409 +0,0 @@
-"""Live Spaces and the MCP bridge (no network: the Hub and the Spaces are stubbed).
-
-What is checked: the explorer only ever talks to a Space's own hf.space host (never a redirect elsewhere, never a
-private Space); waking and restarting do only what they should; playground sessions belong to whoever started them
-and are capped; answers stay out of the Task API browser; the bridge speaks MCP (handshake, notifications, errors,
-sessions), refuses cross-origin pages, and turns servers without tools into reset/step/state tools.
-"""
-
-from __future__ import annotations
-
-import json
-import time
-from types import SimpleNamespace
-
-import httpx
-import pytest
-from fastapi.testclient import TestClient
-
-from app import catalog, main, mcp_bridge, spaces_live as live
-
-client = TestClient(main.app, base_url="https://testserver")
-
-
-def space_info(stage="RUNNING", sub="org-env", private=False, base_path=None):
-    card = SimpleNamespace(to_dict=lambda: ({"base_path": base_path} if base_path else {}))
-    return SimpleNamespace(private=private, card_data=card, subdomain=sub, sdk="docker", tags=["openenv"],
-                           runtime=SimpleNamespace(stage=stage, hardware="cpu-basic"))
-
-
-@pytest.fixture(autouse=True)
-def fresh(monkeypatch):
-    catalog._memo.clear()
-    live._sessions.clear()
-    live._woken.clear()
-    mcp_bridge._hits.clear()
-    mcp_bridge._clients.clear()
-    yield
-    for s in list(live._sessions.values()):
-        s.ws = None
-    live._sessions.clear()
-
-
-def stub_hub(monkeypatch, **kw):
-    monkeypatch.setattr(catalog, "_api", lambda token=None: SimpleNamespace(space_info=lambda spec, expand=None: space_info(**kw)))
-
-
-# ── the Space's record ───────────────────────────────────────────────────────
-def test_only_the_spaces_own_hf_space_host_is_used(monkeypatch):
-    stub_hub(monkeypatch, sub="evil.example.com/x")
-    assert live.record("org/env")["host"] == ""
-    catalog._memo.clear()
-    stub_hub(monkeypatch, sub="org-env")
-    assert live.record("org/env")["host"] == "https://org-env.hf.space"
-
-
-def test_private_spaces_are_refused(monkeypatch):
-    stub_hub(monkeypatch, private=True)
-    with pytest.raises(PermissionError):
-        live.record("org/env")
-    assert client.get("/api/spaces/org/env/live").status_code == 404
-
-
-def test_base_path_must_be_a_plain_path(monkeypatch):
-    stub_hub(monkeypatch, base_path="//evil.com")
-    assert live.record("org/env")["base_path"] is None
-    catalog._memo.clear()
-    stub_hub(monkeypatch, base_path="/web")
-    assert live.record("org/env")["base_path"] == "/web"
-
-
-def test_bad_space_ids_are_refused():
-    for bad in ("../x/y", "a/b/c"):
-        assert client.get(f"/api/spaces/{bad}/live").status_code in (400, 404)
-
-
-def test_redirects_off_the_space_are_never_followed(monkeypatch):
-    stub_hub(monkeypatch)
-    rec = live.record("org/env")
-    seen = []
-
-    def fake_get(url, **kw):
-        seen.append(url)
-        if url.endswith("/web"):
-            return httpx.Response(302, headers={"location": "http://169.254.169.254/latest/meta-data"}, request=httpx.Request("GET", url))
-        if url.endswith("/start-page"):
-            return httpx.Response(302, headers={"location": "/web/"}, request=httpx.Request("GET", url))
-        return httpx.Response(200, headers={"content-type": "text/html"}, text="<html>", request=httpx.Request("GET", url))
-
-    monkeypatch.setattr(live._client, "get", fake_get)
-    assert live._get_here(rec, "/web") is None                       # off-host: dropped, not fetched
-    assert not any("169.254" in u for u in seen)
-    r = live._get_here(rec, "/start-page")                            # on-host: followed
-    assert r is not None and r.url.path == "/web/"
-
-
-def test_hub_dataset_names_map_back_safely():
-    assert live.hub_dataset("/data/FineEnvs__MiMo-V2.6-RL-harbor-terminal") == "FineEnvs/MiMo-V2.6-RL-harbor-terminal"
-    assert live.hub_dataset("/app/prepared/datasets/train") is None
-    assert live.hub_dataset("/data/a__b__c") is None
-    assert live.hub_dataset("/data/__x") is None
-
-
-# ── wake and restart ─────────────────────────────────────────────────────────
-def test_wake_only_sleeping_spaces_and_at_most_once_a_minute(monkeypatch):
-    calls = []
-    monkeypatch.setattr(live.httpx, "post", lambda url, **kw: calls.append(url) or httpx.Response(302))
-    stub_hub(monkeypatch, stage="SLEEPING")
-    assert live.wake("org/env")["woken"] is True
-    assert live.wake("org/env")["woken"] is True        # again within a minute: not sent again
-    assert calls == ["https://huggingface.co/spaces/org/env/start"]
-    catalog._memo.clear()
-    stub_hub(monkeypatch, stage="RUNTIME_ERROR")
-    with pytest.raises(live.SpaceError):
-        live.wake("org/env")
-    catalog._memo.clear()
-    stub_hub(monkeypatch, stage="RUNNING")
-    assert live.wake("org/env") == {"stage": "RUNNING", "woken": False}
-    assert len(calls) == 1
-
-
-def test_restart_needs_a_signed_in_visitor():
-    assert client.post("/api/spaces/org/env/restart", json={}).status_code == 401
-
-
-def test_restart_without_write_access_says_so(monkeypatch):
-    from huggingface_hub.errors import HfHubHTTPError
-
-    def refuse(_spec):
-        raise HfHubHTTPError("no", response=httpx.Response(403, request=httpx.Request("POST", "https://huggingface.co")))
-
-    space = space_info(stage="RUNTIME_ERROR")
-    monkeypatch.setattr(catalog, "_api", lambda token=None: SimpleNamespace(space_info=lambda spec, expand=None: space, restart_space=refuse))
-    with pytest.raises(live.SpaceError) as e:
-        live.restart("org/env", "hf_x")
-    assert e.value.status == 403
-
-
-def test_wake_and_play_refuse_cross_site_posts():
-    for path, body in (("/api/spaces/org/env/wake", {}), ("/api/spaces/org/env/play", {"op": "start"})):
-        r = client.post(path, json=body, headers={"Origin": "https://evil.example"})
-        assert r.status_code == 403
-
-
-# ── the Task API browser ─────────────────────────────────────────────────────
-def test_task_api_leaves_answers_out(monkeypatch):
-    stub_hub(monkeypatch)
-    monkeypatch.setattr(live, "probe", lambda spec, fresh=False: {"running": True, "task_api": {"env": "e", "splits": []}})
-
-    def fake_post(url, json=None, **kw):
-        task = {"task_id": "t1", "prompt": "find x", "ground_truth": "42", "meta": {"expected_output": "x", "level": 2},
-                "target_latex": "a^2", "target_language": "fr", "options": [{"answer": "b", "text": "B"}]}
-        body = {"tasks": [task]} if url.endswith("/task_range") else {"task": task}
-        return httpx.Response(200, json=body, request=httpx.Request("POST", url))
-
-    monkeypatch.setattr(live._client, "post", fake_post)
-    for out in (live.tasks("org/env", "train", 0, 999)["tasks"][0], live.task("org/env", "train", 0)["task"]):
-        text = json.dumps(out)
-        assert "42" not in text and "expected_output" not in text and "a^2" not in text and '"answer"' not in text
-        assert out["prompt"] == "find x" and out["target_language"] == "fr"
-    assert live.tasks("org/env", "train", 0, 999)["stop"] == 50                      # a page is at most 50 tasks
-
-
-# ── playground sessions ──────────────────────────────────────────────────────
-def running(monkeypatch):
-    stub_hub(monkeypatch)
-    monkeypatch.setattr(live, "probe", lambda spec, fresh=False: {"running": True, "openenv": True, "step_api": True, "mcp": None})
-
-
-def test_sessions_belong_to_who_started_them(monkeypatch):
-    running(monkeypatch)
-    sid = live.start("org/env", "web:1.1.1.1")["session"]
-    with pytest.raises(live.SpaceError) as e:
-        live.act(sid, "web:2.2.2.2", "state")
-    assert e.value.status == 410
-
-
-def test_sessions_are_capped_per_owner_and_in_total(monkeypatch):
-    running(monkeypatch)
-    ids = [live.start("org/env", "web:a")["session"] for _ in range(live.PER_OWNER + 2)]
-    mine = [s for s in live._sessions.values() if s.owner == "web:a"]
-    assert len(mine) == live.PER_OWNER and ids[-1] in live._sessions and ids[0] not in live._sessions
-    monkeypatch.setattr(live, "TOTAL", len(live._sessions))
-    with pytest.raises(live.SpaceError) as e:
-        live.start("org/env", "web:b")
-    assert e.value.status == 429
-
-
-def test_idle_sessions_end(monkeypatch):
-    running(monkeypatch)
-    sid = live.start("org/env", "web:a")["session"]
-    live._sessions[sid].used = time.time() - live.IDLE - 1
-    with pytest.raises(live.SpaceError):
-        live.act(sid, "web:a", "state")
-    assert sid not in live._sessions
-
-
-def test_play_rejects_bad_operations_and_tool_names(monkeypatch):
-    running(monkeypatch)
-    sid = live.start("org/env", "web:a")["session"]
-    with pytest.raises(live.SpaceError):
-        live.act(sid, "web:a", "rm -rf")
-    with pytest.raises(live.SpaceError):
-        live.act(sid, "web:a", "call", {"name": "../../x y"})
-    r = client.post("/api/spaces/org/env/play", json={"op": "nope"})
-    assert r.status_code == 422
-
-
-def test_play_sessions_do_not_cross_spaces(monkeypatch):
-    running(monkeypatch)
-    r = client.post("/api/spaces/org/env/play", json={"op": "start"})
-    sid = r.json()["session"]
-    r = client.post("/api/spaces/org/other/play", json={"op": "state", "session": sid})
-    assert r.status_code == 400
-
-
-def test_websocket_replies_become_results_and_errors(monkeypatch):
-    running(monkeypatch)
-    sent = []
-
-    class FakeWS:
-        def __init__(self, replies):
-            self.replies = list(replies)
-
-        def send(self, m):
-            sent.append(json.loads(m))
-
-        def recv(self, timeout=None):
-            return json.dumps(self.replies.pop(0))
-
-        def close(self):
-            pass
-
-    sid = live.start("org/env", "web:a")["session"]
-    live._sessions[sid].ws = FakeWS([{"type": "observation", "data": {"observation": {"x": 1}, "reward": 0.5, "done": True}},
-                                     {"type": "error", "data": {"message": "bad action"}},
-                                     {"type": "mcp", "data": {"jsonrpc": "2.0", "id": 1, "result": {"content": [{"type": "text", "text": "ok"}]}}}])
-    out = live.act(sid, "web:a", "reset", {"seed": 1})
-    assert out["result"]["reward"] == 0.5 and sent[0] == {"type": "reset", "data": {"seed": 1}}
-    with pytest.raises(live.SpaceError) as e:
-        live.act(sid, "web:a", "step", {"a": 1})
-    assert "bad action" in str(e.value)
-    out = live.act(sid, "web:a", "call", {"name": "look", "arguments": {"h": 1}})
-    assert out["result"]["content"][0]["text"] == "ok" and sent[-1]["type"] == "mcp" and sent[-1]["data"]["method"] == "tools/call"
-
-
-def test_images_in_observations_are_found():
-    import base64
-
-    png = base64.b64encode(b"\x89PNG" + b"0" * 400).decode()
-    parts = live.image_parts({"observation": {"image_base64": png, "image_format": "png", "text": "hi"}})
-    assert parts and parts[0][0] == "image/png"
-    assert live.image_parts({"observation": {"text": "x" * 500}}) == []
-
-
-# ── the MCP bridge ───────────────────────────────────────────────────────────
-INFO = {"running": True, "stage": "RUNNING", "openenv": True, "step_api": True, "mcp": None,
-        "schema": {"action": {"type": "object", "properties": {"latex": {"type": "string"}, "metadata": {"type": "object"}}}},
-        "task_api": {"env": "e", "splits": [{"name": "train", "num_tasks": 3}]}}
-
-
-def rpc(method, params=None, rid=1, sid=None, **headers):
-    h = {"Content-Type": "application/json", **({"Mcp-Session-Id": sid} if sid else {}), **headers}
-    body = {"jsonrpc": "2.0", "method": method, **({"id": rid} if rid is not None else {}), **({"params": params} if params is not None else {})}
-    return client.post("/mcp/org/env", content=json.dumps(body), headers=h)
-
-
-@pytest.fixture
-def bridge(monkeypatch):
-    stub_hub(monkeypatch)
-    monkeypatch.setattr(live, "probe", lambda spec, fresh=False: INFO)
-    calls = []
-    monkeypatch.setattr(live, "act", lambda sid, owner, op, data=None: calls.append((op, data)) or {"result": {"observation": {"ok": 1}, "reward": 1.0}})
-    return calls
-
-
-def test_bridge_handshake_and_session(bridge):
-    r = rpc("initialize", {"protocolVersion": "2025-06-18", "capabilities": {}, "clientInfo": {"name": "t", "version": "1"}})
-    assert r.status_code == 200 and r.headers["mcp-session-id"]
-    res = r.json()["result"]
-    assert res["protocolVersion"] == "2025-06-18" and res["capabilities"]["tools"] == {"listChanged": False}
-    assert rpc("initialize", {"protocolVersion": "1999-01-01"}).json()["result"]["protocolVersion"] == mcp_bridge.PROTOCOLS[0]
-    assert rpc("notifications/initialized", rid=None).status_code == 202
-    assert rpc("ping").json()["result"] == {}
-
-
-def test_bridge_offers_episode_and_task_tools_for_servers_without_tools(bridge):
-    tools = {t["name"]: t for t in rpc("tools/list").json()["result"]["tools"]}
-    assert set(tools) == {"reset", "step", "state", "list_splits", "list_tasks", "get_task"}
-    assert set(tools["step"]["inputSchema"]["properties"]) == {"latex"}           # the action schema, metadata dropped
-    r = rpc("tools/call", {"name": "step", "arguments": {"latex": "x^2"}}).json()["result"]
-    assert bridge[-1] == ("step", {"latex": "x^2"}) and "content" in r and not r.get("isError")
-
-
-def test_bridge_tool_errors_are_results_the_agent_can_read(bridge, monkeypatch):
-    def boom(*a, **k):
-        raise live.SpaceError("the Space didn't answer within 180 s", 504)
-
-    monkeypatch.setattr(live, "act", boom)
-    r = rpc("tools/call", {"name": "step", "arguments": {}}).json()
-    assert r["result"]["isError"] is True and "180 s" in r["result"]["content"][0]["text"]
-    assert rpc("tools/call", {"name": "nope", "arguments": {}}).json()["result"]["isError"] is True
-
-
-def test_bridge_rejects_what_it_should(bridge):
-    assert rpc("resources/read").json()["error"]["code"] == -32601
-    assert client.post("/mcp/org/env", content="{nope", headers={"Content-Type": "application/json"}).status_code == 400
-    assert client.post("/mcp/org/env", content=json.dumps([{"jsonrpc": "2.0", "id": 1, "method": "ping"}])).status_code == 400
-    assert client.post("/mcp/org/env", content=json.dumps({"id": 1, "method": "ping"})).status_code == 400
-    assert rpc("ping", **{"Origin": "https://evil.example"}).status_code == 403
-    assert client.post("/mcp/org/env", content="x" * (mcp_bridge.MAX_BODY + 1)).status_code == 413
-    assert client.get("/mcp/org/env").status_code == 405
-    assert client.delete("/mcp/org/env").status_code == 204
-
-
-def test_bridge_is_rate_limited(bridge, monkeypatch):
-    monkeypatch.setattr(mcp_bridge, "RATE", (5, 60))
-    codes = [rpc("ping").status_code for _ in range(8)]
-    assert codes[:5] == [200] * 5 and 429 in codes[5:]
-
-
-def test_bridge_wakes_a_sleeping_space_instead_of_failing(monkeypatch):
-    stub_hub(monkeypatch, stage="SLEEPING")
-    monkeypatch.setattr(live, "probe", lambda spec, fresh=False: {"running": False, "stage": "SLEEPING"})
-    woke = []
-    monkeypatch.setattr(live, "wake", lambda spec: woke.append(spec) or {"stage": "APP_STARTING"})
-    r = rpc("tools/list").json()
-    assert r["error"]["code"] == -32002 and woke == ["org/env"]
-
-
-def test_bridge_passes_through_mcp_content_and_drops_output_schemas(monkeypatch):
-    stub_hub(monkeypatch)
-    info = {**INFO, "mcp": [{"name": "look", "inputSchema": {"type": "object"}, "outputSchema": {"type": "object"}}]}
-    monkeypatch.setattr(live, "probe", lambda spec, fresh=False: info)
-    monkeypatch.setattr(live, "act", lambda *a, **k: {"result": {"content": [{"type": "text", "text": "hi", "annotations": None, "meta": None}],
-                                                                  "structured_content": {"result": "hi"}, "is_error": False}})
-    tools = rpc("tools/list").json()["result"]["tools"]
-    assert all("outputSchema" not in t for t in tools)
-    assert {t["name"] for t in tools} >= {"look", "reset", "state"} and "step" not in {t["name"] for t in tools}
-    r = rpc("tools/call", {"name": "look", "arguments": {}}).json()["result"]
-    assert r["content"] == [{"type": "text", "text": "hi"}] and r["structuredContent"] == {"result": "hi"} and "isError" not in r
-
-
-# ── a server's own routes (NeMo Gym, ORS, custom) ────────────────────────────
-OPENAPI = {"paths": {
-    "/guess": {"post": {"summary": "Guess", "requestBody": {"content": {"application/json": {"schema": {"$ref": "#/components/schemas/G"}}}}}},
-    "/tasks/{task_id}": {"get": {"summary": "A task"}},
-    "//evil.example/x": {"get": {}}, "/a/../b": {"get": {}}, "/q?x=1": {"get": {}}, "/web/x": {"get": {}}, "/reset": {"post": {}},
-    "/self": {"post": {"requestBody": {"content": {"application/json": {"schema": {"$ref": "#/components/schemas/S"}}}}}},
-}, "components": {"schemas": {"G": {"type": "object", "properties": {"word": {"type": "string", "title": "Word"}}, "required": ["word"]},
-                              "S": {"type": "object", "properties": {"next": {"$ref": "#/components/schemas/S"}}}}}}
-
-
-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"), ("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"]
-    assert live._api_routes(OPENAPI, openenv=True) == []          # an OpenEnv server is used through reset/step and tools
-    json.dumps(routes)                                             # a self-referencing schema is cut, not looped
-
-
-def test_route_parameters_cannot_leave_the_route():
-    info = {"api": live._api_routes(OPENAPI, openenv=False)}
-    assert live.route_url(info, "GET", "/tasks/{task_id}", {"task_id": "t-1.2"}) == "/tasks/t-1.2"
-    for bad in ("../admin", "a/b", "x y", "", "%2e%2e"):
-        with pytest.raises(live.SpaceError):
-            live.route_url(info, "GET", "/tasks/{task_id}", {"task_id": bad})
-    with pytest.raises(live.SpaceError):
-        live.route_url(info, "POST", "/not/published", {})
-    with pytest.raises(live.SpaceError):
-        live.route_url(info, "DELETE", "/guess", {})
-
-
-def test_route_calls_keep_their_cookies_and_withhold_answers_from_gets(monkeypatch):
-    stub_hub(monkeypatch)
-    monkeypatch.setattr(live, "probe", lambda spec, fresh=False: {"running": True, "openenv": False, "api": live._api_routes(OPENAPI, openenv=False)})
-    seen = []
-
-    def handler(request: httpx.Request):
-        seen.append((request.method, request.url.path, request.headers.get("cookie")))
-        if request.url.path == "/guess":
-            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 = 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"}
-    out = live.act(sid, "web:a", "http", {"method": "GET", "path": "/tasks/{task_id}", "params": {"task_id": "t1"}})["result"]
-    assert "SECRET" not in json.dumps(out) and "TRUTHVAL" not in json.dumps(out) and set(out["withheld"]) == {"answer", "ground_truth"}
-    assert seen[0][0] == "POST" and seen[1][2] == "session=abc"   # the session's own cookie, kept server-side
-    with pytest.raises(live.SpaceError):
-        live.act(sid, "web:a", "http", {"method": "PUT", "path": "/guess"})
-
-
-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. 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)
-    tools = {t["name"]: t for t in client.get("/api/spaces/o/latex/live").json()["bridge_tools"]}
-    assert set(tools) == {"reset", "step", "state"}
-    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 {t["name"] for t in client.get("/api/spaces/o/geo/live").json()["bridge_tools"]} == {"look", "reset", "state"}

tests/test_mimo.py

@@ -1,187 +0,0 @@
-"""The MiMo release behind the environment contract (app/envs/mimo.py, app/mimo): its tasks read the way the MiMo RL
-Environment Explorer reads them, run as their Harbor conversion or on the release's own harness, and linked to their
-Harbor twins both ways (no network: the release's rows and task views are stubbed; its browsing index is the real one).
-
-What is checked: the MiMo adapter claims the release and nothing else; tiles, scoped facets and the map are coherent;
-every task is a card; a raw row's ref opens the same task; the Harbor twin is the default unless its grader can't score
-here; a rubric task's judge is required and must come from the offered pool; the MiMo runner gets the task and the
-explorer's fields, never a token in its record; a twin links back to the release; a MiMo rollout's page serves its
-events, scrubbed for the public; custom data refuses paths outside the workspace, and raw files are sandboxed.
-"""
-
-from __future__ import annotations
-
-import json
-import time
-
-import pytest
-from fastapi.testclient import TestClient
-
-from app import auth, main, models, settings, store
-from app.envs import contract as c, mimo, registry
-from app.mimo import catalog as mcat
-
-client = TestClient(main.app, base_url="https://testserver")
-TOKEN = "hf_mimo_secret_token_0004"
-SPEC = mimo.SPEC
-GENERAL = "s3k_0052_accounting_audit_tax_en_t2_rl_008"
-
-
-def cookie() -> dict[str, str]:
-    session = {"token": TOKEN, "name": "erin", "avatar": None, "via": "token", "exp": time.time() + 3600}
-    return {"Cookie": f"{auth.COOKIE}={auth._box.encrypt(json.dumps(session).encode()).decode()}"}
-
-
-def view(tid: str) -> dict:
-    rec = mcat.record(tid)
-    d = rec["d"]
-    v = {"id": tid, "domain": d, "title": rec["t"], "short_title": rec["t"], "facets": rec["f"], "brief": "Do the thing.", "meta": [],
-         "image": "docker.io/x:y", "runnable": True, "environment": {"cwd": "/work", "image": "docker.io/x:y"}, "prompt": {"parts": [["task", "Do the thing."]], "task_is_brief": True}}
-    if d == "general":
-        v["verify"] = {"kind": "rubric", "summary": "Checked.", "needs_judge": "text", "formula": "Σ",
-                       "checks": [{"id": "c1", "tier": "critical", "method": "llm", "weight": 2, "question": "Is it right?", "files": []}]}
-    else:
-        v["verify"] = {"kind": "tests", "summary": "Tests.", "files": [{"path": "t.py", "added": 1, "removed": 0, "new": True}], "formula": "1 or 0"}
-    return v
-
-
-@pytest.fixture(autouse=True)
-def stubs(monkeypatch):
-    ids = [e["id"] for e in mcat.index()["envs"]]
-    by_domain: dict[str, list[str]] = {}
-    for e in mcat.index()["envs"]:
-        by_domain.setdefault(e["d"], []).append(e["id"])
-    monkeypatch.setattr(mcat, "rows", lambda: {tid: {"domain": d} for d, tids in by_domain.items() for tid in tids})
-    monkeypatch.setattr(mcat, "view", lambda tid: view(tid) if tid in set(ids) else None)
-    mimo._order.cache_clear(); mimo._position.cache_clear()
-    monkeypatch.setattr(registry, "_meta", lambda kind, spec, token: {"id": spec, "sha": "abc", "restricted": False})
-    monkeypatch.setattr(registry, "_choice", {})
-    monkeypatch.setattr("app.mimo.runner.domains.run_defaults", lambda tid, d: {"steps": 100, "timeout_min": 30, "max_tokens": None})
-    monkeypatch.setattr(models, "get", lambda mid: {"id": mid, "tools": True, "provider": "x"})
-    monkeypatch.setattr(models, "catalog", lambda: {"text_judges": [{"id": "judge/text"}], "vision_judges": [{"id": "judge/vision"}], "agents": []})
-    monkeypatch.setattr(settings, "_org_members", lambda: set())
-    yield
-    mimo._order.cache_clear(); mimo._position.cache_clear()
-
-
-def twin_opt(monkeypatch, warnings=()):
-    """A Harbor twin for every task, whose grader may need a key it won't get here."""
-    from app.envs import harbor
-
-    monkeypatch.setattr(mimo.MiMoAdapter, "_twin", lambda self, tid, d: {"dataset": f"FineEnvs/MiMo-V2.6-RL-harbor-{d}", "path": f"tasks/{tid}"})
-    toml = "[verifier.env]\n" + "".join(f'{k} = "${{{k}}}"\n' for k in warnings)
-    monkeypatch.setattr("app.catalog.task", lambda d, p, t=None: {"runnable": {"ok": True, "how": "image"}, "verifier": {"env": list(warnings)},
-                                                                   "env": {"image": "img"}, "bytes": 1, "toml": toml})
-    return harbor
-
-
-def test_the_release_is_read_by_the_mimo_adapter_only():
-    a = mimo.MiMoAdapter()
-    assert a.detect("dataset", {"id": SPEC}) == 1.0 and a.detect("dataset", {"id": "someone/else"}) == 0
-    assert registry.resolve("dataset", SPEC).adapter.id == "mimo"
-
-
-def test_tiles_facets_and_map_are_coherent():
-    s = client.get(f"/api/env/{SPEC}").json()
-    keys = [f["key"] for f in s["facets"]]
-    assert len(keys) == len(set(keys)), "one facet per key"
-    tiles = {t["value"] for t in s["tiles"]["items"]}
-    assert tiles == {"Code", "Webdev", "Cyber", "Music", "General"} and s["tiles"]["key"] == "domain"
-    for f in s["facets"]:
-        assert set(f["scope"]) <= tiles | {"*"}
-    assert set(s["map"]["by_tile"]) == tiles and all(k in keys for k in s["map"]["by_tile"].values())
-    assert s["order"] == "shuffle" and s["overview"][0]["collapsed"] is True
-
-
-def test_every_task_is_a_card():
-    d = client.get(f"/api/env/{SPEC}/tasks?all=1").json()
-    assert d["total"] == len(mcat.index()["envs"]) == len(d["cards"])
-    assert all(x["facets"]["domain"] and x["color"] for x in d["cards"])
-
-
-def test_a_raw_rows_ref_opens_the_same_task(monkeypatch):
-    twin_opt(monkeypatch)
-    first = mimo._order()["code"][6]
-    v = client.get(f"/api/env/{SPEC}/task?ref=code/train/6").json()
-    assert v["ref"] == first and v["nav"]["index"] == 6
-    assert client.get(f"/api/env/{SPEC}/task?ref=code/train/999999").status_code == 404
-    assert client.get(f"/api/env/{SPEC}/task?ref=nope").status_code == 404
-    # by its own ref, its row is an alias (rollouts recorded against the row are listed with it)
-    assert {"env": SPEC, "ref": "code/train/6"} in client.get(f"/api/env/{SPEC}/task?ref={first}").json()["aliases"]
-
-
-def test_harbor_is_the_default_and_a_model_graded_twin_gets_a_judge(monkeypatch):
-    twin_opt(monkeypatch)
-    code = mimo._order()["code"][0]
-    opts = client.get(f"/api/env/{SPEC}/task?ref={code}").json()["run"]["options"]
-    assert [(o["runner"], o["default"]) for o in opts] == [("harbor", True), ("mimo", False)]
-    assert not any(f["key"] == "judge" for f in opts[0]["fields"])
-    twin_opt(monkeypatch, warnings=["GA_JUDGE_KEY"])   # its grader calls a model: Harbor still runs it, through the relay
-    opts = client.get(f"/api/env/{SPEC}/task?ref={GENERAL}").json()["run"]["options"]
-    assert [(o["runner"], o["default"]) for o in opts] == [("harbor", True), ("mimo", False)]
-    for o in opts:
-        judge = next(f for f in o["fields"] if f["key"] == "judge")
-        assert judge["type"] == "model" and judge["pool"] == "text_judges" and judge["required"]
-
-
-def test_mimo_runs_get_the_task_and_checked_fields(monkeypatch):
-    twin_opt(monkeypatch)
-    from app.mimo.runner import core
-
-    seen = {}
-
-    def fake_submit(user, token, task, model, provider, judge, **kw):
-        seen.update(user=user, token=token, task=task, judge=judge, **kw)
-        return store.create({"id": "20260103-000000-mimo01", "user": user, "task_id": task["id"], "status": "queued", **kw["extra"]})
-
-    monkeypatch.setattr(core, "submit", fake_submit)
-    post = lambda **kw: client.post("/api/runs", json={"dataset": SPEC, "path": GENERAL, "runner": "mimo", "model": "m/x", **kw}, headers=cookie())
-    assert post().status_code == 400                                       # a rubric task needs a judge
-    assert post(fields={"judge": "not/offered"}).status_code == 400        # from the pool only
-    assert post(fields={"judge": "judge/text", "thinking": "loud"}).status_code == 400
-    r = post(fields={"judge": "judge/text", "thinking": "high", "temperature": 0.5})
-    assert r.status_code == 200, r.text
-    assert seen["task"]["id"] == GENERAL and seen["judge"] == "judge/text" and seen["params"] == {"thinking": "high", "temperature": 0.5}
-    assert seen["extra"] == {"dataset": SPEC, "path": GENERAL, "env": SPEC, "adapter": "mimo", "runner": "mimo", "restricted": False, "sha": "abc"}
-    assert TOKEN not in json.dumps(store.get("20260103-000000-mimo01"))
-
-
-def test_a_harbor_twin_links_back_to_the_release():
-    tid = mimo._order()["code"][3]
-    from app.envs.processors import _slug
-
-    env = c.Env("dataset", "FineEnvs/MiMo-V2.6-RL-harbor-code", {}, None)
-    links = mimo.harbor_to_mimo(env, f"tasks/{_slug(tid)}", {})
-    assert links and links[0]["rel"] == "same" and links[0]["href"] == f"/t/{SPEC}/{tid}"
-    assert (SPEC, tid) in mimo.harbor_aliases(env, f"tasks/{_slug(tid)}")
-    assert mimo.harbor_to_mimo(c.Env("dataset", "someone/else", {}, None), f"tasks/{_slug(tid)}", {}) == []
-
-
-def test_a_mimo_rollouts_page_serves_its_events_scrubbed_for_the_public():
-    rid = "20260103-000000-mimo02"
-    store.create({"id": rid, "user": "erin", "task_id": GENERAL, "dataset": SPEC, "path": GENERAL, "runner": "mimo", "status": "done", "reward": 1.0,
-                  "visibility": "public", "title": "T", "model": "m/x", "endpoint": {"base_url": "https://erin.example/v1", "host": "erin.example"}})
-    store.append_events(rid, [{"i": 0, "t": 0, "kind": "text", "text": "hello from erin at https://erin.example/v1"}])
-    mine = client.get(f"/api/runs/{rid}", headers=cookie()).json()
-    assert mine["events"][0]["text"].startswith("hello from erin") and mine["run"]["is_owner"]
-    pub = client.get(f"/api/runs/{rid}").json()
-    assert "erin" not in json.dumps(pub["events"]) and "erin" not in json.dumps(pub["run"])
-    assert client.get(f"/api/runs/{rid}?after=1").json()["events"] == []
-
-
-def test_custom_data_stays_inside_the_workspace(monkeypatch):
-    def outside(tid, rel):
-        raise PermissionError(rel)
-
-    monkeypatch.setattr(mcat, "workspace_path", outside)
-    assert client.get(f"/api/env/{SPEC}/data?ref={GENERAL}&part=preview&path=../../etc/passwd").status_code == 404
-    assert client.get(f"/api/env/{SPEC}/raw?ref={GENERAL}&f=../../etc/passwd").status_code == 404
-    assert client.get(f"/api/env/{SPEC}/data?ref={GENERAL}&part=nothing").status_code == 404
-
-
-def test_raw_files_are_sandboxed(monkeypatch, tmp_path):
-    page = tmp_path / "index.html"
-    page.write_text("<script>alert(1)</script>")
-    monkeypatch.setattr(mcat, "workspace_path", lambda tid, rel: page)
-    r = client.get(f"/api/env/{SPEC}/raw?ref={GENERAL}&f=index.html")
-    assert r.status_code == 200 and r.headers["content-security-policy"] == "sandbox" and r.headers["x-content-type-options"] == "nosniff"

tests/test_model_relay.py

@@ -1,23 +0,0 @@
-from fastapi.testclient import TestClient
-
-from app import main, runner, runtime
-from app.mimo.runner import core
-
-
-def test_local_relay_precedes_capture_catchall_and_keeps_capability_auth(monkeypatch):
-    monkeypatch.setattr(runner, "_service", None)
-    client = TestClient(runner.service().capture.app)
-    monkeypatch.setattr(core, "by_cap", lambda cap: None)
-    assert client.get("/rlx/llm/invalid/health").status_code == 404
-    assert client.post("/rlx/llm/invalid/v1/chat/completions", json={}).status_code == 404
-    assert client.post("/v1/chat/completions", json={"model": "test", "messages": []}).status_code == 401
-    async def relay(cap, request):
-        return {"route": "scoped-relay"}
-    monkeypatch.setattr(main, "llm_proxy", relay)
-    assert client.post("/rlx/llm/test/v1/chat/completions", json={}).json() == {"route": "scoped-relay"}
-
-
-def test_local_and_deployed_capabilities_are_redacted_from_logs():
-    for prefix in ("api", "rlx"):
-        msg = f"POST /{prefix}/llm/SECRET-CAP/v1/chat/completions"
-        assert "SECRET-CAP" not in runtime.SECRET_PATH.sub(lambda m: (m.group(1) or m.group(2)) + "[hidden]", msg)

tests/test_nemo_runner.py

@@ -1,73 +0,0 @@
-import json
-
-import pytest
-
-from app import nemo_runner as runner
-from app.envs import nemogym
-
-
-def row():
-    return {"responses_create_params": {"input": [{"role": "user", "content": "Look up A."},
-                 {"type": "reasoning", "summary": [{"type": "summary_text", "text": "Previous reasoning"}]}],
-                "tools": [{"type": "function", "name": "lookup", "parameters": {"type": "object"}}]},
-            "expected_action": {"type": "function_call", "name": "lookup", "arguments": '{"id":"PRIVATE-ANSWER"}'}}
-
-
-def test_responses_input_preserved_and_answer_withheld():
-    data = row()
-    out = runner.responses_request(data)
-    assert out["input"] == data["responses_create_params"]["input"]
-    assert "PRIVATE-ANSWER" not in json.dumps(out)
-
-
-def test_provider_hosted_tools_cannot_execute():
-    data = row()
-    data["responses_create_params"]["tools"] = [{"type": "mcp", "server_url": "https://example.com", "require_approval": "never"}]
-    with pytest.raises(ValueError, match="Only function"):
-        runner.responses_request(data)
-
-
-def test_native_comparator_scores_arguments_and_calls_before_text():
-    data = row()
-    agent = nemogym.agent_of({}, "nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1")
-    expected = runner.validate(data, agent)
-    response = {"output": [{"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "Looking it up"}]},
-                           {"type": "function_call", "name": "lookup", "arguments": '{"id":"PRIVATE-ANSWER"}'}]}
-    assert runner.score(expected, runner.prediction(response))[0] == 1
-    response["output"][1]["arguments"] = '{"id":"wrong"}'
-    assert runner.score(expected, runner.prediction(response))[0] == 0
-    response["output"][1]["arguments"] = 'not json'
-    assert runner.score(expected, runner.prediction(response))[0] == 0
-
-
-def test_invalid_reference_does_not_leak_through_errors():
-    data = row()
-    data["expected_action"] = {"type": "PRIVATE-ANSWER"}
-    with pytest.raises(ValueError) as e:
-        runner.validate(data, nemogym.agent_of({}, "nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1"))
-    assert "PRIVATE-ANSWER" not in str(e.value)
-
-
-def test_unknown_nemo_server_stays_native():
-    with pytest.raises(ValueError, match="not hosted"):
-        runner.validate(row(), {"known": True, "resources_server": "another_server"})
-
-
-def test_provider_failure_inside_http_200_is_not_a_zero_reward():
-    with pytest.raises(ValueError, match="did not produce a prediction"):
-        runner.prediction({"status": "failed", "error": {"message": "invalid schema"}, "output": []})
-    with pytest.raises(ValueError, match="invalid Responses"):
-        runner.prediction({"message": "not a response"})
-
-
-def test_invalid_strict_declaration_is_relaxed_without_changing_parameters():
-    data = row()
-    tool = data["responses_create_params"]["tools"][0]
-    tool["strict"] = True
-    original = json.dumps(data)
-    request = runner.responses_request(data)
-    assert request["tools"][0]["strict"] is False
-    assert request["tools"][0]["parameters"] == tool["parameters"]
-    assert json.dumps(data) == original
-    tool["parameters"].update(properties={}, required=[], additionalProperties=False)
-    assert runner.responses_request(data)["tools"][0]["strict"] is True

tests/test_remote_mcp.py

@@ -1,62 +0,0 @@
-"""Standard MCP sessions preserve cookies, negotiated headers and reply identity."""
-import json
-
-import httpx
-import pytest
-
-from app import spaces_live as live
-
-
-def test_standard_mcp_initializes_isolates_and_closes_sessions():
-    seen, next_id = [], []
-    def handle(request):
-        seen.append(request)
-        if request.method == "DELETE":
-            return httpx.Response(204)
-        message = json.loads(request.content)
-        if message["method"] == "initialize":
-            sid = str(len(next_id) + 1)
-            next_id.append(sid)
-            return httpx.Response(200, headers={"Mcp-Session-Id": sid, "Set-Cookie": f"episode={sid}; Path=/"},
-                                  json={"jsonrpc": "2.0", "id": message["id"], "result": {"protocolVersion": "2025-06-18"}})
-        sid = request.headers["mcp-session-id"]
-        assert request.headers["mcp-protocol-version"] == "2025-06-18"
-        assert request.headers["cookie"] == f"episode={sid}"
-        if message["method"] == "notifications/initialized":
-            assert "id" not in message
-            return httpx.Response(202)
-        # A progress notification is not the result; the actual event has multi-line data.
-        event = json.dumps({"jsonrpc": "2.0", "id": message["id"], "result": {"episode": sid}}, indent=2)
-        text = 'data: {"jsonrpc":"2.0","method":"notifications/progress"}\n\n' + '\n'.join('data: '+line for line in event.splitlines())+'\n\n'
-        return httpx.Response(200, headers={"Content-Type": "text/event-stream"}, text=text)
-    with live.SpaceClient(transport=httpx.MockTransport(handle)) as a, live.SpaceClient(transport=httpx.MockTransport(handle)) as b:
-        first = live.RemoteMCP({"host": "https://fixture.hf.space"}, a)
-        second = live.RemoteMCP({"host": "https://fixture.hf.space"}, b)
-        assert first.call("tools/call", {}, 2) == {"episode": "1"}
-        assert second.call("tools/call", {}, 2) == {"episode": "2"}
-        assert first.call("tools/call", {}, 2) == {"episode": "1"}
-        first.close()
-        second.close()
-    assert len(next_id) == 2
-    assert [r.headers["mcp-session-id"] for r in seen if r.method == "DELETE"] == ["1", "2"]
-
-
-def test_expired_mcp_session_does_not_replay_or_reinitialize():
-    calls = []
-    def handle(request):
-        calls.append(request)
-        return httpx.Response(404)
-    with live.SpaceClient(transport=httpx.MockTransport(handle)) as c:
-        remote = live.RemoteMCP({"host": "https://fixture.hf.space"}, c)
-        remote.initialized, remote.session = True, "existing"
-        for _ in range(2):
-            with pytest.raises(live.SpaceError) as error:
-                remote.call("tools/call", {"name": "step"}, 2)
-            assert error.value.status == 410
-        assert len(calls) == 1
-
-
-def test_mcp_rejects_an_unrelated_rpc_response():
-    with live.SpaceClient(transport=httpx.MockTransport(lambda r: httpx.Response(200, json={"jsonrpc": "2.0", "id": "other", "result": {}}))) as c:
-        with pytest.raises(live.SpaceError, match="matching"):
-            live.RemoteMCP({"host": "https://fixture.hf.space"}, c).call("tools/list", {}, 2)

tests/test_search_api.py

@@ -1,629 +0,0 @@
-"""/api/search and /api/search/tasks (app/search_api.py) over a catalog snapshot (no network: the listing is fixture rows).
-
-What is checked: declared framework taxonomy independent of editorial collections; metric-only trending with
-separate featured picks; hidden environments left out of everything at query time; every answer (order, total, every
-facet's counts) equal to a plain-Python port of the page's own filtering over the same rows, for hundreds of queries
-(a parity test), through a published snapshot and through the live fallback alike; search text never read as FTS
-syntax; the visitor's own private datasets merged in; cache headers and ETags.
-"""
-
-from __future__ import annotations
-
-import gzip
-import json
-import random
-import shutil
-import time
-from pathlib import Path
-
-import pytest
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-
-from app import catalog, config, indexer, search_api, snapshot
-
-app = FastAPI()
-app.include_router(search_api.router)
-client = TestClient(app)
-
-TAGS = ["code", "agents", "math", "terminal", "swe", "sql", "vision", "a\"quote", "c++", "日本語", "NEAR", "tool-use"]
-COLLS = [{"id": "fineenvs", "group": "FineEnvs on OpenEnv", "icon": "globe", "color": "amber", "about": "ours",
-          "ids": ["space:fe/geo", "space:fe/latex", "space:fe/ors-one", "space:fe/plain"]},
-         {"id": "terminal", "group": "Terminal-Bench", "icon": "terminal", "color": "cyber", "about": "terminal tasks",
-          "ids": ["tb/bench-1", "tb/bench-2", "space:fe/plain"]}]   # fe/plain is in both: the first one counts
-PINS = ["space:fe/latex", "ds/d07"]
-HIDDEN = {"ds/d13", "space:sp/s05"}
-
-
-def rows_fixture(n_ds: int = 30, n_sp: int = 40, seed: int = 7) -> list[dict]:
-    """Listing rows as catalog.environments() returns them (datasets' framework already resolved), varied enough to
-    exercise every facet, sort and tie."""
-    rnd = random.Random(seed)
-    fws = ["harbor", "harbor", "harbor", "verifiers", "nemo-gym", "openenv-data", "verl", "rows", None]
-    out = []
-    for i in range(n_ds):
-        fw = fws[i % len(fws)]
-        tasks = rnd.choice([None, None, 0, 5, 99, 100, 999, 1000, 4000]) if fw in ("harbor", None) else None
-        out.append({"id": f"ds/d{i:02d}", "key": f"ds/d{i:02d}", "kind": "dataset", "framework": fw,
-                    "heading": rnd.choice([None, f"Bench {i}", "Terminal tasks", "Data analysis"]),
-                    "brief": rnd.choice(["", "Agents solve SQL tasks in a sandbox.", "Hard math, graded by tests.", "Tools and C++ builds."]),
-                    "downloads": rnd.choice([0, 5, 50, 9999, 20000, 5]), "likes": rnd.choice([0, 1, 1, 3, 40]),
-                    "trending": rnd.choice([0, 0, 1, 2, 5]), "updated": f"2026-0{rnd.randint(1, 9)}-1{rnd.randint(0, 9)}T10:00:00+00:00",
-                    "created": rnd.choice([None, "2025-01-02T00:00:00.123+00:00", f"2026-0{rnd.randint(1, 9)}-01T00:00:00Z"]),
-                    "badges": rnd.choice([[], ["RL Environment"], ["Benchmark"], ["RL Environment", "Benchmark"]]),
-                    "tags": rnd.sample(TAGS, rnd.randint(0, 4)), "private": False, "gated": False,
-                    "indexed": {"tasks": tasks, "graded": {"txt": 3}, "image": 1} if tasks is not None else None})
-    out += [{"id": "tb/bench-1", "key": "tb/bench-1", "kind": "dataset", "framework": "harbor", "heading": "TB one", "brief": "Terminal",
-             "downloads": 100, "likes": 2, "trending": 3, "badges": ["Benchmark"], "tags": ["terminal"], "indexed": {"tasks": 89},
-             "updated": "2026-10-01T00:00:00+00:00"},
-            {"id": "tb/bench-2", "key": "tb/bench-2", "kind": "dataset", "framework": "verifiers", "heading": None, "brief": "x" * 40,
-             "downloads": 100, "likes": 2, "trending": 3, "badges": [], "tags": [], "indexed": None}]
-    for i in range(n_sp):
-        fw = rnd.choice(["openenv", "openenv", "openenv", "ors", "space"])
-        out.append({"id": f"sp/s{i:02d}", "key": f"space:sp/s{i:02d}", "kind": "space", "framework": fw, "openenv": fw == "openenv",
-                    "heading": rnd.choice([None, f"Game {i}", "Wordle"]), "brief": rnd.choice(["", "Play a game.", "An OCR env."]),
-                    "downloads": 0, "likes": rnd.choice([0, 1, 2, 2, 10]), "trending": rnd.choice([0, 1, 1, 4]),
-                    "updated": rnd.choice([None, f"2026-0{rnd.randint(1, 9)}-0{rnd.randint(1, 9)}T00:00:00+00:00"]),
-                    "created": f"2025-1{rnd.randint(0, 2)}-01T00:00:00+00:00", "stage": rnd.choice(["RUNNING", "SLEEPING", None, "RUNTIME_ERROR"]),
-                    "mcp": rnd.random() < 0.3, "openenv_version": rnd.choice([None, None, "0.2.1", "0.2.3"]) if fw == "openenv" else None,
-                    "badges": ["OpenEnv"] if fw == "openenv" else ["ORS"] if fw == "ors" else [], "tags": rnd.sample(TAGS, rnd.randint(0, 3)),
-                    "private": False, "gated": False, "hardware": "cpu-basic", "manifest": "openenv.yaml" if fw == "openenv" else None})
-    for sid, fw in (("fe/geo", "openenv"), ("fe/latex", "space"), ("fe/ors-one", "ors"), ("fe/plain", "space")):
-        out.append({"id": sid, "key": f"space:{sid}", "kind": "space", "framework": fw, "openenv": fw == "openenv", "heading": sid,
-                    "brief": "FineEnvs server", "downloads": 0, "likes": 1, "trending": 0, "stage": "RUNNING", "mcp": True,
-                    "badges": ["OpenEnv"] if fw == "openenv" else ["ORS"] if fw == "ors" else [], "tags": ["agents"]})
-    out.append({"id": "priv/secret", "key": "priv/secret", "kind": "dataset", "framework": "harbor", "private": True, "heading": "Secret",
-                "brief": "", "tags": [], "badges": [], "downloads": 0, "likes": 0, "trending": 99})
-    return out
-
-
-ROWS = rows_fixture()
-
-
-def write_index(spec: str, tasks: list[dict], restricted: bool = False) -> None:
-    idx = {"spec": spec, "sha": "abc", "built": 1.0, "version": catalog.INDEX_VERSION, "info": {"restricted": restricted},
-           "tasks": tasks, "summary": {}}
-    catalog.atomic_write(catalog._index_path(spec), gzip.compress(json.dumps(idx).encode()))
-
-
-TASKS = {"ds/d00": [{"path": "tasks/sql-join", "title": "Join two tables in SQL", "brief": "Write a query.", "category": "sql",
-                     "difficulty": "easy", "tags": ["sql"], "verifier": {"kind": "txt"}, "env": {}, "run": "image"},
-                    {"path": "tasks/foo-only", "title": "Foo the bar", "brief": "Nothing else.", "category": "misc", "tags": [],
-                     "verifier": {}, "env": {}}],
-         "ds/d13": [{"path": "tasks/hidden-one", "title": "Join hidden tables", "brief": "", "tags": [], "verifier": {}, "env": {}}],
-         "priv/secret": [{"path": "tasks/s", "title": "Join secret tables", "brief": "", "tags": [], "verifier": {}, "env": {}}]}
-
-
-@pytest.fixture(autouse=True)
-def stubs(monkeypatch, tmp_path):
-    monkeypatch.setattr(catalog, "collections", lambda: COLLS)
-    monkeypatch.setattr(catalog, "pinned", lambda: list(PINS))
-    monkeypatch.setattr(catalog, "hidden", lambda: set(HIDDEN))
-    monkeypatch.setattr(catalog, "environments", lambda include_hidden=False: [r for r in ROWS if include_hidden or r["key"] not in HIDDEN])
-    monkeypatch.setattr(search_api, "rollout_counts", lambda: {"ds/d03": 4, "ds/d05": 1, "sp/s01": 2})
-    monkeypatch.setenv("RLX_SNAPSHOT_LOCAL", str(tmp_path / "local"))
-    monkeypatch.setenv("RLX_SNAPSHOT_STORE", str(tmp_path / "store"))
-    for spec, tasks in TASKS.items():
-        write_index(spec, tasks)
-    snapshot.reset()
-    search_api._answers.clear()
-    yield
-    snapshot.reset()
-    for spec in TASKS:
-        catalog._index_path(spec).unlink(missing_ok=True)
-
-
-def publish_fixture(tmp_path: Path) -> dict:
-    """ROWS as a published snapshot in the test store (as the indexer would: raw rows, admin settings left out)."""
-    store = snapshot.LocalStore(tmp_path / "store")
-    db = tmp_path / "build.db"
-    public = [r["id"] for r in ROWS if r["kind"] == "dataset"]
-    counts = snapshot.build_db(db, ROWS, snapshot.iter_index_tasks(public, mimo=False))
-    return indexer.publish(store, db, counts)
-
-
-def fw_js(d: dict) -> str:
-    """No runtime evidence in the base fixture: metadata only supplies candidates."""
-    if d["kind"] == "space":
-        return "unverified-space" if d.get("framework") == "openenv" or d.get("openenv") else "other-space"
-    return d.get("framework") or "harbor"
-
-
-def visible() -> list[dict]:
-    return [r for r in ROWS if r["key"] not in HIDDEN and not r.get("private")]
-
-
-# ── the taxonomy and the orders ──────────────────────────────────────────────
-@pytest.mark.parametrize("mode", ["snapshot", "live"])
-def test_kind_taxonomy(tmp_path, mode):
-    if mode == "snapshot":
-        publish_fixture(tmp_path)
-    d = client.get("/api/search?size=100").json()
-    assert d["snapshot"]["source"] == mode
-    expected: dict[str, int] = {}
-    for r in visible():
-        k = fw_js(r)
-        expected[k] = expected.get(k, 0) + 1
-    assert {k: v for k, v in d["facets"]["kind"].items() if k != "all"} == expected
-    assert d["facets"]["kind"]["all"] == d["total"] == len(visible())
-    assert expected["other-space"] > 0 and expected["unverified-space"] > 0
-    cards = {c["key"]: c for c in d["rows"]}
-    # Collections cannot supply framework evidence, including for FineEnvs.
-    assert all(c["fw"] == "other-space" for c in cards.values() if c["kind"] == "space" and c["collection"] != "fineenvs" and c["framework"] == "ors")
-    for key in ("space:fe/latex", "space:fe/ors-one", "space:fe/plain"):
-        assert cards[key]["fw"] == "other-space" and not cards[key]["openenv"]
-    assert cards["space:fe/plain"]["collection"] == "fineenvs"   # the first collection naming it
-    assert cards["ds/d08"]["fw"] == "harbor"                      # no framework at all: Harbor, as the page reads it
-    for k in expected:
-        sub = client.get(f"/api/search?kind={k}&size=100").json()
-        assert sub["total"] == expected[k] and all(c["fw"] == k for c in sub["rows"])
-    assert client.get("/api/search?k=ors").json()["query"]["kind"] == "other-space"   # the page's old links
-
-
-def test_trending_uses_metrics_and_featured_is_separate(tmp_path):
-    publish_fixture(tmp_path)
-    rows = client.get("/api/search?size=100").json()["rows"]
-    want = sorted(visible(), key=lambda r: (-r["trending"], -r["likes"], -r["downloads"]))
-    assert [r["key"] for r in rows] == [r["key"] for r in want]
-    oe = client.get("/api/search?kind=unverified-space&size=100").json()["rows"]
-    assert [r["key"] for r in oe] == [r["key"] for r in want if fw_js(r) == "unverified-space"]
-    assert client.get("/api/search?kind=unverified-space&sort=likes&size=100").json()["rows"][0]["likes"] == max(r["likes"] for r in oe)
-    trending = client.get("/api/search?trending=5&facets=0").json()["trending"]
-    assert [r["key"] for r in trending] == [r["key"] for r in rows[:5]]
-    assert [r["key"] for r in client.get("/api/search?trending=5").json()["featured"]] == PINS
-    filtered = client.get("/api/search?kind=unverified-space&trending=48").json()
-    assert filtered["featured"] == []
-    assert [r["key"] for r in filtered["trending"]] == [r["key"] for r in oe]
-
-
-def test_hidden_environments_are_left_out_everywhere(tmp_path):
-    publish_fixture(tmp_path)
-    d = client.get("/api/search?size=100&trending=48").json()
-    keys = {r["key"] for r in d["rows"]} | {r["key"] for r in d["trending"]}
-    assert not keys & HIDDEN and "priv/secret" not in keys
-    assert d["stats"]["datasets"] + d["stats"]["spaces"] == len(visible())
-    assert client.get("/api/search?q=d13").json()["total"] == 0
-    assert client.get("/api/search/tasks?q=join").json()["rows"] == [
-        {"env": "ds/d00", "ref": "tasks/sql-join", "title": "Join two tables in SQL", "brief": "Write a query.", "category": "sql",
-         "difficulty": "easy", "grading": "txt", "run": "image"}]    # not the hidden one's, nor the private one's
-
-
-def test_an_admin_hiding_shows_without_a_new_snapshot(tmp_path, monkeypatch):
-    publish_fixture(tmp_path)
-    before = client.get("/api/search?q=d01").json()["total"]
-    assert client.get("/api/search?q=d01").json()["total"] == before == 1   # answered again (from memory)
-    monkeypatch.setattr(catalog, "hidden", lambda: set(HIDDEN) | {"ds/d01"})
-    assert client.get("/api/search?q=d01").json()["total"] == 0              # a settings change is a new question
-
-
-def test_recent_openenv_checks_versions_and_trending_use_same_filters(tmp_path, monkeypatch):
-    from app import space_checks
-    import time
-    publish_fixture(tmp_path)
-    now = time.time()
-    evidence = {"fe/geo": {"schema": 1, "id": "fe/geo", "stage": "RUNNING", "checked_at": now,
-                            "status": "API checked", "mode": "Simulation", "tools": 0,
-                            "version": {"value": "0.2.3", "source": "Lockfile"}}}
-    monkeypatch.setattr(space_checks, "inventory", lambda: evidence)
-    params = {"kind": "openenv", "f": "health:API%20checked;oe:0.2.3", "trending": "24"}
-    data = client.get("/api/search", params=params).json()
-    assert data["total"] == 1
-    assert [r["id"] for r in data["rows"]] == [r["id"] for r in data["trending"]] == ["fe/geo"]
-    assert data["rows"][0]["version_source"] == "Lockfile"
-    assert data["rows"][0]["tools_status"] == "No tools discovered"
-    assert data["facets"]["oe"] == [["0.2.3", 1]]
-    assert client.get("/api/search", params={**params, "f": "health:API%20checked;tools:Tools%20discovered"}).json()["total"] == 0
-    # Negative checks and expiration invalidate cached search responses too.
-    evidence["fe/geo"]["status"] = "Checks failed"
-    assert client.get("/api/search", params=params).json()["total"] == 0
-    evidence["fe/geo"].update(status="API checked", checked_at=now - space_checks.FRESH - 1)
-    assert client.get("/api/search", params=params).json()["total"] == 0
-    expired = client.get("/api/search", params={"f": "health:Check%20expired"}).json()
-    assert expired["total"] == 1 and expired["rows"][0]["api_status"] == "Check expired"
-
-
-def test_sql_python_parity_for_api_evidence(tmp_path, monkeypatch):
-    from app import space_checks
-    import time
-    publish_fixture(tmp_path)
-    now = time.time()
-    statuses = ["API checked", "Checks failed", "Not running", "Check unavailable"]
-    evidence = {r["id"]: {"id": r["id"], "status": statuses[i % 4], "checked_at": now - (i % 5) * 1000,
-                          "mode": "Simulation", "tools": i % 3, "version": {"value": ">=0.2.3", "source": "Dependency constraint"}}
-                for i, r in enumerate(ROWS) if r.get("kind") == "space"}
-    monkeypatch.setattr(space_checks, "inventory", lambda: evidence)
-    ctx = search_api.context()
-    cards = search_api.py_cards([r for r in ROWS if not r.get("private")], ctx)
-    with snapshot.use() as (_, conn):
-        for facet, value in [("health", "API checked"), ("health", "Check expired"), ("health", "Not checked"),
-                             ("mode", "Simulation"), ("tools", "Tools discovered"), ("oe", ">=0.2.3"),
-                             ("oe_source", "Dependency constraint")]:
-            q = search_api.Query(size=100, sel={facet: [value]})
-            actual, expected = search_api.sql_search(conn, q, ctx), search_api.py_search(cards, q)
-            assert actual["total"] == expected["total"]
-            assert actual["facets"] == expected["facets"]
-            assert [r["id"] for r in actual["rows"]] == [r["id"] for r in expected["matches"]]
-
-
-# ── parity with the page's own filtering ─────────────────────────────────────
-def random_queries(n: int, seed: int = 3) -> list[search_api.Query]:
-    rnd = random.Random(seed)
-    words = ["", "", "a", "te", "sql", "bench", "game ocr", "s0", "C++", "日本", "\"", "near", "x" * 41, "d1 tasks"]
-    out = []
-    for _ in range(n):
-        sel = {}
-        for k, vals in (("type", ["Neither", "Benchmark", "OpenEnv", "ORS", "RL Environment"]),
-                        ("size", ["Under 100", "100 to 1,000", "1,000 or more", "Not indexed yet"]),
-                        ("stage", ["Running", "Sleeping", "Error", "Unknown"]), ("mcp", ["MCP tagged", "No MCP tag"]),
-                        ("evidence", ["Manifest present", "Hub tag only"]),
-                        ("oe", ["0.2.1", "0.2.3"]), ("tags", TAGS)):
-            if rnd.random() < 0.2:
-                sel[k] = rnd.sample(vals, rnd.randint(1, 2))
-        out.append(search_api.Query(q=rnd.choice(words), kind=rnd.choice(search_api.KINDS), sort=rnd.choice(search_api.SORTS),
-                                    coll=rnd.choice([None, None, "fineenvs", "terminal", "other"]), sel=sel))
-    return out
-
-
-@pytest.mark.parametrize("mode", ["snapshot", "live"])
-def test_parity_with_the_pages_filtering(tmp_path, mode):
-    if mode == "snapshot":
-        publish_fixture(tmp_path)
-    ctx = search_api.context()
-    cards = search_api.py_cards([r for r in ROWS if not r.get("private")], ctx)
-    with snapshot.use() as (snap, conn):
-        assert snap.source == mode
-        for q in random_queries(300):
-            got = search_api.sql_search(conn, q, ctx, limit=1000, offset=0)
-            want = search_api.py_search(cards, q)
-            assert [r["key"] for r in got["rows"]] == [d["key"] for d in want["matches"]], q
-            assert got["total"] == want["total"], q
-            for k in ("kind", "collection", *search_api.FACETS):
-                assert got["facets"][k] == want["facets"][k], (q, k)
-
-
-def test_api_facets_match_the_reference(tmp_path):
-    publish_fixture(tmp_path)
-    ctx = search_api.context()
-    cards = search_api.py_cards([r for r in ROWS if not r.get("private")], ctx)
-    for qs, q in [("f=tags:sql|code;type:Neither", search_api.Query(sel={"tags": ["sql", "code"], "type": ["Neither"]})),
-                  ("k=openenv&f=stage:Running&s=updated", search_api.Query(kind="openenv", sel={"stage": ["Running"]}, sort="updated")),
-                  ("c=other&q=game&sort=new", search_api.Query(coll="other", q="game", sort="new")),
-                  ("f=tags:a%22quote", search_api.Query(sel={"tags": ['a"quote']}))]:
-        d = client.get(f"/api/search?{qs}&size=100").json()
-        want = search_api.py_search(cards, q)
-        assert d["total"] == want["total"] and [r["key"] for r in d["rows"]] == [x["key"] for x in want["matches"]][:100]
-        for k in search_api.FACETS:
-            assert d["facets"][k] == search_api._rank(want["facets"][k]), k
-        assert d["facets"]["collection"] == want["facets"]["collection"]
-
-
-def test_paging_covers_every_match_once(tmp_path):
-    publish_fixture(tmp_path)
-    total = client.get("/api/search?facets=0").json()["total"]
-    seen = []
-    for page in range(1, 20):
-        rows = client.get(f"/api/search?sort=likes&page={page}&size=7&facets=0").json()["rows"]
-        if not rows:
-            break
-        seen += [r["key"] for r in rows]
-    assert len(seen) == len(set(seen)) == total
-
-
-# ── search text is data, never FTS syntax ────────────────────────────────────
-NASTY = ['"', '""', '"unbalanced', 'NEAR(a b)', 'NEAR(sql, 2)', 'a*', '*', '^sql', 'title:sql', 'brief:x', '{id heading}:sql',
-         'AND', 'OR', 'NOT', 'sql OR math', 'sql NOT math', '(sql', 'sql)', '-sql', '+sql', "'; DROP TABLE envs; --",
-         '\x00sql', 'c++', '日本語', '%', '_', '\\', 'a" OR "b', 'sql"*', ':', '"" ""', 'NEAR', 'near(']
-
-
-@pytest.mark.parametrize("text", NASTY)
-def test_search_text_cant_inject(tmp_path, text):
-    publish_fixture(tmp_path)
-    r = client.get("/api/search", params={"q": text, "size": 100})
-    assert r.status_code == 200
-    q = search_api.Query(q=text.strip())
-    want = search_api.py_search(search_api.py_cards([x for x in ROWS if not x.get("private")], search_api.context()), q)
-    assert [x["key"] for x in r.json()["rows"]] == [d["key"] for d in want["matches"]]
-    t = client.get("/api/search/tasks", params={"q": text})
-    assert t.status_code == 200 and isinstance(t.json()["rows"], list)
-
-
-def test_fts_expressions_are_quoted():
-    assert search_api.envs_fts_query(['a"b', "near(x", "ab"]) == '"a""b" "near(x"'
-    assert search_api.tasks_fts_query('NEAR(sql OR "x*" title:join ^z)') == '"near"* "sql"* "or"* "x"* "title"* "join"* "z"*'
-    assert search_api.tasks_fts_query('"*" -- ()') is None
-    assert search_api.tasks_fts_query("a " * 50).count("*") == 8
-
-
-def test_task_search_operators_are_words(tmp_path):
-    publish_fixture(tmp_path)
-    assert [r["ref"] for r in client.get("/api/search/tasks?q=foo").json()["rows"]] == ["tasks/foo-only"]
-    assert client.get("/api/search/tasks?q=foo OR join").json()["total"] == 0     # OR is a word to find, not an operator
-    assert client.get("/api/search/tasks?q=NEAR(foo bar)").json()["total"] == 0   # nor NEAR ("near" isn't in it)
-    assert client.get("/api/search/tasks?q=NOT foo").json()["total"] == 1          # "not" finds "Nothing": a word
-    assert client.get("/api/search/tasks?q=jo").json()["total"] == 1             # prefixes
-    assert client.get("/api/search/tasks?q=join&env=ds/d01").json()["total"] == 0
-    assert client.get("/api/search/tasks?q=join&env=../x").status_code == 400
-
-
-# ── the visitor's own, headers ───────────────────────────────────────────────
-def test_mine_merges_private_datasets(tmp_path, monkeypatch):
-    publish_fixture(tmp_path)
-    mine = [{"id": "me/private-ds", "key": "me/private-ds", "kind": "dataset", "framework": "harbor", "private": True, "heading": "Mine",
-             "brief": "my sql tasks", "tags": ["sql"], "badges": [], "downloads": 0, "likes": 0, "trending": 50, "indexed": {"tasks": 3}},
-            {**next(r for r in ROWS if r["id"] == "ds/d02"), "mine": True}]
-    monkeypatch.setattr(search_api, "_mine_rows", lambda request: mine)
-    d = client.get("/api/search?mine=1&c=mine&size=100").json()
-    assert {r["key"] for r in d["rows"]} == {"me/private-ds", "ds/d02"} and d["total"] == 2
-    assert d["facets"]["collection"]["mine"] == 2 and d["mine"] == 2
-    top = client.get("/api/search?mine=1&trending=3").json()
-    assert top["trending"][0]["key"] == "me/private-ds"
-    assert [r["key"] for r in top["featured"]] == PINS
-    own = client.get("/api/search?mine=1&c=mine&trending=24").json()
-    assert {r["key"] for r in own["trending"]} == {"me/private-ds", "ds/d02"}
-    assert top["total"] == len(visible()) + 1 and top["stats"]["datasets"] == sum(1 for r in visible() if r["kind"] == "dataset") + 1
-    assert next(r for r in top["rows"] if r["key"] == "me/private-ds")["private"] is True
-    r = client.get("/api/search?mine=1")
-    assert r.headers["cache-control"].startswith("private") and r.headers["vary"] == "Cookie"
-    monkeypatch.setattr(search_api, "_mine_rows", lambda request: None)   # signed out: "mine" is no filter
-    assert client.get("/api/search?mine=1&c=mine").json()["query"]["collection"] is None
-
-
-def test_cache_headers_and_etag(tmp_path):
-    publish_fixture(tmp_path)
-    r = client.get("/api/search?q=sql")
-    assert r.headers["cache-control"].startswith("public, max-age=") and r.headers["etag"].startswith('W/"')
-    again = client.get("/api/search?q=sql", headers={"If-None-Match": r.headers["etag"]})
-    assert again.status_code == 304 and not again.content
-    assert client.get("/api/search/tasks?q=sql").headers["cache-control"].startswith("public")
-
-
-def test_responses_are_cards_only(tmp_path):
-    publish_fixture(tmp_path)
-    d = client.get("/api/search?trending=24").json()
-    assert len(d["rows"]) == 40 and len(d["trending"]) == 24
-    assert set(d["rows"][0]) == {"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", "evidence", "stage_label",
-                                 "api_check", "api_status", "api_mode", "declared_version", "version_source", "tools_status"}
-    assert [c["id"] for c in d["collections"]] == ["fineenvs", "terminal"] and "ids" not in d["collections"][0]
-    assert client.get("/api/search?q=ds/d03").json()["rows"][0]["rollouts"] == 4
-    assert len(client.get("/api/search?trending=24").content) < 60_000
-
-
-def test_rollouts_sort(tmp_path):
-    publish_fixture(tmp_path)
-    rows = client.get("/api/search?sort=rollouts&size=3").json()["rows"]
-    assert [r["id"] for r in rows] == ["ds/d03", "sp/s01", "ds/d05"]
-
-
-def teardown_module(module):
-    shutil.rmtree(Path(config.STORAGE_DIR) / "snapshots", ignore_errors=True)
-
-
-def test_environments_helper_for_whole_listing_readers(tmp_path, monkeypatch):
-    publish_fixture(tmp_path)
-    rows = search_api.environments()
-    assert [r["key"] for r in rows] == [r["key"] for r in ROWS if r["key"] not in HIDDEN and not r.get("private")]   # listing order
-    by = {r["key"]: r for r in rows}
-    assert by["space:fe/plain"]["framework"] == "space" and by["space:fe/plain"]["collection"] == "fineenvs"
-    assert by["ds/d07"]["pinned"] and not by["ds/d07"]["gated"] and not by["ds/d07"]["private"]
-    assert {r["key"] for r in search_api.environments(include_hidden=True)} >= HIDDEN
-
-
-def test_the_visitors_datasets_never_make_a_search_wait(monkeypatch):
-    from app import auth
-
-    calls = []
-
-    def mine(token):
-        calls.append(token)
-        return [{"id": f"me/v{len(calls)}"}]
-
-    monkeypatch.setattr(auth, "current_user", lambda request: {"name": "me", "token": "hf_secret_token"})
-    monkeypatch.setattr(catalog, "mine", mine)
-    search_api._mine.clear()
-    assert search_api._mine_rows(None)[0]["id"] == "me/v1" and search_api._mine_rows(None)[0]["id"] == "me/v1" and len(calls) == 1
-    who = next(iter(search_api._mine))
-    assert "hf_secret_token" not in who
-    search_api._mine[who] = (search_api._mine[who][0] - search_api.MINE_FRESH - 1, search_api._mine[who][1])
-    assert search_api._mine_rows(None)[0]["id"] == "me/v1"          # stale: answered at once...
-    for _ in range(100):
-        if search_api._mine[who][1][0]["id"] == "me/v2":
-            break
-        time.sleep(0.02)
-    assert search_api._mine[who][1][0]["id"] == "me/v2"             # ...and refreshed behind it
-    monkeypatch.setattr(auth, "current_user", lambda request: None)
-    assert search_api._mine_rows(None) is None
-
-
-def test_a_spaces_rank_matches_the_trending_order_without_the_listing(tmp_path):
-    publish_fixture(tmp_path)
-    key = lambda d: (-d["trending"], -d["likes"], -(d.get("downloads") or 0))
-    spaces = [r for r in visible() if r["kind"] == "space"]
-    order = sorted(spaces, key=key)
-    for i in (0, len(order) // 2, len(order) - 1):
-        r = client.get(f"/api/search/rank?key={order[i]['key']}")
-        assert r.status_code == 200 and r.json() == {"n": i + 1, "of": len(order)}, order[i]["key"]
-    assert client.get(f"/api/search/rank?key={next(iter(HIDDEN))}").status_code == 404   # hidden: not ranked
-    assert client.get("/api/search/rank?key=space:nobody/nothing").status_code == 404
-
-
-def test_runtime_and_evidence_filters_and_census_agree(tmp_path):
-    publish_fixture(tmp_path)
-    d = client.get("/api/search?kind=unverified-space&size=100").json()
-    assert sum(d["stats"]["openenv"].values()) == d["total"]
-    for evidence, count in d["stats"]["openenv"].items():
-        r = client.get("/api/search", params={"kind": "unverified-space", "f": f"evidence:{evidence}", "trending": 48, "size": 100}).json()
-        assert r["total"] == count
-        assert all(x["evidence"] == evidence for x in r["rows"] + r["trending"])
-    running = client.get("/api/search?kind=unverified-space&f=stage:Running").json()
-    assert running["total"] == d["stats"]["openenv_running"]
-    errors = client.get("/api/search?f=stage:Error&size=100").json()
-    assert errors["total"] and all(r["stage"] == "RUNTIME_ERROR" and r["stage_label"] == "Error" for r in errors["rows"])
-    sleeping = client.get("/api/search?f=stage:Sleeping&size=100").json()
-    assert sleeping["total"] and all(r["stage"] == "SLEEPING" for r in sleeping["rows"])
-    old = client.get("/api/search?f=stage:Asleep%20or%20stopped;mcp:Has%20MCP%20tools").json()
-    assert "Error" in old["query"]["f"]["stage"] and old["query"]["f"]["mcp"] == ["MCP tagged"]
-
-
-def test_trending_priorities_cannot_overflow_into_each_other(tmp_path, monkeypatch):
-    # Old 1e9/1e4 weights let popularity displace a larger recent-interest score,
-    # and capped downloads made 10k and 10M downloads indistinguishable.
-    custom = [dict(ROWS[0], id=f"rank/{i}", key=f"rank/{i}", trending=t, likes=l, downloads=d)
-              for i, (t, l, d) in enumerate([(0, 10**9, 10**12), (0.1, 0, 0), (1, 3, 10000), (1, 3, 10**7)])]
-    monkeypatch.setattr(__import__(__name__, fromlist=["ROWS"]), "ROWS", custom)
-    monkeypatch.setattr(catalog, "pinned", lambda: ["rank/0"])
-    publish_fixture(tmp_path)
-    got = client.get("/api/search?trending=4").json()
-    assert [r["id"] for r in got["rows"]] == ["rank/3", "rank/2", "rank/1", "rank/0"]
-    assert got["trending"] == got["rows"]
-    assert [r["id"] for r in got["featured"]] == ["rank/0"]
-    assert got["ranking"]["order"] == ["trending", "likes", "downloads"]
-
-
-def test_empty_filters_have_no_unrelated_trending_or_featured(tmp_path):
-    publish_fixture(tmp_path)
-    d = client.get("/api/search?q=absent-environment-xyz&trending=24").json()
-    assert d["total"] == 0 and d["trending"] == [] and d["featured"] == []
-
-
-@pytest.mark.parametrize("mode", ["published", "fallback"])
-def test_owner_filter_is_exact_and_shared_by_results_facets_and_trending(tmp_path, monkeypatch, mode):
-    import sys
-    space = next(r for r in ROWS if r["kind"] == "space")
-    dataset = ROWS[0]
-    mixed = [*ROWS, {**space, "id": "ds/owned-space", "key": "space:ds/owned-space"},
-             {**dataset, "id": "ds-copy/impostor", "key": "ds-copy/impostor", "heading": "ds environments"}]
-    monkeypatch.setattr(sys.modules[__name__], "ROWS", mixed)
-    if mode == "published":
-        publish_fixture(tmp_path)
-    expected = {r["key"] for r in visible() if r["id"].split("/")[0] == "ds"}
-    data = client.get("/api/search", params={"owner": "DS", "size": 100, "trending": 48}).json()
-    assert {r["key"] for r in data["rows"]} == expected
-    assert {r["kind"] for r in data["rows"]} == {"dataset", "space"}
-    assert data["total"] == data["facets"]["kind"]["all"] == len(expected)
-    assert {r["key"] for r in data["trending"]} == expected
-    assert all(r["id"].split("/")[0] == "ds" for r in data["featured"])
-    query = search_api.Query(owner="DS")
-    ref = search_api.py_search(search_api.py_cards([r for r in mixed if not r.get("private")], search_api.context()), query)
-    assert {r["key"] for r in ref["matches"]} == expected
-    pages = [client.get("/api/search", params={"owner": "ds", "size": 10, "page": page, "facets": 0}).json()["rows"]
-             for page in range(1, (len(expected) + 9) // 10 + 1)]
-    assert {r["key"] for page in pages for r in page} == expected
-    assert sum(map(len, pages)) == len(expected)
-    filtered = client.get("/api/search", params={"owner": "ds", "kind": "openenv", "q": "owned-space"}).json()
-    assert all(r["id"] == "ds/owned-space" for r in filtered["rows"])
-    for owner in ("d", "ds%", "ds/", "missing", "ds' OR 1=1 --"):
-        empty = client.get("/api/search", params={"owner": owner, "trending": 24}).json()
-        assert empty["total"] == 0 and empty["trending"] == [] and empty["featured"] == []
-
-
-def test_owner_filter_applies_to_authorized_private_dataset_merge(tmp_path, monkeypatch):
-    publish_fixture(tmp_path)
-    mine = [{**ROWS[0], "id": "me/private", "key": "me/private", "private": True},
-            {**ROWS[0], "id": "someone-else/private", "key": "someone-else/private", "private": True}]
-    monkeypatch.setattr(search_api, "_mine_rows", lambda request: mine)
-    public = client.get("/api/search", params={"owner": "me"}).json()
-    assert public["total"] == 0
-    response = client.get("/api/search", params={"owner": "ME", "mine": 1, "trending": 24})
-    data = response.json()
-    assert data["total"] == 1
-    assert data["stats"]["datasets"] == 1
-    assert data["stats"]["dataset_tasks"] == (mine[0].get("indexed") or {}).get("tasks", 0)
-    assert [r["id"] for r in data["rows"]] == [r["id"] for r in data["trending"]] == ["me/private"]
-    assert data["rows"][0]["private"] is True
-    assert response.headers["cache-control"].startswith("private")
-
-
-@pytest.mark.parametrize("status,stage,age,expected", [
-    (None, "RUNNING", 0, "unverified-space"),
-    ("Checks failed", "RUNNING", 0, "unverified-space"),
-    ("API checked", "RUNNING", 0, "openenv"),
-    ("API checked", "RUNNING", 3601, "unverified-space"),
-    ("API checked", "SLEEPING", 0, "unverified-space"),
-])
-def test_manifest_filename_never_establishes_openenv_without_fresh_live_evidence(tmp_path, monkeypatch, status, stage, age, expected):
-    from app import space_checks
-    publish_fixture(tmp_path)
-    target = next(r for r in ROWS if r.get("manifest"))
-    record = {"id": target["id"], "status": status, "stage": stage, "checked_at": time.time() - age}
-    monkeypatch.setattr(space_checks, "inventory", lambda: {target["id"]: record} if status else {})
-    data = client.get("/api/search", params={"q": target["id"], "trending": 24}).json()
-    row = next(r for r in data["rows"] if r["id"] == target["id"])
-    assert row["fw"] == expected
-    assert row["openenv"] is (expected == "openenv")
-    if expected != "openenv":
-        assert row["framework"] == "space" and "OpenEnv" not in row["badges"]
-    filtered = client.get("/api/search", params={"q": target["id"], "kind": "openenv", "trending": 24}).json()
-    assert bool(filtered["rows"]) is (expected == "openenv")
-    assert bool(filtered["trending"]) is (expected == "openenv")
-    assert filtered["facets"]["kind"].get(expected, 0) > 0
-
-
-def test_verified_untagged_space_has_protocol_facets(tmp_path, monkeypatch):
-    from app import space_checks
-    publish_fixture(tmp_path)
-    record = {"id": "fe/plain", "status": "API checked", "stage": "RUNNING", "checked_at": time.time(), "mode": "Simulation", "tools": 0}
-    monkeypatch.setattr(space_checks, "inventory", lambda: {"fe/plain": record})
-    data = client.get("/api/search", params={"kind": "openenv", "f": "health:API%20checked"}).json()
-    assert [r["id"] for r in data["rows"]] == ["fe/plain"]
-    ctx = search_api.context()
-    cards = search_api.py_cards([r for r in ROWS if not r.get("private")], ctx)
-    with snapshot.use() as (_, conn):
-        q = search_api.Query(kind="openenv")
-        assert search_api.sql_search(conn, q, ctx)["facets"] == search_api.py_search(cards, q)["facets"]
-
-
-def test_ready_scope_counts_and_facets_share_live_evidence(tmp_path, monkeypatch):
-    from app import space_checks
-    publish_fixture(tmp_path)
-    now = time.time()
-    good = {"id": "fe/geo", "status": "API checked", "stage": "RUNNING", "checked_at": now,
-            "task_catalog": {"checked_at": now, "tasks": 1234, "counted_splits": 1, "complete": True}}
-    checks = {"fe/geo": good,
-              "fe/latex": {**good, "id": "fe/latex", "checked_at": now - 3601, "task_catalog": {}},
-              "fe/plain": {**good, "id": "fe/plain", "status": "Checks failed", "task_catalog": {}},
-              "fe/ors-one": {**good, "id": "fe/ors-one", "status": "Checks failed", "interface": "ors", "task_catalog": {}}}
-    monkeypatch.setattr(space_checks, "inventory", lambda: checks)
-    data = client.get("/api/search", params={"scope": "ready", "owner": "fe", "size": 100, "trending": 24}).json()
-    assert {r["id"] for r in data["rows"]} == {"fe/geo", "fe/ors-one"}
-    assert data["stats"]["datasets"] == data["stats"]["dataset_tasks"] == 0
-    assert data["stats"]["spaces"] == data["total"] == data["facets"]["kind"]["all"] == 2
-    assert data["stats"]["space_tasks"] == 1234
-    rank = client.get("/api/search/rank", params={"scope": "ready", "key": "space:fe/geo"}).json()
-    assert rank["of"] == 2
-    assert client.get("/api/search/rank", params={"scope": "ready", "key": "space:fe/plain"}).status_code == 404
-    ctx = search_api.context()
-    cards = search_api.py_cards([r for r in ROWS if not r.get("private")], ctx)
-    with snapshot.use() as (_, conn):
-        for q in (search_api.Query(scope="ready"), search_api.Query(scope="ready", owner="fe"),
-                  search_api.Query(scope="ready", kind="openenv")):
-            sql = search_api.sql_search(conn, q, ctx, limit=100)
-            py = search_api.py_search(cards, q)
-            assert sql["total"] == py["total"]
-            assert sql["facets"] == py["facets"]
-    datasets = client.get("/api/search", params={"scope": "ready", "owner": "ds"}).json()
-    assert datasets["stats"]["datasets"] == datasets["total"] and datasets["stats"]["spaces"] == 0
-    assert datasets["stats"]["dataset_tasks"] == len(TASKS["ds/d00"])
-    empty = client.get("/api/search", params={"scope": "ready", "q": "nothing-matches"}).json()
-    assert all(empty["stats"][k] == 0 for k in ("datasets", "spaces", "dataset_tasks", "space_tasks"))
-
-
-def test_fineenvs_promoted_without_pins_and_without_changing_trending(tmp_path, monkeypatch):
-    import sys
-    from app import space_checks
-    custom = [{**ROWS[0], "id": "FineEnvs/data", "key": "FineEnvs/data", "trending": 0},
-              {**ROWS[1], "id": "other/popular", "key": "other/popular", "trending": 100},
-              {**ROWS[-2], "id": "FineEnvs/server", "key": "space:FineEnvs/server", "kind": "space", "trending": 0}]
-    monkeypatch.setattr(sys.modules[__name__], "ROWS", custom)
-    monkeypatch.setattr(catalog, "pinned", list)
-    monkeypatch.setattr(space_checks, "inventory", lambda: {"FineEnvs/server": {
-        "id": "FineEnvs/server", "status": "API checked", "stage": "RUNNING", "checked_at": time.time()}})
-    publish_fixture(tmp_path)
-    data = client.get("/api/search?scope=ready&trending=24").json()
-    assert [r["id"] for r in data["promoted"]] == ["FineEnvs/server", "FineEnvs/data"]
-    assert data["trending"][0]["id"] == "other/popular"
-    assert data["featured"] == []
-    assert client.get("/api/search?scope=ready&owner=other&trending=24").json()["promoted"] == []
-    assert client.get("/api/search?scope=ready&q=popular&trending=24").json()["promoted"] == []
-    assert len(client.get("/api/search?scope=ready&owner=fineenvs&trending=24").json()["promoted"]) == 2

tests/test_security.py

@@ -1,554 +0,0 @@
-"""Security properties of the explorer, end to end through the HTTP API (no network: the Hub is stubbed).
-
-    uv run pytest tests -q
-
-What is checked: who may see and change what (admins, owners, everyone), that sessions can't be forged, that
-cross-site requests are refused, that private datasets and private rollouts stay private, that answers and tokens
-never reach a page, that a visitor's endpoint can't point the server at a private address, and the headers.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import tempfile
-import time
-from pathlib import Path
-
-import pytest
-
-_TMP = os.environ.get("RLX_TEST_TMP") or tempfile.mkdtemp(prefix="rlx-test-")   # conftest.py's, shared by every module
-os.environ.update(STORAGE_DIR=_TMP, RLX_CACHE_DIR=f"{_TMP}/cache", OAUTH_CLIENT_ID="test-client", SESSION_SECRET="test-secret",
-                  RLX_WARM="0", RLX_ADMIN_ORG="FineEnvs")
-
-from fastapi.testclient import TestClient  # noqa: E402
-
-from app import admin_app, auth, catalog, config, endpoints, main, models, runner, settings, store  # noqa: E402
-
-TOKENS = {"alice": "hf_alice_secret_token_0001", "bob": "hf_bob_secret_token_0002"}
-
-
-def cookie(name: str, exp: float | None = None) -> dict[str, str]:
-    session = {"token": TOKENS[name], "name": name, "avatar": None, "via": "token", "exp": exp or time.time() + 3600}
-    return {"Cookie": f"{auth.COOKIE}={auth._box.encrypt(json.dumps(session).encode()).decode()}"}
-
-
-@pytest.fixture(autouse=True)
-def stubs(monkeypatch):
-    """No Hub: alice is a FineEnvs member, bob isn't; the catalog is empty."""
-    monkeypatch.setattr(settings, "_org_members", lambda: {"alice"})
-    monkeypatch.setattr(catalog, "environments", lambda include_hidden=False: [])
-    monkeypatch.setattr(models, "get", lambda mid: {"id": mid, "tools": True, "provider": "x"})
-
-
-client = TestClient(main.app, base_url="https://testserver")
-admin = TestClient(admin_app.app, base_url="https://testserver")   # its own app, on its own private Space
-
-
-def runnable_task(monkeypatch, **row):
-    """A task any environment's adapter says runs with the Harbor runner (app/envs/registry.run_task, stubbed)."""
-    from types import SimpleNamespace
-
-    from app.envs import registry
-
-    row = {"title": "T", "restricted": False, "sha": "abc", "runnable": {"ok": True, "how": "image"}, "image": "python:3.12", **row}
-    opts = [{"runner": "harbor", "label": "Harbor", "ok": True, "why": "", "fields": [], "harnesses": None}]
-    monkeypatch.setattr(registry, "run_task", lambda d, p, t=None: (SimpleNamespace(key=d, adapter=SimpleNamespace(id="test")), row, opts))
-    monkeypatch.setattr(runner.Rollout, "execute", lambda self: None)
-
-
-def run(**kw) -> dict:
-    rid = kw.pop("id", f"20260101-000000-{os.urandom(3).hex()}")
-    base = {"id": rid, "user": "alice", "dataset": "org/ds", "path": "tasks/t1", "task_id": "org/ds:tasks/t1", "title": "T",
-            "model": "m/x", "harness": "opencode", "status": "done", "reward": 1.0, "visibility": "public"}
-    return store.create({**base, **kw})
-
-
-# ── sessions ─────────────────────────────────────────────────────────────────
-def test_signed_out_and_forged_sessions_are_nobody():
-    assert client.get("/api/runs").status_code == 401
-    assert client.get("/api/runs", headers={"Cookie": f"{auth.COOKIE}=gAAAAABforged"}).status_code == 401
-    assert client.get("/api/runs", headers=cookie("alice", exp=time.time() - 10)).status_code == 401
-    assert client.get("/api/runs", headers=cookie("alice")).status_code == 200
-
-
-def test_me_never_returns_the_token():
-    body = client.get("/api/me", headers=cookie("alice")).text
-    assert TOKENS["alice"] not in body
-    assert json.loads(body)["user"]["name"] == "alice"
-
-
-# ── admin ────────────────────────────────────────────────────────────────────
-ADMIN_GETS = ["/api/admin/overview", "/api/admin/rollouts", "/api/admin/environments", "/api/admin/collections",
-              "/api/admin/indexes", "/api/admin/settings", "/api/admin/audit"]
-
-
-@pytest.mark.parametrize("path", ADMIN_GETS)
-def test_admin_is_for_org_members_only(path):
-    assert admin.get(path).status_code == 401
-    assert admin.get(path, headers=cookie("bob")).status_code == 403
-    assert admin.get(path, headers=cookie("alice")).status_code == 200
-
-
-@pytest.mark.parametrize("path", ADMIN_GETS)
-def test_the_public_explorer_has_no_admin(path):
-    r = client.get(path, headers=cookie("alice"))
-    assert r.status_code == 404 or "Admin" not in r.text   # the static fallback serves nothing there
-
-
-def test_admin_writes_refused_for_others_and_audited():
-    body = {"rollouts_enabled": True, "max_active": 5, "max_per_user": 2, "agents": ["opencode"], "announcement": "hi"}
-    assert admin.put("/api/admin/settings", json=body).status_code == 401
-    assert admin.put("/api/admin/settings", json=body, headers=cookie("bob")).status_code == 403
-    assert admin.post("/api/admin/environments", json={"key": "org/ds", "action": "hide"}, headers=cookie("bob")).status_code == 403
-    r = admin.put("/api/admin/settings", json=body, headers=cookie("alice"))
-    assert r.status_code == 200 and r.json()["max_active"] == 5
-    entry = settings.audit(1)[0]
-    assert entry["user"] == "alice" and entry["after"]["max_active"] == 5
-
-
-def test_admin_input_is_validated():
-    h = cookie("alice")
-    assert admin.put("/api/admin/settings", json={"rollouts_enabled": True, "max_active": 0, "max_per_user": 2, "agents": []}, headers=h).status_code == 422
-    assert admin.put("/api/admin/settings", json={"rollouts_enabled": True, "max_active": 3, "max_per_user": 2, "agents": ["rm -rf"]}, headers=h).status_code == 400
-    bad_key = {"collections": [{"id": "x1", "group": "X", "icon": "grid", "color": "code", "ids": ["not a key"]}]}
-    assert admin.put("/api/admin/collections", json=bad_key, headers=h).status_code == 400
-    bad_id = {"collections": [{"id": "Bad Id", "group": "X", "icon": "grid", "color": "code", "ids": []}]}
-    assert admin.put("/api/admin/collections", json=bad_id, headers=h).status_code == 422
-    assert admin.post("/api/admin/environments", json={"key": "../../etc", "action": "pin"}, headers=h).status_code == 400
-
-
-def test_session_name_cannot_be_claimed_by_a_header():
-    # the admin check reads the name from the encrypted session only
-    assert admin.get("/api/admin/settings", headers={**cookie("bob"), "X-User": "alice", "X-Forwarded-User": "alice"}).status_code == 403
-
-
-# ── cross-site requests ──────────────────────────────────────────────────────
-def test_cross_site_posts_are_refused():
-    h = cookie("alice")
-    r = client.post("/api/runs", json={"dataset": "org/ds"}, headers={**h, "Origin": "https://evil.example"})
-    assert r.status_code == 403
-    r = client.post("/api/runs", json={"dataset": "org/ds"}, headers={**h, "Sec-Fetch-Site": "cross-site"})
-    assert r.status_code == 403
-    r = admin.put("/api/admin/settings", json={}, headers={**h, "Origin": "https://evil.example"})
-    assert r.status_code == 403
-
-
-# ── rollouts: who sees what ──────────────────────────────────────────────────
-def test_private_rollouts_are_owner_only():
-    r = run(visibility="private")
-    assert client.get(f"/api/runs/{r['id']}").status_code == 404
-    assert client.get(f"/api/runs/{r['id']}", headers=cookie("bob")).status_code == 404
-    assert client.get(f"/api/runs/{r['id']}", headers=cookie("alice")).status_code == 200
-    assert client.post(f"/api/runs/{r['id']}/visibility", json={"visibility": "public"}, headers=cookie("bob")).status_code == 404
-    assert client.post(f"/api/runs/{r['id']}/cancel", headers=cookie("bob")).status_code == 404
-
-
-def test_public_rollouts_hide_who_ran_them():
-    r = run(endpoint={"base_url": "https://llm.alice-corp.example/v1", "host": "llm.alice-corp.example", "model": "m"})
-    store.write_artifact(r["id"], "trajectory.json", json.dumps([{"role": "user", "content": "hello alice, use https://llm.alice-corp.example/v1"}]))
-    body = client.get(f"/api/runs/{r['id']}").text
-    data = json.loads(body)
-    assert "user" not in data["run"] and data["run"]["endpoint"] == {"custom": True}
-    assert "alice" not in body and "alice-corp" not in body
-
-
-def test_ungraded_unfinished_and_restricted_rollouts_stay_off_community():
-    keep = run(dataset="org/community-check")
-    run(dataset="org/community-check", status="running", reward=None)
-    run(dataset="org/community-check", status="failed", reward=None)
-    run(dataset="org/community-check", restricted=True)
-    run(dataset="org/community-check", visibility="private")
-    ids = [x["id"] for x in client.get("/api/community?dataset=org/community-check").json()["runs"]]
-    assert ids == [keep["id"]]
-
-
-def test_rollouts_on_private_datasets_cannot_go_public():
-    r = run(visibility="private", restricted=True)
-    assert client.post(f"/api/runs/{r['id']}/visibility", json={"visibility": "public"}, headers=cookie("alice")).status_code == 400
-
-
-def test_tokens_never_reach_the_store(monkeypatch):
-    runnable_task(monkeypatch)
-    r = client.post("/api/runs", json={"dataset": "org/ds", "path": "tasks/t1", "model": "m/x"}, headers=cookie("alice"))
-    assert r.status_code == 200, r.text
-    assert TOKENS["alice"] not in r.text
-    for f in Path(_TMP).rglob("*"):
-        if f.is_file():
-            assert TOKENS["alice"].encode() not in f.read_bytes(), f
-
-
-def test_paused_rollouts_are_refused(monkeypatch):
-    runnable_task(monkeypatch)
-    settings.save("alice", {"rollouts_enabled": False})
-    try:
-        r = client.post("/api/runs", json={"dataset": "org/ds", "path": "tasks/t1", "model": "m/x"}, headers=cookie("alice"))
-        assert r.status_code == 429 and "paused" in r.json()["detail"]
-    finally:
-        settings.save("alice", {"rollouts_enabled": True})
-
-
-# ── private datasets ─────────────────────────────────────────────────────────
-def test_private_datasets_need_a_token_that_can_read_them(monkeypatch):
-    calls = []
-
-    def fetch(spec, token):   # the Hub: only alice's token can read it
-        calls.append(token)
-        if token == TOKENS["alice"]:
-            return {"id": spec, "sha": "abc", "restricted": True}
-        raise PermissionError("private")
-
-    monkeypatch.setattr(catalog, "_fetch_info", fetch)
-    catalog._memo.clear()
-    with pytest.raises(PermissionError):
-        catalog.info("org/private-ds")
-    assert catalog.info("org/private-ds", TOKENS["alice"])["restricted"]
-    with pytest.raises(PermissionError):   # bob's token is checked on its own, never served alice's cached answer
-        catalog.info("org/private-ds", TOKENS["bob"])
-    with pytest.raises(PermissionError):   # and signed out, still nothing
-        catalog.info("org/private-ds")
-    assert TOKENS["bob"] in calls
-
-
-# ── answers stay out ─────────────────────────────────────────────────────────
-@pytest.mark.parametrize("rel,text,withheld", [
-    ("solution/solve.sh", None, True),
-    ("tests/test.sh", "pytest /tests", False),
-    ("tests/grade.py", "import json", False),
-    ("tests/expected_output.json", None, True),
-    ("tests/verifier/verifier_meta.json", None, True),
-    ("tests/grade.json", None, True),
-    ("tests/check.py", "GOLD = {'gold_answer': 42}", True),
-    ("environment/setup/files/expected_func.json", None, True),
-    ("instruction.md", "find the gold_answer", False),
-])
-def test_answers_are_withheld(rel, text, withheld):
-    assert catalog._withheld(rel, text) is withheld
-
-
-def test_task_toml_masks_answer_keys():
-    out = catalog._masked_toml('[metadata]\ngold_answer = "42"\nexpected_output = "x"\ndifficulty = "easy"')
-    assert '"42"' not in out and '"x"' not in out and 'difficulty = "easy"' in out
-
-
-def test_task_files_stay_inside_the_task(monkeypatch):
-    monkeypatch.setattr(catalog, "_task_row", lambda s, p, t=None: ({}, {"sha": "abc"}))
-    monkeypatch.setattr(catalog, "_task_texts", lambda s, sha, p, t: ({"tests/test.sh": 10, "solution/solve.sh": 5}, {"tests/test.sh": "echo"}, set()))
-    assert catalog.task_file("org/ds", "tasks/t1", "../t2/task.toml")["error"]
-    assert catalog.task_file("org/ds", "tasks/t1", "/etc/passwd")["error"]
-    assert catalog.task_file("org/ds", "tasks/t1", "solution/solve.sh").get("withheld")
-    assert catalog.task_file("org/ds", "tasks/t1", "tests/test.sh")["text"] == "echo"
-
-
-def test_dataset_ids_are_checked():
-    for bad in ("../../etc", "a/b/c", "org/..", "", "org/ name"):
-        with pytest.raises(ValueError):
-            catalog.check_spec(bad)
-
-
-# ── a visitor's endpoint ─────────────────────────────────────────────────────
-@pytest.mark.parametrize("url", ["http://example.com/v1", "https://127.0.0.1/v1", "https://localhost/v1", "https://169.254.169.254/latest",
-                                 "https://10.0.0.5/v1", "https://[::1]/v1", "https://user:pass@example.com/v1"])
-def test_endpoints_must_be_public_https(url):
-    with pytest.raises(endpoints.EndpointError):
-        endpoints.check_url(url)
-
-
-def test_space_hosts_are_pinned_to_hf_space():
-    import re
-
-    pat = re.compile(r"^https://[a-z0-9-]+\.hf\.space$")
-    assert pat.match("https://openenv-coding-env.hf.space")
-    for bad in ("https://evil.com", "https://x.hf.space.evil.com", "https://x.hf.space/../", "http://x.hf.space"):
-        assert not pat.match(bad)
-
-
-# ── headers ──────────────────────────────────────────────────────────────────
-def test_security_headers():
-    r = client.get("/")
-    csp = r.headers["content-security-policy"]
-    assert "object-src 'none'" in csp and "frame-ancestors 'self' https://huggingface.co" in csp and "script-src 'self'" in csp
-    assert r.headers["x-content-type-options"] == "nosniff"
-
-
-def test_local_mode_refuses_other_hosts(monkeypatch):
-    monkeypatch.setattr(config, "LOCAL_MODE", True)
-    assert client.get("/api/me", headers={"Host": "evil.example"}).status_code == 403
-    assert client.get("/api/me", headers={"Host": "localhost:8060"}).status_code == 200
-
-
-# ── what the admin Space changes reaches the explorer through the bucket ─────
-def test_admin_hides_a_rollout_from_community():
-    r = run(dataset="org/moderation-check")
-    assert [x["id"] for x in client.get("/api/community?dataset=org/moderation-check").json()["runs"]] == [r["id"]]
-    assert admin.post(f"/api/admin/rollouts/{r['id']}/moderate", json={"hidden": True}, headers=cookie("alice")).status_code == 200
-    assert client.get("/api/community?dataset=org/moderation-check").json()["runs"] == []
-    assert client.get(f"/api/runs/{r['id']}").status_code == 404                        # gone for everyone
-    assert client.get(f"/api/runs/{r['id']}", headers=cookie("alice")).status_code == 200   # its owner still has it
-    admin.post(f"/api/admin/rollouts/{r['id']}/moderate", json={"hidden": False}, headers=cookie("alice"))
-    assert client.get(f"/api/runs/{r['id']}").status_code == 200
-
-
-def test_admin_stop_requests_reach_running_rollouts(monkeypatch):
-    stopped = []
-    monkeypatch.setattr(runner, "is_live", lambda rid: True)
-    monkeypatch.setattr(runner, "cancel", lambda rid: stopped.append(rid) or True)
-    r = run(status="running", reward=None, updated_at=time.time())
-    assert admin.post(f"/api/admin/rollouts/{r['id']}/cancel", headers=cookie("alice")).status_code == 200
-    assert admin.post(f"/api/admin/rollouts/{r['id']}/cancel", headers=cookie("bob")).status_code == 403
-    import threading
-
-    threading.Thread(target=runner.watch_cancel_requests, daemon=True).start()
-    for _ in range(40):
-        if r["id"] in stopped:
-            break
-        time.sleep(0.1)
-    assert r["id"] in stopped
-
-
-def test_answers_written_into_grader_scripts_are_masked():
-    sh = "expected_answer=$(cat <<'ANSWER_EOF'\n138236\nANSWER_EOF\n)\nEXPECTED=\"42\"\nagent=$(cat /workdir/answer.txt)\n"
-    out = catalog._mask_answers("tests/test.sh", sh)
-    assert "138236" not in out and '"42"' not in out and "cat /workdir/answer.txt" in out
-    py = 'GOLD_ANSWER = {"x": 1}\nresult = run()\n'
-    assert "{\"x\": 1}" not in catalog._mask_answers("tests/grade.py", py)
-    assert catalog._mask_answers("instruction.md", "expected = 5") == "expected = 5"   # only grader files
-
-
-def test_no_network_tasks_are_refused_with_a_reason():
-    r = catalog.runnable({"env": {"network": "no-network", "image": "python:3.12"}}, {})
-    assert not r["ok"] and "internet" in r["why"]
-
-
-def test_indexing_is_capped(monkeypatch):
-    monkeypatch.setattr(catalog, "info", lambda spec, token=None: {"sha": "s1", "restricted": False})
-    monkeypatch.setattr(catalog, "_read_index", lambda spec, sha=None: None)
-    monkeypatch.setattr(catalog, "_build", lambda *a, **k: None)
-    with catalog._jobs_lock:
-        saved = dict(catalog._jobs)
-        catalog._jobs.clear()
-        catalog._jobs.update({f"o/busy{i}": {"state": "reading", "sha": "x"} for i in range(config.MAX_INDEX_JOBS)})
-    try:
-        with pytest.raises(RuntimeError):
-            catalog.index_status("o/new-one")
-    finally:
-        with catalog._jobs_lock:
-            catalog._jobs.clear()
-            catalog._jobs.update(saved)
-
-
-def test_huge_tasks_are_refused(monkeypatch):
-    runnable_task(monkeypatch, bytes=50 * 1024**3)
-    r = client.post("/api/runs", json={"dataset": "org/ds", "path": "tasks/t1", "model": "m/x"}, headers=cookie("alice"))
-    assert r.status_code == 400 and "GB" in r.json()["detail"]
-
-
-# ── the run list agrees with the run files ───────────────────────────────────
-def test_list_follows_records_written_elsewhere():
-    r = run(status="running", reward=None)
-    store.list_runs()   # index it
-    doc = json.loads((store.RUNS / r["id"] / "run.json").read_text())
-    time.sleep(0.01)
-    doc.update(status="done", reward=1.0, updated_at=time.time())
-    (store.RUNS / r["id"] / "run.json").write_text(json.dumps(doc))   # another process finishes it
-    store._synced_at = 0
-    assert next(x for x in store.list_runs() if x["id"] == r["id"])["status"] == "done"
-
-
-def test_only_silent_rollouts_are_marked_interrupted():
-    busy = run(status="running", reward=None)                    # touched just now: someone is running it
-    lost = run(status="running", reward=None)
-    doc = json.loads((store.RUNS / lost["id"] / "run.json").read_text())
-    doc["updated_at"] = time.time() - 3600                        # silent for an hour: its worker is gone
-    (store.RUNS / lost["id"] / "run.json").write_text(json.dumps(doc))
-    store._synced_at = 0
-    store.mark_interrupted(set())
-    assert store.get(busy["id"])["status"] == "running"
-    assert store.get(lost["id"])["status"] == "interrupted"
-
-
-# ── a task's ${VAR}s never reach this server's environment ───────────────────
-def test_task_variables_never_come_from_this_servers_environment(monkeypatch):
-    monkeypatch.setenv("SESSION_SECRET_PROBE", "s3cret-value")
-    monkeypatch.setenv("HF_TOKEN", "hf_operator_token")
-    with pytest.raises(runner.MissingTaskEnv):
-        runner.resolve_task_env({"X": "${SESSION_SECRET_PROBE}"})
-    with pytest.raises(runner.MissingTaskEnv):
-        runner.resolve_task_env({"KEY": "${HF_TOKEN}"})
-    assert runner.resolve_task_env({"A": "${HF_TOKEN:-none}", "B": "literal"}) == {"A": "none", "B": "literal"}
-    token = runner._TASK_ENV.set({"environment": {"OPENAI_API_KEY": "cap-123"}, "verifier": {"JUDGE": "cap-456"}})
-    try:
-        assert runner.resolve_task_env({"K": "${OPENAI_API_KEY}"}) == {"K": "cap-123"}
-        with pytest.raises(runner.MissingTaskEnv):   # the grader's values never reach the agent's phase
-            runner.resolve_task_env({"J": "${JUDGE}"})
-        assert runner._resolver("verifier")({"J": "${JUDGE}"}) == {"J": "cap-456"}
-    finally:
-        runner._TASK_ENV.reset(token)
-
-
-def test_harbor_and_its_agents_are_cut_off_from_this_servers_secrets(monkeypatch):
-    monkeypatch.setenv("HF_TOKEN", "hf_operator_token")
-    monkeypatch.setenv("OAUTH_CLIENT_SECRET", "oauth-secret")
-    monkeypatch.setenv("PATH_LIKE_SETTING", "fine")
-    runner._patch_harbor_env()
-    import harbor.environments.base as env_base
-    import harbor.trial.trial as trial
-    import harbor.verifier.verifier as verifier
-    from harbor.agents import base as agent_base
-    from harbor.utils import env as harbor_env
-    for mod, phase in ((env_base, "environment"), (trial, "any"), (verifier, "verifier"), (harbor_env, "environment")):
-        assert getattr(mod.resolve_env_vars, "_rlx_phase", None) == phase, mod.__name__
-    host = runner._HostEnv()
-    assert "HF_TOKEN" not in host and "OAUTH_CLIENT_SECRET" not in host and host.get("PATH_LIKE_SETTING") == "fine"
-    fake = type("A", (), {"_extra_env": {}})()
-    sources = agent_base.BaseAgent._env_sources(fake)
-    assert all("HF_TOKEN" not in s and "OAUTH_CLIENT_SECRET" not in s for s in sources)
-
-
-def test_a_public_rollouts_files_are_images_only_to_others():
-    r = run(user="alice", status="done", reward=1.0, visibility="public")
-    store.write_artifact(r["id"], "trajectory.json", '[{"role": "user", "content": "from alice"}]')
-    store.write_artifact(r["id"], "screenshot.jpg", b"\xff\xd8\xff")
-    assert client.get(f"/api/runs/{r['id']}/artifacts/trajectory.json").status_code == 404
-    assert client.get(f"/api/runs/{r['id']}/artifacts/screenshot.jpg").status_code == 200
-    assert client.get(f"/api/runs/{r['id']}/artifacts/trajectory.json", headers=cookie("alice")).status_code == 200
-    assert client.get(f"/api/runs/{r['id']}/artifacts/run.json", headers=cookie("alice")).status_code == 404
-
-
-# ── sign-in ──────────────────────────────────────────────────────────────────
-def _hub_signin(monkeypatch):
-    from types import SimpleNamespace
-
-    monkeypatch.setattr(auth.httpx, "post", lambda *a, **k: SimpleNamespace(status_code=200, json=lambda: {"access_token": "hf_oauth_x", "scope": "openid inference-api jobs", "expires_in": 3600}))
-    monkeypatch.setattr(auth.httpx, "get", lambda *a, **k: SimpleNamespace(json=lambda: {"preferred_username": "carol"}))
-
-
-def test_oauth_state_lives_in_a_signed_cookie_for_one_browser(monkeypatch):
-    _hub_signin(monkeypatch)
-    c = TestClient(main.app, base_url="https://testserver")
-    r = c.get("/login", follow_redirects=False)
-    assert r.status_code in (302, 307)
-    state = dict(x.split("=", 1) for x in r.headers["location"].split("?", 1)[1].split("&"))["state"]
-    sent = r.cookies.get(auth.STATE_COOKIE)
-    assert sent and state not in sent   # encrypted, not the state itself
-    other = TestClient(main.app, base_url="https://testserver")   # another browser, the same callback URL: refused
-    assert other.get(f"/login/callback?code=x&state={state}", follow_redirects=False).status_code == 400
-    assert c.get("/login/callback?code=x&state=forged", cookies={auth.STATE_COOKIE: sent}, follow_redirects=False).status_code == 400
-    ok = c.get(f"/login/callback?code=x&state={state}", cookies={auth.STATE_COOKIE: sent}, follow_redirects=False)
-    assert ok.status_code in (302, 307) and auth.COOKIE in ok.headers.get("set-cookie", "")
-
-
-def test_an_expired_sign_in_is_refused(monkeypatch):
-    _hub_signin(monkeypatch)
-    old = auth._box.encrypt_at_time(b"s1", int(time.time()) - auth.STATE_TTL - 5).decode()
-    r = client.get("/login/callback?code=x&state=s1", cookies={auth.STATE_COOKIE: old}, follow_redirects=False)
-    assert r.status_code == 400
-
-
-def test_a_cancelled_sign_in_goes_home():
-    r = client.get("/login/callback?error=access_denied", follow_redirects=False)
-    assert r.status_code in (302, 307) and r.headers["location"] == "/"
-
-
-def test_pasting_tokens_is_rate_limited(monkeypatch):
-    from types import SimpleNamespace
-
-    monkeypatch.setattr(auth, "TOKEN_LIMIT", auth.Limiter(3, 600))
-    monkeypatch.setattr(auth.httpx, "get", lambda *a, **k: SimpleNamespace(status_code=401))
-    codes = [client.post("/api/login/token", json={"token": "hf_" + "x" * 30}).status_code for _ in range(5)]
-    assert codes == [400, 400, 400, 429, 429]
-
-
-def test_two_submits_at_once_cant_both_take_the_last_place(monkeypatch):
-    import threading as th
-
-    runnable_task(monkeypatch)
-    runner._live.clear()
-    real_create = store.create
-
-    def slow_create(doc):   # the record takes a moment to write: the window two submits used to race through
-        time.sleep(0.3)
-        return real_create(doc)
-
-    monkeypatch.setattr(store, "create", slow_create)
-    before = {k: settings.get(k) for k in ("max_per_user", "max_active")}
-    settings.save("alice", {"rollouts_enabled": True, "max_per_user": 1, "max_active": 5})
-    codes: list[int] = []
-    try:
-        ts = [th.Thread(target=lambda: codes.append(client.post("/api/runs", json={"dataset": "org/ds", "path": "tasks/t1", "model": "m/x"},
-                                                                headers=cookie("bob")).status_code)) for _ in range(3)]
-        [t.start() for t in ts]
-        [t.join() for t in ts]
-        assert sorted(codes) == [200, 429, 429]
-        assert runner._reserved == {}   # every reservation let go, the refused ones too
-    finally:
-        runner._live.clear()
-        settings.save("alice", {"rollouts_enabled": True, **{k: v for k, v in before.items() if v is not None}})
-
-
-def test_a_live_rollouts_events_stay_local_until_flushed(monkeypatch):
-    r = run(user="alice", status="running")
-    store.append_events(r["id"], [{"kind": "turn", "n": 1}])
-    on_store = (store._dir(r["id"]) / "events.jsonl")
-    assert store.read_events(r["id"]) == [{"kind": "turn", "n": 1}]   # the page reads the local copy at once
-    assert on_store.read_text() == ""                                  # the store (a bucket) wasn't rewritten per event
-    monkeypatch.setattr(store, "FLUSH_EVERY", 0.0)
-    store.flush_due()
-    assert json.loads(on_store.read_text().splitlines()[0]) == {"kind": "turn", "n": 1}
-    store.append_events(r["id"], [{"kind": "turn", "n": 2}])
-    store.update(r["id"], status="done")                               # it ended: everything is on the store, no local copy
-    assert len(on_store.read_text().splitlines()) == 2 and not (store.LOCAL / r["id"]).exists()
-    assert store.read_events(r["id"], after=1) == [{"kind": "turn", "n": 2}]
-
-
-def test_events_a_stopped_process_left_on_local_disk_are_kept():
-    r = run(user="alice", status="running")
-    store.append_events(r["id"], [{"kind": "turn", "n": 1}])
-    store._local.pop(r["id"])   # the process stopped: nothing in memory, the local file left behind
-    store._write_json(store._dir(r["id"]) / "run.json", {**store.get(r["id"]), "updated_at": time.time() - store.STALE - 10})
-    store._index_put(store.get(r["id"]))
-    assert store.mark_interrupted(set()) >= 1
-    assert store.get(r["id"])["status"] == "interrupted"
-    assert store.read_events(r["id"]) == [{"kind": "turn", "n": 1}] and not (store.LOCAL / r["id"]).exists()
-
-
-def test_a_visitors_endpoint_cant_rebind_to_a_private_address_later(monkeypatch):
-    import socket
-
-    answers = {"model.example": "93.184.216.34", "internal.example": "10.0.0.5"}
-
-    def fake(host, port, *a, **k):
-        return [(socket.AF_INET, socket.SOCK_STREAM, 6, "", (answers[host], port))]
-
-    monkeypatch.setattr(endpoints, "_real_getaddrinfo", fake)
-    real = socket.getaddrinfo
-    try:
-        assert endpoints.check_url("https://model.example/v1") == "https://model.example/v1"
-        assert socket.getaddrinfo("model.example", 443)[0][4][0] == "93.184.216.34"
-        answers["model.example"] = "169.254.169.254"   # the name now points at the metadata service
-        with pytest.raises(socket.gaierror):
-            socket.getaddrinfo("model.example", 443)     # any client in this process (the capture proxy's too)
-        assert socket.getaddrinfo("internal.example", 443)[0][4][0] == "10.0.0.5"   # names nobody gave us: untouched
-    finally:
-        socket.getaddrinfo = real
-        endpoints._untrusted.discard("model.example")
-
-
-def test_a_rollout_never_downloads_reference_solutions(monkeypatch):
-    import huggingface_hub
-
-    seen = {}
-    monkeypatch.setattr(catalog, "info", lambda spec, token=None: {"sha": "abc", "restricted": False})
-    monkeypatch.setattr(huggingface_hub, "snapshot_download", lambda *a, **k: seen.update(k))
-    catalog.task_dir("org/ds", "tasks/t1")
-    from fnmatch import fnmatch
-    for f in ("tasks/t1/solution/solve.sh", "tasks/t1/steps/s1/solution/solve.sh", "tasks/t1/steps/two/solution/deep/x.py"):
-        assert any(fnmatch(f, p) for p in seen["ignore_patterns"]), f
-    assert not any(fnmatch("tasks/t1/steps/s1/instruction.md", p) for p in seen["ignore_patterns"])
-
-
-def test_the_admin_space_has_health_checks_and_nothing_else_open():
-    assert admin.get("/healthz").json() == {"ok": True}
-    r = admin.get("/readyz")
-    assert r.status_code == 200 and r.json()["store"] == "ok"
-    assert admin.get("/api/admin/settings").status_code == 401

tests/test_seo.py

@@ -1,118 +0,0 @@
-"""Every page at its own address, findable and previewable (app/seo.py), without starting work or leaking anything
-(no network: the catalog's listing is stubbed).
-
-What is checked: each page answers with its own title, description, canonical address and schema.org data; what a
-page shows comes escaped (a task title can't inject markup or end the JSON-LD script); pages that are personal or
-unknown aren't indexed; old addresses move for good; robots.txt keeps crawlers off the API and rollouts; the
-sitemap lists environments and indexed tasks; preview images are images; unknown paths are 404 pages.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-
-import pytest
-from fastapi.testclient import TestClient
-
-from app import main, seo, snapshot
-
-client = TestClient(main.app, base_url="https://testserver")
-EVIL = '</script><script>alert(1)</script>"<b>'
-ROWS = [{"id": "org/ds", "key": "org/ds", "kind": "dataset", "heading": f"Bench {EVIL}", "brief": "A bench.", "tags": ["code"], "framework": "harbor",
-         "indexed": {"tasks": 2}, "updated": "2026-10-01T00:00:00+00:00", "downloads": 10, "likes": 2, "trending": 1},
-        {"id": "org/sp", "key": "space:org/sp", "kind": "space", "heading": "Game", "brief": "A game env.", "tags": ["openenv"], "trending": 0,
-         "framework": "openenv", "likes": 3},
-        {"id": "org/copy", "key": "space:org/copy", "kind": "space", "heading": "Echo copy", "tags": ["openenv"], "framework": "openenv", "likes": 0}]
-TASKS = [{"path": "tasks/a", "title": f"Fix it {EVIL}", "brief": "Do it.", "category": "code"}, {"path": "tasks/b", "title": "B", "brief": "", "category": None}]
-
-
-@pytest.fixture(autouse=True)
-def stubs(monkeypatch):
-    snapshot.reset()   # seo reads the listing through the snapshot (a live one here): built from these rows
-    seo._listing.update(at=0.0, by={}, rows=[])
-    seo._sitemap.update(at=0.0, pages=[], tasks=[])
-    monkeypatch.setattr(seo.catalog, "environments", lambda include_hidden=False: ROWS)
-    monkeypatch.setattr(seo, "index_rows", lambda spec: TASKS if spec == "org/ds" else [])
-
-
-def head(html: str) -> dict:
-    return {"title": re.search(r"<title>(.*?)</title>", html).group(1),
-            "description": re.search(r'<meta name="description" content="([^"]*)"', html).group(1),
-            "canonical": re.search(r'rel="canonical" href="([^"]*)"', html).group(1),
-            "robots": re.search(r'name="robots" content="([^"]*)"', html).group(1),
-            "ld": [json.loads(x) for x in re.findall(r'<script type="application/ld\+json">(.*?)</script>', html, re.S)]}
-
-
-def test_every_page_has_its_own_head():
-    for path, kind in [("/", "WebSite"), ("/d/org/ds", "Dataset"), ("/t/org/ds/tasks/a", "CreativeWork"), ("/s/org/sp", "SoftwareApplication")]:
-        r = client.get(path)
-        assert r.status_code == 200 and r.headers["content-type"].startswith("text/html")
-        h = head(r.text)
-        assert h["canonical"] == "https://testserver" + path and "index" in h["robots"] and not h["robots"].startswith("noindex")
-        assert kind in [x["@type"] for x in h["ld"]] and h["description"]
-    assert "Bench" in head(client.get("/d/org/ds").text)["title"]
-    assert client.get("/t/org/ds/tasks/a").text.count('href="/t/') == 0   # a task page links up, not sideways
-    assert client.get("/d/org/ds").text.count('href="/t/org/ds/tasks/') == 2   # crawlable links to its tasks
-
-
-def test_what_a_page_shows_is_escaped():
-    for path in ("/d/org/ds", "/t/org/ds/tasks/a", "/"):
-        html = client.get(path).text
-        lds = re.findall(r'<script type="application/ld\+json">(.*?)</script>', html, re.S)
-        for x in lds:
-            assert "</" not in x   # nothing in the data can end its script early
-            json.loads(x)
-        rest = re.sub(r'<script type="application/ld\+json">.*?</script>', "", html, flags=re.S)
-        assert "<script>alert(1)" not in rest and '"<b>' not in rest, path
-        assert "&lt;/script&gt;" in rest or path == "/"   # shown, as text
-
-
-def test_personal_and_unknown_pages_arent_indexed():
-    for path in ("/runs", "/run/20260101-000000-abcdef", "/compare/org/ds/tasks/a?r=x,y", "/d/someone/unknown", "/t/org/ds/tasks/zzz"):
-        assert head(client.get(path).text)["robots"].startswith("noindex"), path
-    r = client.get("/nowhere/at/all")
-    assert r.status_code == 404 and head(r.text)["robots"].startswith("noindex")
-    assert client.get("/api/nothing").json() == {"detail": "Not Found"}
-
-
-def test_old_addresses_move_for_good():
-    for old, new in [("/r/org/ds?c=default&s=train&i=3", "/t/org/ds/train/3"), ("/r/org/ds?c=code&s=train&i=6", "/t/org/ds/code/train/6"),
-                     ("/task/music-1", f"/t/{seo.MIMO}/music-1"), ("/rewards", f"/d/{seo.MIMO}?rewards=1")]:
-        r = client.get(old, follow_redirects=False)
-        assert r.status_code == 301 and r.headers["location"] == new, old
-
-
-def test_robots_and_sitemap():
-    t = client.get("/robots.txt").text
-    for line in ("Disallow: /api/", "Disallow: /mcp/", "Disallow: /run/", "Sitemap: https://testserver/sitemap.xml"):
-        assert line in t
-    idx = client.get("/sitemap.xml").text
-    assert "<sitemapindex" in idx and "/sitemap-pages.xml" in idx and "/sitemap-tasks-1.xml" in idx
-    pages = client.get("/sitemap-pages.xml").text
-    assert "https://testserver/d/org/ds" in pages and "https://testserver/s/org/sp" in pages and "<lastmod>2026-10-01</lastmod>" in pages
-    assert "https://testserver/s/org/copy" not in pages   # an unliked, sleeping copy isn't put forward
-    tasks = client.get("/sitemap-tasks-1.xml").text
-    assert "https://testserver/t/org/ds/tasks/a" in tasks
-    assert client.get("/sitemap-tasks-99.xml").status_code == 404
-
-
-def test_preview_images_are_images():
-    for path in ("/og.png", "/og/d/org/ds.png", "/og/t/org/ds/tasks/a.png", "/og/s/org/sp.png"):
-        r = client.get(path)
-        assert r.status_code == 200 and r.headers["content-type"] == "image/png" and r.content[:8] == b"\x89PNG\r\n\x1a\n", path
-    assert client.get("/og/d/org/ds.jpg").status_code == 404
-    # nothing listed there: no image drawn (and its page points at the site's card instead)
-    for path in ("/og/d/nobody/nothing.png", "/og/s/nobody/nothing.png", "/og/whatever.png", "/og/x/y/z.png"):
-        assert client.get(path).status_code == 404, path
-    assert 'content="https://testserver/og.png"' in client.get("/d/nobody/nothing").text
-
-
-def test_a_card_section_heading_is_not_a_datasets_name():
-    from app.catalog import _card_text
-
-    desc = "NVIDIA NeMo Gym knowledge MCQA dataset for training models on multiple choice questions across domains."
-    assert _card_text(f"Dataset Description:\n\n{desc}") == (None, desc)
-    assert _card_text(f"Overview\n\n{desc}")[0] is None
-    assert _card_text(f"Dataset Card for Terminal Bench\n\n{desc}")[0] == "Terminal Bench"
-    assert _card_text(f"Terminal-Bench 2.1\n\n{desc}")[0] == "Terminal-Bench 2.1"

tests/test_snapshot.py

@@ -1,456 +0,0 @@
-"""Catalog snapshots (app/snapshot.py) and the indexer that publishes them (app/indexer.py), with no network.
-
-What is checked: a snapshot built from listing rows holds only public environments and their tasks' public fields
-(no private or gated dataset, no index built for a signed-in visitor, no metadata values); publishing writes the
-database first and the pointer last, and the app swaps to it while a query on the old one finishes; a pointer whose
-database is corrupt, truncated or not the file it names is rejected and the app keeps what it had (or falls back to
-the live catalog); a newer schema's pointer is left alone; the indexer rebuilds only indexes whose dataset changed,
-within its budget, doesn't retry a failure at the same revision, refuses a listing that shrank, publishes nothing
-when any step fails, reruns safely and prunes old snapshots; the same works through the bucket API.
-"""
-
-from __future__ import annotations
-
-import gzip
-import json
-import shutil
-import threading
-import time
-from pathlib import Path
-from types import SimpleNamespace
-
-import pytest
-
-from app import catalog, config, indexer, snapshot
-
-
-def ds(i: int, **kw) -> dict:
-    return {"id": f"snaptest/d{i}", "key": f"snaptest/d{i}", "kind": "dataset", "framework": "harbor", "heading": f"D{i}",
-            "brief": "tasks", "tags": ["t"], "badges": [], "downloads": i, "likes": 0, "trending": i,
-            "updated": "2026-09-01T00:00:00+00:00", **kw}
-
-
-def sp(i: int, **kw) -> dict:
-    return {"id": f"snaptest/s{i}", "key": f"space:snaptest/s{i}", "kind": "space", "framework": "openenv", "openenv": True,
-            "heading": None, "brief": "", "tags": [], "badges": ["OpenEnv"], "downloads": 0, "likes": i, "trending": 0, **kw}
-
-
-ROWS = [ds(0), ds(1), ds(2, private=True), ds(3, gated=True), ds(4), sp(0), sp(1), sp(2)]
-SECRET = "SECRET-ANSWER-4242"
-
-
-def task(path: str, title: str = "A task") -> dict:
-    return {"path": path, "title": title, "brief": "Do the thing.", "category": "c", "difficulty": "easy", "tags": ["x"],
-            "meta": {"gold_answer": SECRET, "note": SECRET}, "withheld": ["gold_answer"], "verifier": {"kind": "txt", "env": ["OPENAI_KEY"]},
-            "env": {"image": "img", "gpus": 0}, "run": "image"}
-
-
-def write_index(spec: str, tasks: list[dict], *, restricted: bool = False, version: int | None = None, sha: str = "sha1",
-                built: float = 1e9, partial: bool = False) -> None:
-    idx = {"spec": spec, "sha": sha, "built": built, "version": version or catalog.INDEX_VERSION, "info": {"restricted": restricted},
-           "tasks": tasks, "summary": {}, **({"partial": True} if partial else {})}
-    catalog.atomic_write(catalog._index_path(spec), gzip.compress(json.dumps(idx).encode()))
-    head = {"tasks": len(tasks), "graded": {"txt": len(tasks)}, "image": len(tasks), "built": built, "sha": sha,
-            "version": version or catalog.INDEX_VERSION}
-    catalog.atomic_write(catalog._head_path(spec), json.dumps(head).encode())
-    catalog._heads.pop(spec, None)
-
-
-@pytest.fixture(autouse=True)
-def isolated(monkeypatch, tmp_path):
-    monkeypatch.setenv("RLX_SNAPSHOT_LOCAL", str(tmp_path / "local"))
-    monkeypatch.setenv("RLX_SNAPSHOT_STORE", str(tmp_path / "store"))
-    monkeypatch.setattr(catalog, "environments", lambda include_hidden=False: ROWS)
-    monkeypatch.setattr(catalog, "hidden", lambda: set())
-    write_index("snaptest/d0", [task("tasks/a", "Alpha"), task("tasks/b", "Beta")])
-    write_index("snaptest/d2", [task("tasks/p")])                    # a private dataset's index (a visitor built it)
-    write_index("snaptest/d4", [task("tasks/r")], restricted=True)   # an index built with a visitor's token
-    snapshot.reset()
-    listing = dict(catalog._env_list)
-    had_listing = (config.STORAGE_DIR / "listing.json.gz").exists()
-    yield
-    snapshot.reset()
-    for p in list(config.INDEX_DIR.glob("snaptest__*")):
-        p.unlink(missing_ok=True)
-    (config.STORAGE_DIR / indexer.STATE).unlink(missing_ok=True)
-    catalog._env_list.clear()
-    catalog._env_list.update(listing)   # the indexer sets catalog's listing: other tests mustn't see these rows
-    if not had_listing:
-        (config.STORAGE_DIR / "listing.json.gz").unlink(missing_ok=True)
-
-
-def store_of(tmp_path: Path) -> snapshot.LocalStore:
-    return snapshot.LocalStore(tmp_path / "store")
-
-
-def build(tmp_path: Path, rows=ROWS, name: str = "build.db") -> tuple[Path, dict]:
-    db = tmp_path / name
-    counts = indexer.build_snapshot(rows, db, {"test": True})
-    return db, counts
-
-
-# ── what a snapshot holds ────────────────────────────────────────────────────
-def test_snapshot_holds_public_rows_and_public_fields_only(tmp_path):
-    db, counts = build(tmp_path)
-    assert counts["envs"] == 6 and counts["datasets"] == 3 and counts["spaces"] == 3
-    assert counts["tasks"] == 2 and counts["task_envs"] == 1   # d0's; not the private one's, nor the restricted index's
-    raw = db.read_bytes()
-    assert SECRET.encode() not in raw and b"gold_answer" not in raw and b"OPENAI_KEY" not in raw
-    import sqlite3
-
-    c = sqlite3.connect(db)
-    assert c.execute("PRAGMA journal_mode").fetchone()[0] != "wal"
-    assert {r[0] for r in c.execute("SELECT key FROM envs")} == {"snaptest/d0", "snaptest/d1", "snaptest/d4", "space:snaptest/s0",
-                                                                 "space:snaptest/s1", "space:snaptest/s2"}
-    assert c.execute("SELECT tasks, framework FROM envs WHERE key = 'snaptest/d0'").fetchone() == (2, "harbor")
-    assert json.loads(c.execute("SELECT v FROM meta WHERE k = 'schema'").fetchone()[0]) == snapshot.SCHEMA
-    names = {r[0] for r in c.execute("SELECT name FROM sqlite_master WHERE type = 'index'")}
-    assert {"envs_trending", "envs_downloads", "envs_likes", "envs_tasks", "envs_updated", "envs_created", "tasks_env"} <= names
-    assert c.execute("SELECT COUNT(*) FROM sqlite_stat1").fetchone()[0] > 0   # ANALYZE ran
-
-
-def test_harbor_whenever_an_index_found_tasks(tmp_path):
-    rows = [ds(0, framework="verifiers"), ds(1, framework="verifiers")]
-    db, _ = build(tmp_path, rows)
-    import sqlite3
-
-    got = dict(sqlite3.connect(db).execute("SELECT id, framework FROM envs"))
-    assert got == {"snaptest/d0": "harbor", "snaptest/d1": "verifiers"}
-
-
-# ── publishing and swapping ──────────────────────────────────────────────────
-class Recording(snapshot.LocalStore):
-    def __init__(self, root):
-        super().__init__(root)
-        self.ops: list[tuple[str, str]] = []
-
-    def put_file(self, src, rel):
-        self.ops.append(("file", rel))
-        super().put_file(src, rel)
-
-    def put_bytes(self, rel, data):
-        self.ops.append(("bytes", rel))
-        super().put_bytes(rel, data)
-
-
-def test_database_first_pointer_last(tmp_path):
-    store = Recording(tmp_path / "store")
-    db, counts = build(tmp_path)
-    ptr = indexer.publish(store, db, counts)
-    assert store.ops == [("file", ptr["db"]), ("bytes", snapshot.POINTER)]
-    assert snapshot.read_pointer(store) == ptr and ptr["sha256"] == snapshot.sha256_file(tmp_path / "store" / ptr["db"])
-    assert ptr["counts"]["envs"] == 6 and ptr["schema"] == snapshot.SCHEMA
-
-
-def test_app_swaps_to_a_new_snapshot_while_a_query_finishes(tmp_path):
-    store = store_of(tmp_path)
-    db, counts = build(tmp_path)
-    first = indexer.publish(store, db, counts)
-    assert snapshot.check(store) and snapshot.current().name == first["db"]
-    with snapshot.use() as (old, conn):
-        assert conn.execute("SELECT COUNT(*) FROM envs").fetchone()[0] == 6
-        db2, counts2 = build(tmp_path, ROWS + [ds(9)], "build2.db")
-        second = indexer.publish(store, db2, counts2, now=snapshot.datetime(2030, 1, 1, tzinfo=snapshot.UTC))
-        assert snapshot.check(store)                                   # swapped under a running query
-        assert snapshot.current().name == second["db"] and old.name == first["db"]
-        assert conn.execute("SELECT COUNT(*) FROM envs").fetchone()[0] == 6   # the old one still answers
-        assert not old._closed
-    assert old._closed                                                 # closed once its last query was done
-    with snapshot.use() as (new, conn):
-        assert new.name == second["db"] and conn.execute("SELECT COUNT(*) FROM envs").fetchone()[0] == 7
-    assert not snapshot.check(store)                                   # nothing new: no work
-
-
-def test_concurrent_queries_during_swaps(tmp_path):
-    store = store_of(tmp_path)
-    db, counts = build(tmp_path)
-    indexer.publish(store, db, counts)
-    snapshot.check(store)
-    errors: list[BaseException] = []
-    stop = threading.Event()
-
-    def reader():
-        while not stop.is_set():
-            try:
-                with snapshot.use() as (_, conn):
-                    assert conn.execute("SELECT COUNT(*) FROM envs").fetchone()[0] in (6, 7)
-            except BaseException as e:  # noqa: BLE001
-                errors.append(e)
-
-    threads = [threading.Thread(target=reader) for _ in range(6)]
-    for t in threads:
-        t.start()
-    for i in range(6):
-        rows = ROWS + ([ds(9)] if i % 2 == 0 else [])
-        dbi, ci = build(tmp_path, rows, f"b{i}.db")
-        indexer.publish(store, dbi, ci, now=snapshot.datetime(2030, 1, 1, 0, 0, i, tzinfo=snapshot.UTC))
-        assert snapshot.check(store)
-    stop.set()
-    for t in threads:
-        t.join()
-    assert not errors
-
-
-def test_corrupt_or_mismatched_snapshots_are_rejected(tmp_path):
-    store = store_of(tmp_path)
-    good_db, counts = build(tmp_path)
-    good = indexer.publish(store, good_db, counts)
-    assert snapshot.check(store)
-    root = tmp_path / "store"
-
-    def point(name: str, data: bytes, sha: str | None = None, **extra) -> None:
-        (root / name).write_bytes(data)
-        ptr = {"db": name, "sha256": sha or snapshot.hashlib.sha256(data).hexdigest(), "size": len(data), "built_at": "x",
-               "schema": snapshot.SCHEMA, "counts": counts, **extra}
-        store.put_bytes(snapshot.POINTER, json.dumps(ptr).encode())
-
-    raw = good_db.read_bytes()
-    point("snapshots/catalog-20300101T000001Z.db", raw, sha="0" * 64)               # not the file the pointer names
-    assert not snapshot.check(store) and "sha256" in snapshot.status()["error"]
-    point("snapshots/catalog-20300101T000002Z.db", b"not a database" * 100)          # garbage with a matching sha
-    assert not snapshot.check(store)
-    point("snapshots/catalog-20300101T000003Z.db", raw[: len(raw) // 2])             # truncated
-    assert not snapshot.check(store)
-    point("snapshots/catalog-20300101T000004Z.db", raw, counts={**counts, "envs": 99})   # not what the pointer says
-    assert not snapshot.check(store)
-    store.put_bytes(snapshot.POINTER, b"{not json")
-    assert not snapshot.check(store)
-    store.put_bytes(snapshot.POINTER, json.dumps({"db": "../../etc/passwd", "sha256": "0" * 64, "schema": 1}).encode())
-    assert not snapshot.check(store)
-    assert snapshot.current().name == good["db"]                                    # the good one stayed in use
-    assert not list((tmp_path / "local").glob("catalog-20300101T00000[234]Z.db"))   # rejected files aren't kept
-
-
-def test_no_usable_snapshot_falls_back_to_the_live_catalog(tmp_path):
-    store = store_of(tmp_path)
-    (tmp_path / "store" / "snapshots").mkdir(parents=True)
-    (tmp_path / "store" / "snapshots" / "catalog-20300101T000000Z.db").write_bytes(b"garbage")
-    store.put_bytes(snapshot.POINTER, json.dumps({"db": "snapshots/catalog-20300101T000000Z.db", "sha256": "1" * 64,
-                                                  "schema": snapshot.SCHEMA, "counts": {}}).encode())
-    with snapshot.use() as (snap, conn):
-        assert snap.source == "live" and conn.execute("SELECT COUNT(*) FROM envs").fetchone()[0] == 6
-        assert conn.execute("SELECT COUNT(*) FROM tasks").fetchone()[0] == 2
-    assert snapshot.status()["source"] == "live" and "rejected" in snapshot.status()["error"]
-
-
-def test_a_newer_schemas_pointer_is_not_read(tmp_path):
-    store = store_of(tmp_path)
-    store.put_bytes(f"snapshots/LATEST.v{snapshot.SCHEMA + 1}.json", b'{"db": "snapshots/catalog-1Z.db"}')
-    assert snapshot.read_pointer(store) is None and not snapshot.check(store)
-
-
-# ── the indexer ──────────────────────────────────────────────────────────────
-def test_plan_rebuilds_only_what_changed(tmp_path, monkeypatch):
-    monkeypatch.setattr(catalog, "featured_datasets", lambda: ["snaptest/f1"])
-    built = 1_790_000_000.0   # 2026-09-21
-    write_index("snaptest/same", [task("t")], sha="s1", built=built)
-    write_index("snaptest/touched", [task("t")], sha="s1", built=built)
-    write_index("snaptest/moved", [task("t")], sha="old", built=built)
-    write_index("snaptest/oldfmt", [task("t")], version=catalog.INDEX_VERSION - 1, built=built)
-    write_index("snaptest/part", [task("t")], built=built)
-    rows = [{**ds(0), "id": i, "key": i, "updated": u, "trending": t} for i, u, t in [
-        ("snaptest/same", "2026-09-01T00:00:00+00:00", 9),       # changed before its index was built: no Hub call
-        ("snaptest/touched", "2026-09-30T00:00:00+00:00", 8),    # changed after, same revision: checked, skipped
-        ("snaptest/moved", "2026-09-30T00:00:00+00:00", 1),      # a new revision
-        ("snaptest/oldfmt", "2026-09-01T00:00:00+00:00", 7),
-        ("snaptest/part", "2026-09-01T00:00:00+00:00", 6),
-        ("snaptest/new", "2026-09-01T00:00:00+00:00", 5),
-        ("snaptest/f1", "2026-09-01T00:00:00+00:00", 0)]]
-    rows.append({**ds(0), "id": "snaptest/rows", "key": "snaptest/rows", "framework": "verl"})   # read row by row: never indexed
-    asked: list[str] = []
-
-    def info(spec):
-        asked.append(spec)
-        return {"sha": "new" if spec == "snaptest/moved" else "s1"}
-
-    items = indexer.plan(rows, {"rebuild": ["snaptest/part"]}, info=info)
-    assert sorted(asked) == ["snaptest/moved", "snaptest/touched"]
-    assert [(i["spec"], i["reason"]) for i in items] == [("snaptest/f1", "new"), ("snaptest/moved", "changed"),
-                                                        ("snaptest/oldfmt", "format"), ("snaptest/part", "partial"),
-                                                        ("snaptest/new", "new")]
-
-
-def test_refresh_keeps_to_its_budget_and_doesnt_retry_failures(tmp_path):
-    items = [{"spec": f"snaptest/x{i}", "reason": "new", "tagged": True, "featured": False, "trending": 0, "downloads": 0, "head": None}
-             for i in range(5)]
-    calls: list[str] = []
-
-    def build(spec, meta):
-        calls.append(spec)
-        if spec == "snaptest/x1":
-            raise ValueError("more than 20,000 tasks")
-        return 3
-
-    state = indexer.load_state()
-    info = lambda spec: {"sha": "r1"}
-    out = indexer.refresh_indexes(items, state, budget_s=60, max_builds=3, build=build, info=info, looks_harbor=lambda s, h: True)
-    assert calls == ["snaptest/x0", "snaptest/x1", "snaptest/x2"] and out["deferred"] == 2
-    assert [b["spec"] for b in out["built"]] == ["snaptest/x0", "snaptest/x2"] and out["failed"][0]["spec"] == "snaptest/x1"
-    calls.clear()
-    out = indexer.refresh_indexes(items[1:2], state, budget_s=60, max_builds=3, build=build, info=info, looks_harbor=lambda s, h: True)
-    assert calls == [] and out["skipped"][0]["why"].startswith("failed at this revision")
-    out = indexer.refresh_indexes(items[1:2], state, budget_s=60, max_builds=3, build=build, info=lambda s: {"sha": "r2"},
-                                  looks_harbor=lambda s, h: True)
-    assert calls == ["snaptest/x1"]                                    # a new revision is tried again
-    out = indexer.refresh_indexes(items, state, budget_s=0, max_builds=3, build=build, info=info)
-    assert out["deferred"] == 5                                        # out of time: nothing started
-
-
-def test_indexer_run_publishes_and_prunes(tmp_path, monkeypatch):
-    store = Recording(tmp_path / "store")
-    monkeypatch.setattr(catalog, "featured_datasets", list)
-    monkeypatch.setattr(catalog, "info", lambda spec: {"sha": "zz"})
-    builds: list[str] = []
-
-    def fake_build(spec, meta):
-        builds.append(spec)
-        write_index(spec, [task("tasks/new")], sha=meta["sha"], built=time.time())
-        return 1
-
-    monkeypatch.setattr(indexer, "_build_one", fake_build)
-    reports = []
-    for i in range(4):
-        reports.append(indexer.run(store, rows=ROWS, budget_s=60, max_builds=10, keep=2))
-        time.sleep(1.05)   # one snapshot a second at most: names are UTC seconds
-    # d4 and d0 changed revision (the Hub says zz), d1 was never indexed; after that, all current: no more builds
-    assert builds == ["snaptest/d4", "snaptest/d0", "snaptest/d1"]
-    assert [r["indexes"]["built"] for r in reports[1:]] == [[], [], []]
-    ptr = snapshot.read_pointer(store)
-    assert ptr == reports[-1]["pointer"] and ptr["counts"]["tasks"] == 3
-    assert store.ops[-2:] == [("file", ptr["db"]), ("bytes", snapshot.POINTER)]
-    dbs = [n for n in store.list("snapshots") if n.endswith(".db")]
-    assert len(dbs) == 2 and ptr["db"] in dbs                          # pruned to --keep
-    assert (config.STORAGE_DIR / "listing.json.gz").exists()
-    assert snapshot.check(store) and snapshot.current().counts["envs"] == 6
-
-
-def test_cached_listing_publication_preserves_discovery_timestamp(tmp_path):
-    at = time.time() - 1800
-    indexer.run(snapshot.LocalStore(tmp_path / "store"), rows=ROWS, index=False, listing_at=at)
-    data = json.loads(gzip.decompress((config.STORAGE_DIR / "listing.json.gz").read_bytes()))
-    assert data["at"] == at
-    assert catalog._env_list["at"] == at
-
-
-def test_timed_out_build_backs_off_so_later_batches_can_progress(monkeypatch):
-    class Stalled:
-        def __init__(self, **kwargs): pass
-        def start(self): pass
-        def join(self, **kwargs): pass
-        def is_alive(self): return True
-    monkeypatch.setattr(indexer.threading, "Thread", Stalled)
-    items = [{"spec": "snaptest/large", "reason": "new", "tagged": True}]
-    state = {"failed": {}, "not_harbor": {}, "rebuild": []}
-    info = lambda spec: {"sha": "same-revision"}
-    first = indexer.refresh_indexes(items, state, budget_s=90, max_builds=4, info=info)
-    assert first["abandoned"] == ["snaptest/large"]
-    second = indexer.refresh_indexes(items, state, budget_s=90, max_builds=4, info=info)
-    assert second["abandoned"] == [] and second["skipped"][0]["spec"] == "snaptest/large"
-
-
-def test_a_failed_run_publishes_nothing(tmp_path, monkeypatch):
-    store = store_of(tmp_path)
-    first = indexer.run(store, rows=ROWS, index=False)["pointer"]
-    time.sleep(1.05)
-    monkeypatch.setattr(snapshot, "build_db", lambda *a, **k: (_ for _ in ()).throw(RuntimeError("disk full")))
-    with pytest.raises(RuntimeError):
-        indexer.run(store, rows=ROWS, index=False)
-    assert snapshot.read_pointer(store) == first
-
-
-def test_a_listing_that_shrank_is_refused(tmp_path):
-    store = store_of(tmp_path)
-    first = indexer.run(store, rows=ROWS, index=False)["pointer"]
-    with pytest.raises(indexer.IndexerError, match="refusing to publish"):
-        indexer.run(store, rows=ROWS[:2], index=False)               # the Spaces' listing failed
-    assert snapshot.read_pointer(store) == first
-    time.sleep(1.05)
-    assert indexer.run(store, rows=ROWS[:2], index=False, force=True)["pointer"]["counts"]["envs"] == 2
-
-
-def test_dry_run_writes_nothing(tmp_path):
-    store = store_of(tmp_path)
-    out = tmp_path / "dry.db"
-    report = indexer.run(store, rows=ROWS, dry_run=True, out=out)
-    assert report["counts"]["envs"] == 6 and out.exists()
-    assert snapshot.read_pointer(store) is None and not (tmp_path / "store").exists()
-
-
-def test_main_exit_status(tmp_path, monkeypatch):
-    monkeypatch.setenv("STORAGE_DIR", str(config.STORAGE_DIR))   # main() points it at --store: restored after
-    monkeypatch.setattr(indexer, "fetch_listing", lambda attempts=2: (_ for _ in ()).throw(indexer.IndexerError("Hub down")))
-    monkeypatch.setattr("app.runtime.logs", lambda: None)
-    assert indexer.main(["--store", str(tmp_path / "store"), "--no-index"]) == 1
-    assert not (tmp_path / "store" / snapshot.POINTER).exists()
-
-
-# ── through the bucket API ───────────────────────────────────────────────────
-class FakeBucketApi:
-    """The four bucket calls the store uses, over a dict."""
-
-    def __init__(self):
-        self.files: dict[str, bytes] = {}
-        self.batches: list[dict] = []
-
-    def batch_bucket_files(self, bucket_id, *, add=None, delete=None, copy=None, token=None):
-        self.batches.append({"add": [p for _, p in add or []], "delete": list(delete or [])})
-        for src, path in add or []:
-            self.files[path] = src if isinstance(src, bytes) else Path(src).read_bytes()
-        for path in delete or []:
-            self.files.pop(path, None)
-
-    def download_bucket_files(self, bucket_id, files, *, raise_on_missing_files=False, token=None):
-        for path, dst in files:
-            if path not in self.files:
-                if raise_on_missing_files:
-                    raise FileNotFoundError(path)
-                continue
-            Path(dst).write_bytes(self.files[path])
-
-    def list_bucket_tree(self, bucket_id, prefix=None, *, recursive=None, token=None):
-        return [SimpleNamespace(type="file", path=p, size=len(b)) for p, b in sorted(self.files.items()) if p.startswith(prefix or "")]
-
-    def get_bucket_paths_info(self, bucket_id, paths, *, token=None):
-        return [SimpleNamespace(type="file", path=p, size=len(self.files[p])) for p in paths if p in self.files]
-
-
-def test_the_same_through_the_bucket_api(tmp_path):
-    api = FakeBucketApi()
-    store = snapshot.BucketStore("FineEnvs/rl-explorer-data", api=api)
-    report = indexer.run(store, rows=ROWS, index=False, keep=1)
-    ptr = report["pointer"]
-    assert [b["add"] for b in api.batches] == [[ptr["db"]], [snapshot.POINTER]]   # the database, then the pointer
-    assert snapshot.check(store) and snapshot.current().counts["envs"] == 6
-    time.sleep(1.05)
-    indexer.run(store, rows=ROWS, index=False, keep=1)
-    assert api.batches[-1]["delete"] == [ptr["db"]]                                 # pruned through the API too
-    assert str(snapshot.open_store("hf://buckets/FineEnvs/rl-explorer-data/sub")).endswith("rl-explorer-data/sub")
-
-
-def teardown_module(module):
-    shutil.rmtree(Path(config.STORAGE_DIR) / "snapshots", ignore_errors=True)
-
-
-def test_a_snapshot_whose_file_vanished_is_dropped_and_fetched_again(tmp_path):
-    store = store_of(tmp_path)
-    db, counts = build(tmp_path)
-    indexer.publish(store, db, counts)
-    assert snapshot.check(store)
-    snap = snapshot.current()
-    snap._close()                    # its pooled connections gone, as after a while idle
-    snap._closed = False
-    snap.path.unlink()               # a disk cleaner took the file
-    with snapshot.use() as (s, conn):   # this request is still answered: the snapshot is fetched again at once
-        assert conn.execute("SELECT COUNT(*) FROM envs").fetchone()[0] == 6
-    assert s is not snap and s.name == snap.name and s.path.exists() and snapshot.current() is s
-
-
-def test_fallback_files_of_dead_processes_are_cleaned(tmp_path):
-    local = tmp_path / "local"
-    local.mkdir(parents=True)
-    dead, mine = local / "fallback-999999-1.db", local / f"fallback-{snapshot.os.getpid()}-77.db"
-    dead.write_bytes(b"x")
-    mine.write_bytes(b"x")
-    with snapshot.use() as (snap, _):
-        assert snap.source == "live"
-    assert not dead.exists() and mine.exists()

tests/test_space_checks.py

@@ -1,135 +0,0 @@
-import json
-import time
-
-import pytest
-
-from app import space_checks as checks, spaces_live as live
-
-
-def facts():
-    api = {"info": {"version": "1.0.0"}, "paths": {
-        "/reset": {"post": {}}, "/step": {"post": {}}, "/state": {"get": {}}, "/mcp": {"post": {}}}}
-    return [api, {"status": "healthy"}, {"name": "test", "description": "test", "version": "9.9.9"},
-            {"action": {}, "observation": {}, "state": {}}, None]
-
-
-def test_typed_actions_do_not_require_mcp_but_production_does():
-    f = facts()
-    assert checks.assess(*f)["status"] == checks.PASS
-    f[0]["paths"] = {"/mcp": {"post": {}}}
-    assert checks.assess(*f)["status"] == "Checks failed"
-    f[-1] = [{"name": "echo"}]
-    assert checks.assess(*f)["mode"] == "MCP service"
-
-
-@pytest.mark.parametrize("change", ["schema", "health", "route", "method", "html"])
-def test_failures_cannot_become_api_checked(change):
-    f = facts()
-    if change == "schema":
-        f[3].pop("state")
-    elif change == "health":
-        f[1]["status"] = "ok"
-    elif change == "route":
-        f[0]["paths"].pop("/step")
-    elif change == "method":
-        f[0]["paths"]["/step"] = {"get": {}}
-    else:
-        f[0] = "<html>Space UI</html>"
-    assert checks.assess(*f)["status"] == "Checks failed"
-
-
-@pytest.mark.parametrize("dependency,value,source", [
-    ("openenv-core==0.2.3", "0.2.3", "Dependency pin"),
-    ("openenv==0.7.0", "0.7.0", "Dependency pin"),
-    ("openenv_core[core]>=0.2.0,<0.3", "<0.3,>=0.2.0", "Dependency constraint"),
-    ("openenv-core==0.2.*", "==0.2.*", "Dependency constraint"),
-    ("openenv-core", "Unpinned", "Dependency constraint"),
-    ("openenv-core @ git+https://github.com/meta-pytorch/OpenEnv.git@abc123", "git:abc123", "Source reference"),
-    ('openenv-core==0.2.3; python_version < "3.12"', "Conditional", "Dependency constraint"),
-])
-def test_declared_versions_keep_constraints_and_source_refs(dependency, value, source):
-    v = checks.requirement_version(dependency)
-    assert (v["value"], v["source"]) == (value, source)
-
-
-def test_version_does_not_use_environment_or_api_version():
-    assert checks.parse_version('[project]\nname="env"\nversion="9.9.9"\ndependencies=["fastapi"]', "pyproject.toml") is None
-    assert checks.requirement_version("gymnasium==1.0.0") is None
-    assert checks.tag_version(["openenv", "openenv-nonsense"])["value"] == "Unknown"
-    assert checks.tag_version(["openenv-0.2.3"])["value"] == "0.2.3"
-
-
-def test_lock_and_uv_source_precedence():
-    doc = '[[package]]\nname="openenv-core"\nversion="0.7.1.dev0"\nsource={git="https://example.org/env?rev=main#abcdef"}'
-    assert checks.parse_version(doc, "uv.lock") == {"value": "git:abcdef", "source": "Lockfile"}
-    doc = '[project]\ndependencies=["openenv-core>=0.2"]\n[tool.uv.sources]\nopenenv-core={git="https://example.org/env",rev="v0.2.3"}'
-    assert checks.parse_version(doc, "pyproject.toml")["value"] == "git:v0.2.3"
-    assert checks.parse_version(doc.replace("openenv-core", "openenv"), "pyproject.toml")["value"] == "git:v0.2.3"
-
-
-def test_expiry_future_dates_and_newer_failures(tmp_path, monkeypatch):
-    monkeypatch.setattr(checks.config, "STORAGE_DIR", tmp_path)
-    now = time.time()
-    passing = {"schema": 1, "id": "owner/env", "checked_at": now - 10, "status": checks.PASS}
-    checks.save(passing)
-    assert checks.status(checks.inventory()["owner/env"], now) == checks.PASS
-    assert checks.status(passing, now + checks.FRESH) == "Check expired"
-    assert checks.status(passing, now - 20) == "Check expired"
-    checks.save({**passing, "checked_at": now, "status": "Checks failed"})
-    checks.save(passing)  # late completion cannot overwrite a newer failure
-    assert checks.status(checks.inventory()["owner/env"], now) == "Checks failed"
-
-
-def test_sleeping_space_is_not_contacted_or_woken(tmp_path, monkeypatch):
-    monkeypatch.setattr(checks.config, "STORAGE_DIR", tmp_path)
-    monkeypatch.setattr(live, "record", lambda *a, **kw: {"stage": "SLEEPING"})
-    monkeypatch.setattr(live, "SpaceClient", lambda *a, **kw: pytest.fail("contacted sleeping server"))
-    r = checks.check("owner/sleeping")
-    assert r["status"] == "Not running"
-
-
-def test_network_failure_invalidates_previous_pass(tmp_path, monkeypatch):
-    monkeypatch.setattr(checks.config, "STORAGE_DIR", tmp_path)
-    checks.save({"schema": 1, "id": "owner/env", "checked_at": time.time() - 10, "status": checks.PASS})
-    def offline(*a, **kw):
-        raise ConnectionError("offline")
-    monkeypatch.setattr(live, "record", offline)
-    assert checks.check("owner/env")["status"] == "Check unavailable"
-    assert checks.status(checks.inventory()["owner/env"]) != checks.PASS
-
-
-def test_concurrent_refresh_skips_locked_queue(tmp_path, monkeypatch):
-    fcntl = pytest.importorskip("fcntl")
-    monkeypatch.setattr(checks.config, "CACHE_DIR", tmp_path)
-    monkeypatch.setattr(checks, "_scan", lambda: pytest.fail("started duplicate queue"))
-    with (tmp_path / "openenv-checks.lock").open("a") as lease:
-        fcntl.flock(lease, fcntl.LOCK_EX | fcntl.LOCK_NB)
-        assert checks.scan() == []
-
-
-def test_automatic_queue_includes_inactive_and_untagged_without_starvation():
-    candidates = [(f"org/active{i}", "RUNNING") for i in range(120)] + [(f"org/sleep{i}", "SLEEPING") for i in range(40)]
-    candidates += [("FineEnvs/recent", "RUNNING"), ("FineEnvs/new", "RUNNING")]
-    now = time.time()
-    old = {"FineEnvs/recent": {"stage": "RUNNING", "checked_at": now, "status": checks.PASS, "task_catalog": {}}}
-    pending = checks.pending(candidates, old, now)
-    assert len(pending) == 128 and pending[0] == "FineEnvs/new"
-    assert sum("sleep" in spec for spec in pending) == 32
-    assert "FineEnvs/recent" not in pending
-    for spec in pending:
-        old[spec] = {"checked_at": now, "stage": "SLEEPING", "status": "Not running"}
-    next_batch = checks.pending(candidates, old, now)
-    assert next_batch and not set(next_batch) & set(pending)
-
-
-def test_other_environment_interfaces_need_published_methods_and_fresh_running_checks():
-    api = {"info": {"version": "1"}, "paths": {"/seed_session": {"post": {}}, "/verify": {"post": {}}}}
-    assert checks.environment_interface(api) == "nemo-gym"
-    rec = {"interface": "nemo-gym", "status": "Checks failed", "stage": "RUNNING", "checked_at": time.time()}
-    assert checks.browseable(rec) and not checks.verified(rec)
-    assert not checks.browseable({**rec, "checked_at": time.time() - checks.FRESH})
-    assert not checks.browseable({**rec, "stage": "SLEEPING"})
-    assert not checks.browseable({**rec, "status": "Check unavailable"})
-    api["paths"]["/verify"] = {"get": {}}
-    assert checks.environment_interface(api) is None
-    assert checks.environment_interface(facts()[0]) is None  # generic reset/step alone is insufficient

tests/test_space_files.py

@@ -1,449 +0,0 @@
-"""An environment Space read as files, and what a live probe leaves behind (no network: the Hub is stubbed).
-
-What is checked: openenv.yaml in its variants (canonical, legacy class names, hackathon task lists, the `validation:`
-block, a manifest in a subfolder, broken or explosive YAML); models.py, server/app.py and the environment read with
-`ast`, never imported or run; vendored OpenEnv and build output left out of the tree; the file endpoint serves only
-listed text files (no traversal, no binaries, no answers); private Spaces are refused and no token is ever sent;
-the last good probe is kept and shown while the Space sleeps; `openenv validate`'s six criteria are judged right.
-"""
-
-from __future__ import annotations
-
-import json
-import time
-from pathlib import Path
-from types import SimpleNamespace
-
-import pytest
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-
-from app import catalog, config
-from app import space_files as sf
-from app import spaces_live as live
-
-api = FastAPI()
-api.include_router(sf.router)
-client = TestClient(api)
-
-SHA = "a" * 40
-
-
-@pytest.fixture(autouse=True)
-def fresh():
-    catalog._memo.clear()
-    yield
-    catalog._memo.clear()
-
-
-def sibling(name, size=100, lfs=False):
-    return SimpleNamespace(rfilename=name, size=size, lfs={"sha256": "x"} if lfs else None)
-
-
-def stub_space(monkeypatch, tmp_path, files: dict[str, str | bytes], private=False, extra: list[str] = (), seen_tokens=None):
-    """A public Space whose repository holds `files` (path -> content) and `extra` (listed only)."""
-    sibs = [sibling(p, len(c.encode() if isinstance(c, str) else c)) for p, c in files.items()] + [sibling(p) for p in extra]
-    sp = SimpleNamespace(sha=SHA, private=private, gated=False, siblings=sibs, subdomain="org-env", sdk="docker", tags=["openenv"],
-                         card_data=SimpleNamespace(to_dict=lambda: {"title": "Env", "base_path": "/web", "app_port": 8000}),
-                         runtime=SimpleNamespace(stage="SLEEPING", hardware=None, requested_hardware="cpu-basic"),
-                         last_modified=None)
-
-    def space_info(spec, files_metadata=False, expand=None):
-        return sp
-
-    def _api(token=None):
-        if seen_tokens is not None:
-            seen_tokens.append(("api", token))
-        return SimpleNamespace(space_info=space_info)
-
-    calls = []
-
-    def download(repo_id, filename, repo_type=None, revision=None, token=None, cache_dir=None, **kw):
-        calls.append({"repo": repo_id, "file": filename, "type": repo_type, "revision": revision, "token": token})
-        p = tmp_path / "dl" / filename
-        p.parent.mkdir(parents=True, exist_ok=True)
-        data = files[filename]
-        p.write_bytes(data.encode() if isinstance(data, str) else data)
-        return str(p)
-
-    import huggingface_hub
-
-    monkeypatch.setattr(catalog, "_api", _api)
-    monkeypatch.setattr(huggingface_hub, "hf_hub_download", download)
-    return calls
-
-
-# ── openenv.yaml ─────────────────────────────────────────────────────────────
-CANONICAL = """spec_version: 1
-name: echo_env
-type: space
-runtime: fastapi
-app: server.app:app
-port: 8000
-"""
-
-
-def test_canonical_manifest_keys():
-    m = sf.parse_manifest(CANONICAL, "openenv.yaml")
-    assert m["keys"] == {"spec_version": 1, "name": "echo_env", "type": "space", "runtime": "fastapi", "app": "server.app:app", "port": 8000}
-    assert "validation" not in m and "tasks" not in m and "error" not in m
-
-
-def test_legacy_manifest_names_its_classes():
-    m = sf.parse_manifest('name: browsergym_env\nversion: "0.1.0"\naction: BrowserGymAction\nobservation: BrowserGymObservation\n', "openenv.yaml")
-    assert m["legacy"] == {"action": "BrowserGymAction", "observation": "BrowserGymObservation"}
-    assert m["keys"]["version"] == "0.1.0"
-
-
-def test_hackathon_task_lists_in_every_shape_and_without_answers():
-    listed = sf.parse_manifest("""name: triage
-tasks:
-  - id: easy
-    name: Direct injection
-    difficulty: easy
-    description: Detect it.
-    expected_score_range: [0.2, 0.5]
-    gold_answer: "yes"
-  - id: hard
-    level: hard
-reward:
-  min: 0.0
-  max: 1.0
-  expected_output: 42
-""", "openenv.yaml")
-    assert [t["id"] for t in listed["tasks"]] == ["easy", "hard"]
-    assert listed["tasks"][0]["difficulty"] == "easy" and listed["tasks"][1]["difficulty"] == "hard"
-    flat = json.dumps(listed)
-    assert "gold_answer" not in flat and "expected_score_range" not in flat and "42" not in flat
-    assert "expected_output" in listed["withheld"]
-    strings = sf.parse_manifest("name: x\ntasks: [easy, medium, hard]\n", "openenv.yaml")
-    assert [t["id"] for t in strings["tasks"]] == ["easy", "medium", "hard"]
-    keyed = sf.parse_manifest("name: x\ntasks:\n  easy: {description: one}\n  hard: two\n", "openenv.yaml")
-    assert keyed["tasks"] == [{"id": "easy", "description": "one"}, {"id": "hard", "description": "two"}]
-
-
-def test_validation_block():
-    m = sf.parse_manifest(CANONICAL + """validation:
-  reward: {range: [0.0, 1.0], oracle_tolerance: 0.01, floor_margin: 0.5, variance_tolerance: 0.05}
-  judge: {model: Qwen/Qwen3-8B, version: "2025-05", params: {temperature: 0}}
-  resources: {cpu: 2, memory_mb: 4096, disk_mb: 2048, episode_timeout_s: 600}
-  network: {mode: allowlist, allowed_hosts: [api.example.com]}
-  capabilities:
-    verifier: {kind: reward_channel}
-    llm_judged: true
-    task_api: true
-    declared_tools: [look, submit_guess]
-    declared_task_count: {train: 1000, eval: 200}
-  types: {tags: [geo]}
-""", "openenv.yaml")
-    v = m["validation"]
-    assert v["reward"]["range"] == [0.0, 1.0] and v["reward"]["variance_tolerance"] == 0.05
-    assert v["judge"]["model"] == "Qwen/Qwen3-8B"
-    assert v["capabilities"]["llm_judged"] is True and v["capabilities"]["verifier"]["kind"] == "reward_channel"
-    assert v["capabilities"]["declared_tools"] == ["look", "submit_guess"]
-    assert v["capabilities"]["declared_task_count"] == {"train": 1000, "eval": 200}
-    assert v["network"] == {"mode": "allowlist", "allowed_hosts": ["api.example.com"]}
-    assert v["resources"]["memory_mb"] == 4096 and v["types"] == ["geo"]
-
-
-def test_broken_and_explosive_yaml_is_said_so_quickly():
-    assert sf.parse_manifest("name: [unclosed\n", "openenv.yaml")["error"].startswith("not valid YAML")
-    assert sf.parse_manifest("- just\n- a list\n", "openenv.yaml")["error"] == "not a YAML mapping"
-    laughs = "a: &a [x, x, x, x, x, x, x, x, x]\n" + "".join(f"{c}: &{c} [*{p}, *{p}, *{p}, *{p}, *{p}, *{p}, *{p}, *{p}, *{p}]\n"
-                                                         for p, c in zip("abcdefgh", "bcdefghi")) + "rubric: *i\n"
-    t = time.time()
-    m = sf.parse_manifest(laughs, "openenv.yaml")
-    assert time.time() - t < 2 and len(json.dumps(m)) < 2_000_000
-
-
-def test_the_shallowest_manifest_wins_and_ties_follow_the_dockerfile():
-    paths = ["envs/deep/x/openenv.yaml", "env/openenv.yaml", "geoguesser_env/openenv.yaml", "src/openenv/cli/templates/openenv_env/openenv.yaml"]
-    assert sf.manifest_path(paths, "FROM python:3.12\nCOPY geoguesser_env /app/geoguesser_env\n", "FineEnvs/geoguesser-env") == "geoguesser_env/openenv.yaml"
-    assert sf.manifest_path(paths, None, "FineEnvs/geoguesser-env") == "geoguesser_env/openenv.yaml"   # named like the Space
-    assert sf.manifest_path(paths, None, "someone/other") == "env/openenv.yaml"
-    assert sf.manifest_path(["a/openenv.yaml", "openenv.yaml"], None, "o/n") == "openenv.yaml"
-    assert sf.manifest_path(["src/openenv/cli/templates/openenv_env/openenv.yaml"], None, "o/n") is None
-
-
-def test_a_subfolder_manifest_roots_the_environment(monkeypatch, tmp_path):
-    files = {"Dockerfile": "FROM python:3.12\nCOPY my_env /app/my_env\nENV ENABLE_WEB_INTERFACE=true\n",
-             "my_env/openenv.yaml": CANONICAL.replace("echo_env", "my_env"),
-             "my_env/models.py": "from openenv.core.env_server.types import Action, Observation\nclass A(Action):\n    x: int = 1\n",
-             "my_env/server/app.py": "app = create_app(E, A, O, env_name='my_env')\n",
-             "my_env/server/my_environment.py": "class E(Environment):\n    pass\n",
-             "my_env/pyproject.toml": '[project]\nname = "openenv-my-env"\ndependencies = ["openenv-core>=0.2.1"]\n'}
-    stub_space(monkeypatch, tmp_path, files)
-    d = sf.declared("org/env")
-    assert d["root"] == "my_env" and d["sha"] == SHA and d["short"] == SHA[:7]
-    assert d["keys"]["manifest"] == "my_env/openenv.yaml" and d["keys"]["models"] == "my_env/models.py"
-    assert d["declared"]["manifest"]["keys"]["name"] == "my_env"
-    assert d["declared"]["app"]["env_name"] == "my_env"
-    assert d["declared"]["dockerfile"]["web_interface"] is True
-    assert d["declared"]["pyproject"]["openenv_version"] == ">=0.2.1"
-    assert d["declared"]["card"]["base_path"] == "/web"
-
-
-# ── Python, parsed and never run ─────────────────────────────────────────────
-MODELS = '''
-import os
-os.system("touch {marker}")
-raise SystemExit("models.py must never run here")
-
-from enum import Enum
-from pydantic import Field
-from openenv.core.env_server.types import Action, Observation, State
-
-
-class Mode(str, Enum):
-    EASY = "easy"
-    HARD = "hard"
-
-
-class Base(Action):
-    """Every action."""
-
-
-class MoveAction(Base):
-    """Walk along the road.
-
-    More detail."""
-    direction: str = Field(..., description="forward or backward", pattern="^(forward|backward)$")
-    meters: float = Field(default=10.0, gt=0, description="how far")
-    tags: list[str] = Field(default_factory=list)
-    _private: int = 0
-
-
-class GeoObservation(Observation):
-    image_b64: str = Field(default="", description="the view, as base64 PNG")
-    feedback: str = ""
-    model_config = {{"extra": "forbid"}}
-
-
-class GeoState(State):
-    step_count: int = 0
-'''
-
-
-def test_models_are_parsed_and_never_executed(tmp_path):
-    marker = tmp_path / "pwned"
-    m = sf.parse_models(MODELS.format(marker=marker), "models.py")   # would raise SystemExit, or touch the marker, if run
-    assert not marker.exists()
-    by = {c["name"]: c for c in m["classes"]}
-    assert by["MoveAction"]["role"] == "action" and by["Base"]["role"] == "action"     # through Base, within the file
-    assert by["GeoObservation"]["role"] == "observation" and by["GeoState"]["role"] == "state"
-    assert by["Mode"]["kind"] == "enum" and by["Mode"]["values"] == ["'easy'", "'hard'"] and by["Mode"]["role"] is None
-    assert by["MoveAction"]["doc"] == "Walk along the road."
-    f = {x["name"]: x for x in by["MoveAction"]["fields"]}
-    assert set(f) == {"direction", "meters", "tags"}                                      # private fields left out
-    assert f["direction"]["required"] is True and f["direction"]["description"] == "forward or backward"
-    assert f["meters"]["default"] == "10.0" and not f["meters"]["required"] and "gt 0" in f["meters"]["limits"]
-    assert f["tags"]["default"] == "list()" and f["tags"]["type"] == "list[str]"
-    o = {x["name"]: x for x in by["GeoObservation"]["fields"]}
-    assert o["image_b64"].get("image") is True and "model_config" not in o
-    assert sf.parse_models("def broken(:\n", "models.py")["error"]
-
-
-def test_server_app_and_environment_are_read_not_run(tmp_path):
-    marker = tmp_path / "ran"
-    app_py = f'''
-import os
-open("{marker}", "w").write("x")
-MAX_CONCURRENT = int(os.getenv("MAX_CONCURRENT_ENVS", "4"))
-app = create_app(GeoEnvironment, GeoAction, GeoObservation, env_name="geo", max_concurrent_envs=MAX_CONCURRENT,
-                 gradio_builder=build_ui, custom_tab_name="Play")
-
-@app.get("/geo/task/{{i}}")
-def task(i: int): ...
-'''
-    a = sf.parse_app(app_py, "server/app.py")
-    assert not marker.exists()
-    assert (a["env"], a["action"], a["observation"], a["env_name"]) == ("GeoEnvironment", "GeoAction", "GeoObservation", "geo")
-    assert a["max_concurrent_envs"] == 4 and a["gradio_builder"] == "build_ui" and a["custom_tab_name"] == "Play"
-    assert a["routes"] == ["GET /geo/task/{i}"] and not a["mcp"]
-    assert sf.parse_app("app = create_app(E, CallToolAction, CallToolObservation, env_name='echo')", "server/app.py")["mcp"] is True
-
-    env = sf.parse_environment('''
-from openai import OpenAI
-from .scoring import compute_reward
-from openenv.core.env_server.mcp_environment import MCPEnvironment
-
-class GeoEnvironment(MCPEnvironment):
-    def _register(self, mcp):
-        @mcp.tool
-        def look(heading_deg: float, fov_deg: float = 90):
-            """Render a view."""
-        @mcp.tool()
-        def submit_guess(lat: float, lon: float):
-            """Commit the answer."""
-
-    def _grade(self, guess):
-        return compute_reward(guess)
-''', "server/geo_environment.py")
-    assert [t["name"] for t in env["tools"]] == ["look", "submit_guess"]
-    assert env["tools"][0]["params"] == ["heading_deg", "fov_deg"] and env["tools"][0]["description"] == "Render a view."
-    assert env["llm_judge"] is True and env["mcp"] is True and "_grade" in env["functions"]
-    assert sf.reward_files("server/geo_environment.py", env["reward_imports"], {"server/scoring.py"}, "") == ["server/scoring.py"]
-    assert sf.parse_environment("from openenv.core.rubrics import Rubric\nclass R(Rubric): pass\n", "e.py")["rubric"] is True
-
-
-def test_dockerfile_and_pyproject_facts():
-    d = sf.parse_dockerfile("ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest\nFROM ${BASE_IMAGE} AS builder\n"
-                            "FROM ${BASE_IMAGE}\nENV ENABLE_WEB_INTERFACE=true\nEXPOSE 7860\n"
-                            'CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000"]\n', "Dockerfile")
-    assert d["from"] == ["ghcr.io/meta-pytorch/openenv-base:latest"] and d["web_interface"] is True
-    assert d["expose"] == 7860 and d["port"] == 8000
-    assert sf.parse_dockerfile("FROM python:3.12\nENV ENABLE_WEB_INTERFACE false\n", "Dockerfile")["web_interface"] is False
-    git = sf.parse_pyproject('[project]\nname = "openenv-echo-env"\ndependencies = ["fastapi", '
-                             '"openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git@v0.2.3"]\n'
-                             '[project.scripts]\nserver = "echo_env.server.app:main"\n', "pyproject.toml")
-    assert git["package"] == "openenv-echo-env" and git["openenv_version"] == "0.2.3" and git["server_script"] == "echo_env.server.app:main"
-    assert sf.parse_pyproject('[project]\ndependencies = ["openenv==0.3.1"]\n', "p")["openenv_version"] == "0.3.1"
-    assert "openenv" not in sf.parse_pyproject('[project]\ndependencies = ["openenv-echo-env>=1"]\n', "p")   # another package
-    assert sf.parse_pyproject("not = [toml", "p")["error"]
-
-
-# ── the tree ────────────────────────────────────────────────────────────────��
-def test_junk_is_left_out_of_the_tree():
-    info = {"files": [(p, 10, False) for p in (
-        ".gitattributes", "README.md", "openenv.yaml", "models.py", "server/app.py", "uv.lock",
-        "src/openenv/core/env_server/http_server.py", "src/core/env_client.py", "src/openenv_core/__init__.py",
-        "build/lib/server/app.py", "envs/echo_env/build/lib/echo_env/client.py", "openenv_echo_env.egg-info/PKG-INFO",
-        "server/__pycache__/app.cpython-312.pyc", "envs/echo_env/server/app.py", "solution/solve.py",
-        "tasks/eval.jsonl", "data/geo/countries.geojson")] + [("assets/map.png", 10, True)]}
-    files, dropped, truncated = sf.listing(info)
-    paths = [f["path"] for f in files]
-    assert paths == sorted(["README.md", "openenv.yaml", "models.py", "server/app.py", "uv.lock", "envs/echo_env/server/app.py",
-                            "solution/solve.py", "tasks/eval.jsonl", "data/geo/countries.geojson", "assets/map.png"])
-    assert dropped == 8 and not truncated
-    by = {f["path"]: f for f in files}
-    assert by["uv.lock"]["collapsed"] and by["assets/map.png"]["binary"]
-    assert by["solution/solve.py"]["withheld"] and by["tasks/eval.jsonl"]["withheld"]
-    assert not by["data/geo/countries.geojson"].get("withheld") and not by["openenv.yaml"].get("withheld")
-
-
-# ── one file ─────────────────────────────────────────────────────────────────
-def test_the_file_endpoint_serves_only_listed_text(monkeypatch, tmp_path):
-    big = "x" * (sf.MAX_TEXT + 10)
-    calls = stub_space(monkeypatch, tmp_path, {
-        "openenv.yaml": CANONICAL, "models.py": "class A: pass\n", "big.txt": big,
-        "blob.dat": b"\x00\x01binary", "picture.png": b"\x89PNG", "config/answers.json": '{"x": 1}',
-        "data/manifest.json": '{"steps": [{"original_bash": "ls"}]}',
-        "uv.lock": 'version = 1\n[[package]]\nname = "fastapi"\nversion = "0.115.0"\n[[package]]\nname = "openenv-core"\nversion = "0.2.3"\n',
-    }, extra=["src/openenv/core/secret.py"])
-    r = client.get("/api/spaces/org/env/file", params={"f": "models.py"})
-    assert r.status_code == 200 and r.json()["text"] == "class A: pass\n" and r.json()["sha"] == SHA
-    for bad in ("../etc/passwd", "/etc/passwd", "server/../models.py", "a\\b", "./models.py", ""):
-        assert client.get("/api/spaces/org/env/file", params={"f": bad}).status_code in (400, 404), bad
-    assert client.get("/api/spaces/org/env/file", params={"f": "src/openenv/core/secret.py"}).status_code == 404   # junk: not served
-    assert client.get("/api/spaces/org/env/file", params={"f": "nothere.py"}).status_code == 404
-    assert client.get("/api/spaces/org/env/file", params={"f": "picture.png"}).status_code == 415   # binary by name
-    assert client.get("/api/spaces/org/env/file", params={"f": "blob.dat"}).status_code == 415      # binary by content
-    long = client.get("/api/spaces/org/env/file", params={"f": "big.txt"}).json()
-    assert long["truncated"] and len(long["text"]) == sf.MAX_TEXT
-    for answers in ("config/answers.json", "data/manifest.json"):                                  # by name; by its keys
-        w = client.get("/api/spaces/org/env/file", params={"f": answers}).json()
-        assert w["withheld"] and "text" not in w, answers
-    lock = client.get("/api/spaces/org/env/file", params={"f": "uv.lock"}).json()
-    assert lock["collapsed"] and "openenv-core  0.2.3" in lock["text"] and "[[package]]" not in lock["text"]
-    assert {c["file"] for c in calls} <= {"models.py", "big.txt", "blob.dat", "data/manifest.json", "uv.lock"}   # never the junk or the png
-    assert all(c["token"] is False and c["revision"] == SHA and c["type"] == "space" for c in calls)
-
-
-def test_files_endpoint_shape_and_no_token(monkeypatch, tmp_path):
-    tokens = []
-    stub_space(monkeypatch, tmp_path, {"openenv.yaml": CANONICAL, "README.md": "# hi\n"}, extra=["src/core/x.py", "build/lib/a.py"], seen_tokens=tokens)
-    r = client.get("/api/spaces/org/env/files", headers={"Authorization": "Bearer hf_visitor_token"})
-    assert r.status_code == 200
-    d = r.json()
-    assert [f["path"] for f in d["files"]] == ["README.md", "openenv.yaml"] and d["dropped"] == 2
-    assert d["subdomain"] == "org-env" and d["hardware"] == "cpu-basic" and d["declared"]["manifest"]["keys"]["name"] == "echo_env"
-    assert tokens and all(t is None for _, t in tokens)                                             # catalog._api(): anonymous
-
-
-def test_private_spaces_are_refused(monkeypatch, tmp_path):
-    stub_space(monkeypatch, tmp_path, {"openenv.yaml": CANONICAL}, private=True)
-    assert client.get("/api/spaces/org/env/files").status_code == 404
-    assert client.get("/api/spaces/org/env/file", params={"f": "openenv.yaml"}).status_code == 404
-    from huggingface_hub.errors import RepositoryNotFoundError
-
-    def missing(spec, **kw):
-        raise RepositoryNotFoundError("nope", response=SimpleNamespace(status_code=404, headers={}, request=None))
-
-    catalog._memo.clear()
-    monkeypatch.setattr(catalog, "_api", lambda token=None: SimpleNamespace(space_info=missing))
-    assert client.get("/api/spaces/org/env/files").status_code == 404
-    assert client.get("/api/spaces/../x/files").status_code in (400, 404)
-
-
-# ── last seen, and openenv validate's criteria ───────────────────────────────
-SCHEMA = {"action": {"properties": {"message": {"type": "string"}}}, "observation": {"properties": {"reward": {}}}, "state": {"properties": {}}}
-OPENAPI = {"info": {"version": "1.0.0"}, "paths": {p: {} for p in ("/reset", "/step", "/state", "/metadata", "/health", "/schema", "/mcp")}}
-
-
-def stub_running(monkeypatch, stage="RUNNING"):
-    rec = {"id": "org/env", "host": "https://org-env.hf.space", "stage": stage, "base_path": "/web"}
-    monkeypatch.setattr(live, "record", lambda spec, fresh=False: rec)
-    answers = {"/openapi.json": OPENAPI, "/metadata": {"name": "env", "description": "an env", "readme_content": "x" * 5000},
-               "/schema": SCHEMA, "/health": {"status": "healthy"}, "/list_environments": None}
-    monkeypatch.setattr(live, "_get_json", lambda rec, path: answers.get(path))
-    monkeypatch.setattr(live, "_ui_path", lambda rec: "/web/")
-    monkeypatch.setattr(live, "_tools", lambda rec: ([{"name": "echo", "inputSchema": {"type": "object"}}], None, {"ok": True, "detail": "JSON-RPC 2.0"}))
-    return rec
-
-
-def test_a_good_probe_is_kept_and_shown_while_the_space_sleeps(monkeypatch):
-    rec = stub_running(monkeypatch)
-    info = live.probe("org/env")
-    assert info["running"] and info["mode"] == "simulation" and info["openapi_version"] == "1.0.0"
-    assert [c["status"] for c in info["conformance"]] == ["pass"] * 6
-    p = Path(config.STORAGE_DIR) / "space-probes" / "org__env.json"
-    assert p.exists() and not [x for x in p.parent.iterdir() if x.name.endswith(".tmp")]          # written whole
-    kept = json.loads(p.read_text())
-    assert kept["mcp"][0]["name"] == "echo" and kept["schema"] == SCHEMA and kept["ui"] == "/web/"
-    assert kept["metadata"] == {"name": "env", "description": "an env"}                            # no README copy
-    rec["stage"] = "SLEEPING"
-    catalog._memo.clear()
-    asleep = live.probe("org/env")
-    assert not asleep["running"] and asleep["last_seen"]["mcp"][0]["name"] == "echo"
-    assert asleep["last_seen"]["checked_at"] <= time.time() and len(asleep["last_seen"]["conformance"]) == 6
-
-
-def test_a_probe_that_got_nothing_does_not_replace_the_last_good_one(monkeypatch):
-    stub_running(monkeypatch)
-    live.probe("org/env")
-    catalog._memo.clear()
-    monkeypatch.setattr(live, "_get_json", lambda rec, path: None)
-    monkeypatch.setattr(live, "_tools", lambda rec: (None, "the Space's /mcp answered HTTP 503", {"ok": False, "detail": "HTTP 503"}))
-    bad = live.probe("org/env")
-    assert bad["running"] and bad["conformance"][0]["status"] == "fail"
-    assert live.last_seen("org/env")["mcp"][0]["name"] == "echo"
-
-
-def test_the_last_seen_record_is_trimmed_to_fit():
-    huge = [{"name": f"t{i}", "inputSchema": {"description": "x" * 4000}, "outputSchema": {"d": "y" * 4000}} for i in range(120)]
-    kept = live._seen_record("org/env", {"mcp": huge, "schema": SCHEMA, "checked": 1.0})
-    assert len(json.dumps(kept)) <= live.SEEN_MAX and [t["name"] for t in kept["mcp"]] == [f"t{i}" for i in range(120)]
-
-
-def test_conformance_criteria():
-    allgood = {"openapi": OPENAPI, "health": {"status": "healthy"}, "metadata": {"name": "a", "description": "b"}, "schema": SCHEMA,
-               "mcp": {"ok": True, "detail": "JSON-RPC 2.0"}, "mcp_tried": True, "paths": list(OPENAPI["paths"])}
-    ids = [c["id"] for c in live.conformance(allgood)]
-    assert ids == ["openapi_version_available", "health_endpoint", "metadata_endpoint", "schema_endpoint", "mcp_endpoint", "mode_endpoint_consistency"]
-    assert all(c["status"] == "pass" for c in live.conformance(allgood))
-
-    def status(facts):
-        return {c["id"]: c["status"] for c in live.conformance({**allgood, **facts})}
-
-    assert status({"openapi": {"paths": {}}})["openapi_version_available"] == "fail"
-    assert status({"health": {"status": "ok"}})["health_endpoint"] == "fail"
-    assert status({"metadata": {"name": "a"}})["metadata_endpoint"] == "fail"
-    assert status({"schema": {"action": {}, "observation": {}}})["schema_endpoint"] == "fail"
-    assert status({"mcp": {"ok": False, "detail": "HTTP 404"}})["mcp_endpoint"] == "fail"
-    assert status({"mcp": None})["mcp_endpoint"] == "fail"                       # not among its routes
-    assert status({"mcp": None, "paths": None})["mcp_endpoint"] == "unknown"
-    assert status({"paths": ["/mcp", "/health"]})["mode_endpoint_consistency"] == "pass"           # production
-    assert status({"paths": ["/mcp", "/step"]})["mode_endpoint_consistency"] == "fail"             # production with /step
-    assert status({"paths": ["/reset", "/step"]})["mode_endpoint_consistency"] == "fail"           # simulation without /state
-    assert status({"paths": None})["mode_endpoint_consistency"] == "fail"
-    assert {c["status"] for c in live.conformance(None)} == {"unknown"}

tests/test_space_tasks.py

@@ -1,41 +0,0 @@
-import time
-
-import pytest
-
-from app import space_tasks as tasks, spaces_live as live
-
-
-def test_multiple_environments_count_once_and_keep_unknowns(monkeypatch):
-    docs = {"/list_environments": ["a", "a", "b", "../bad"],
-            "/a/splits": [{"name": "train", "num_tasks": 12}, {"name": "train", "num_tasks": 12}],
-            "/b/splits": [{"name": "test", "num_tasks": True}, {"name": "valid", "num_tasks": 0}]}
-    monkeypatch.setattr(live, "_get_json", lambda rec, path: docs[path])
-    d = tasks.discover({}, {"/{env_name}/splits"})
-    assert [e["env"] for e in d["environments"]] == ["a", "b"]
-    s = tasks.summary(d)
-    assert s["tasks"] == 12 and s["counted_splits"] == 2 and s["unknown_splits"] == 1
-    assert not s["complete"]
-
-
-@pytest.mark.parametrize("value", [True, -1, "100", 2.5, float("inf"), 10**30])
-def test_invalid_counts_never_inflate_totals(value):
-    assert tasks.count(value) is None
-
-
-def test_census_filters_visibility_expiry_and_inactive_spaces():
-    now = time.time()
-    s = {"tasks": 19, "counted_splits": 1, "checked_at": now, "complete": True}
-    records = {"a": {"stage": "RUNNING", "task_catalog": s},
-               "private": {"stage": "RUNNING", "task_catalog": s},
-               "asleep": {"stage": "SLEEPING", "task_catalog": s},
-               "stale": {"stage": "RUNNING", "task_catalog": {**s, "checked_at": now - tasks.FRESH}}}
-    assert tasks.census(records, ["a", "asleep", "stale"], now)["tasks"] == 19
-    assert tasks.census(records, ["a"], now - 1)["tasks"] == 0
-
-
-def test_task_environment_must_be_advertised(monkeypatch):
-    monkeypatch.setattr(live, "probe", lambda spec: {"running": True, "task_api": {"env": "a", "environments": [{"env": "a"}, {"env": "b"}]}})
-    monkeypatch.setattr(live, "record", lambda spec: {})
-    assert live._task_api("o/s", "b")[1] == "b"
-    with pytest.raises(live.SpaceError):
-        live._task_api("o/s", "../secrets")

tests/ui-audit.mjs

@@ -1,320 +0,0 @@
-// UI audit of the HF RL Explorer: every check clicks or types like a person would and asserts the result, then
-// every page is checked at four widths in both themes for errors, sideways scroll, broken images and unlabelled
-// buttons, with a screenshot of each.
-//   npm i -D playwright && npx playwright install chromium     (or PW_CHROME=/path/to/chrome-headless-shell)
-//   node tests/ui-audit.mjs http://localhost:8060 /tmp/rlx-shots
-// Uses live Hub data and live Spaces (FineEnvs/geoguesser-env, FineEnvs/latex-ocr-env, ...): it needs network.
-import { chromium } from "playwright";
-import { mkdirSync } from "node:fs";
-
-const BASE = process.argv[2] || "http://localhost:8060";
-const SHOTS = process.argv[3] || "/tmp/rlx-shots";
-mkdirSync(SHOTS, { recursive: true });
-const HARBOR = "harborframework/terminal-bench-2.1", HTASK = "tasks/feal-differential-cryptanalysis";
-const MIMO = "XiaomiMiMo/MiMo-V2.6-RL-oss", MIMO_GENERAL = "s3k_0052_accounting_audit_tax_en_t2_rl_008";
-const results = [];
-const ok = (name, cond, detail = "") => { results.push({ name, pass: !!cond, detail }); if (!cond) console.log("  FAIL", name, detail); };
-
-const browser = await chromium.launch(process.env.PW_CHROME ? { executablePath: process.env.PW_CHROME } : {});
-
-async function page(width, theme = "light", height = 900) {
-  const ctx = await browser.newContext({ viewport: { width, height }, deviceScaleFactor: 1, hasTouch: width < 768, isMobile: width < 768 });
-  await ctx.addInitScript((t) => { try { localStorage.setItem("theme", t); localStorage.removeItem("fe-banner-closed"); } catch {} }, theme);
-  const p = await ctx.newPage();
-  p.errors = [];
-  p.on("pageerror", (e) => p.errors.push("pageerror: " + e.message));
-  p.on("console", (m) => { if (m.type() === "error" && !/favicon|Failed to load resource|net::ERR|cdn-thumbnails|hf\.space/.test(m.text())) p.errors.push("console: " + m.text()); });
-  p.on("dialog", (d) => { p.errors.push("native dialog: " + d.message()); d.dismiss(); });
-  p.on("response", (r) => { const u = r.url(); if (u.startsWith(BASE) && (r.status() === 403 || r.status() >= 500)) p.errors.push(`${r.status()} ${r.request().method()} ${u.slice(BASE.length, BASE.length + 120)}`); });
-  return p;
-}
-// a live Space's interface fills in once its server answers the probe: wait for that, not for the section's skeleton
-const liveIn = async (p, ms = 60000) => { try { await p.waitForFunction(() => /live/.test(document.querySelector("#sec-interface")?.textContent || "") && document.querySelector(".pg-opts, #pg-route, #pg-reset"), null, { timeout: ms }); return true; } catch { return false; } };
-const here = (p) => p.evaluate(() => location.pathname + location.search + location.hash);   // pages are paths now; old #/ links redirect
-const go = async (p, to, wait = 1200) => { await p.goto(BASE + "/" + to.replace(/^\/+/, ""), { waitUntil: "domcontentloaded" }); await p.waitForTimeout(wait); };   // "#/old", "path" or "/path"
-const until = async (p, sel, ms = 20000) => { try { await p.waitForSelector(sel, { timeout: ms }); return true; } catch { return false; } };
-
-async function health(p, label) {
-  const r = await p.evaluate(() => {
-    const over = document.documentElement.scrollWidth > document.documentElement.clientWidth + 1;
-    const wide = over ? [...document.querySelectorAll("body *")].filter((e) => e.getBoundingClientRect().right > document.documentElement.clientWidth + 2
-      && getComputedStyle(e).position !== "fixed" && e.offsetParent).slice(0, 4).map((e) => `${e.tagName.toLowerCase()}.${[...e.classList].join(".")}`) : [];
-    const broken = [...document.images].filter((i) => i.complete && i.naturalWidth === 0 && i.src && !i.src.includes("cdn-thumbnails") && i.offsetParent).map((i) => i.src.slice(0, 80));
-    const unnamed = [...document.querySelectorAll("button, a[href]")].filter((b) => b.offsetParent && !(b.textContent.trim() || b.getAttribute("aria-label") || b.getAttribute("title"))).map((b) => b.outerHTML.slice(0, 90));
-    const cut = [];
-    for (const e of document.querySelectorAll("body *")) {
-      if (!e.offsetParent || ![...e.childNodes].some((n) => n.nodeType === 3 && n.textContent.trim())) continue;
-      if (getComputedStyle(e).textOverflow === "ellipsis") continue;
-      const r = e.getBoundingClientRect();
-      for (let a = e.parentElement; a && a !== document.body; a = a.parentElement) {
-        const ox = getComputedStyle(a).overflowX;
-        if (ox === "auto" || ox === "scroll") break;
-        if (ox !== "visible") {
-          if (getComputedStyle(a).textOverflow === "ellipsis") break;   // cut on purpose, with an ellipsis
-          const ar = a.getBoundingClientRect();
-          if (r.right > ar.right + 1 && !a.matches(".sp-facts")) cut.push(`${e.tagName.toLowerCase()}.${[...e.classList].join(".")} "${e.textContent.trim().slice(0, 30)}"`);
-          break;
-        }
-      }
-    }
-    // content spilling out of its panel, card or column over its neighbour (nothing clips it, so "cut" misses it)
-    const spill = [];
-    const inScroller = (e, box) => { for (let a = e.parentElement; a && a !== box; a = a.parentElement) { const s = getComputedStyle(a); if (s.overflowX !== "visible" || s.textOverflow === "ellipsis") return true; } return false; };
-    for (const box of document.querySelectorAll(".panel, .card, .pg-ctl, #pg-log, .tp-side, .sp-side")) {
-      if (!box.offsetParent) continue;
-      const br = box.getBoundingClientRect();
-      for (const e of box.querySelectorAll("*")) {
-        if (!e.offsetParent || getComputedStyle(e).position === "absolute") continue;
-        if (e.getBoundingClientRect().right > br.right + 2 && !inScroller(e, box)) { spill.push(`${e.tagName.toLowerCase()}.${[...e.classList].join(".")} out of ${box.tagName.toLowerCase()}.${[...box.classList].join(".") || box.id}`); break; }
-      }
-    }
-    return { over, wide, broken, unnamed, cut: [...new Set(cut)], spill: [...new Set(spill)] };
-  });
-  ok(`${label}: no sideways scroll`, !r.over, r.wide.join(" "));
-  ok(`${label}: no broken images`, !r.broken.length, r.broken.join(" "));
-  ok(`${label}: every button and link is named`, !r.unnamed.length, r.unnamed.slice(0, 3).join(" | "));
-  ok(`${label}: no text cut off by its card or panel`, !r.cut.length, r.cut.slice(0, 3).join(" | "));
-  ok(`${label}: nothing spills out of its panel or column`, !r.spill.length, r.spill.slice(0, 3).join(" | "));
-  ok(`${label}: no errors`, !p.errors.length, p.errors.slice(0, 4).join(" | "));
-  p.errors = [];
-}
-
-// ── desktop: interactions ────────────────────────────────────────────────────
-{
-  const p = await page(1440, "dark");
-  await go(p, "#/", 600);
-  ok("home: the app replaces the boot loader", await until(p, "#list .card"));
-  ok("home: no collection tiles", !(await p.$("#domains, .domains")));
-  ok("home: one search box (the header's hides on Explore)", await p.evaluate(() => getComputedStyle(document.querySelector(".top-search")).visibility === "hidden"));
-  ok("home: the FineEnvs banner is one link", await p.evaluate(() => { const a = document.querySelector("#fe-banner a.fe-banner-link"); return a && !document.querySelector("#fe-banner").hidden && a.href.includes("huggingface.co/FineEnvs"); }));
-  ok("home: heading says what it explores", /Explore RL environments on Hugging Face/.test(await p.textContent("h1")));
-  const kinds = await p.$$eval("[data-kind]", (bs) => bs.map((b) => b.textContent));
-  ok("home: Kind filter covers the frameworks", ["Harbor", "Spaces", "Verifiers", "NeMo Gym"].every((k) => kinds.some((x) => x.includes(k))), kinds.join(","));
-  ok("home: ORS isn't a Kind of its own (its one Space is with the other Spaces)", !kinds.some((x) => /ORS/.test(x)), kinds.join(","));
-  await p.click('[data-kind="openenv"]');
-  await p.waitForTimeout(1500);   // the server answers (/api/search), after a short debounce
-  const firstOE = await p.$$eval("#list .card", (cs) => cs.slice(0, 8).map((c) => c.getAttribute("href")));
-  ok("home: OpenEnv Spaces open on FineEnvs' curated servers", firstOE.length === 8 && firstOE.every((h) => h.startsWith("/s/FineEnvs/")), firstOE.join(" "));
-  await p.click('[data-kind="verifiers"]');
-  await p.waitForTimeout(1500);
-  ok("home: filtering to Verifiers shows only Verifiers datasets", await p.$$eval("#list .card .kind-tag", (ts) => ts.length > 0 && ts.every((t) => t.textContent.includes("Verifiers"))));
-  await p.click('[data-kind="all"]');
-  await p.waitForTimeout(1200);
-  await p.fill("#q", "terminal-bench");
-  // the server answers the search (/api/search): wait for its answer, not a fixed time (a Space is a round trip away)
-  const narrowed = await p.waitForFunction(() => { const cs = [...document.querySelectorAll("#list .card")]; return cs.length > 0 && cs.every((c) => /terminal/i.test(c.textContent)); }, null, { timeout: 15000 }).then(() => true, () => false);
-  ok("home: search narrows the list", narrowed);
-  await p.fill("#q", "");
-  const page1 = await p.textContent("#tr-page");
-  await p.click("#tr-next");
-  await p.waitForTimeout(200);
-  ok("home: trending pages forward", (await p.textContent("#tr-page")) !== page1);
-  ok("home: Space cards show the whole picture", await p.$$eval("#list .card.sp .sp-thumb", (is) => is.slice(0, 3).every((i) => Math.abs(i.getBoundingClientRect().width / i.getBoundingClientRect().height - 1200 / 630) < 0.05)));
-  await health(p, "home 1440 dark");
-
-  // a Harbor task's file viewer
-  await go(p, `#/t/${HARBOR}/${HTASK}`, 600);
-  ok("task: file viewer renders", await until(p, ".fv .fv-row.fv-file"));
-  await p.click('.fv-row.fv-file[data-path="tests/test.sh"]');
-  await p.waitForTimeout(500);
-  ok("task: a shell file is highlighted with line numbers", await p.$$eval(".fv-body .tk-k", (x) => x.length > 2) && await p.$(".fv-body .ln .n"));
-  ok("task: the open file is in the URL", (await here(p)).includes("f=tests%2Ftest.sh"));
-  await p.click(".fv-body .ln:nth-child(3) .n");
-  ok("task: a line can be linked", (await here(p)).includes("L=3"));
-  await p.click('[data-act="full"]');
-  ok("task: full view covers the page, above the header", await p.evaluate(() => {
-    const fv = document.querySelector(".fv.full"); if (!fv) return false;
-    const r = fv.getBoundingClientRect(); const hit = document.elementFromPoint(r.left + 40, r.top + 20);
-    return fv.contains(hit);
-  }));
-  await p.keyboard.press("Escape");
-  ok("task: Esc closes full view", !(await p.$(".fv.full")));
-  const solution = await p.$('.fv-row.fv-file.withheld');
-  if (solution) { await solution.click(); await p.waitForTimeout(200); ok("task: withheld files say so", /Not shown/.test(await p.textContent(".fv-body"))); }
-  await health(p, "task 1440 dark");
-
-  // a big Harbor dataset: walked, opens immediately
-  await go(p, "#/d/microsoft/ProgramDistill", 2500);
-  ok("big dataset: its tasks list without waiting for every file", await until(p, "#list .card, .ix-partial, .tk-card, [data-task]", 30000) || (await p.textContent("#body")).length > 200);
-  await health(p, "ProgramDistill 1440");
-
-  // rows: a generic dataset, paged, its facets filtering on the server
-  await go(p, "#/d/FineEnvs/SmolDataEnvs", 600);
-  ok("rows: list renders", await until(p, "#list .card", 30000));
-  ok("rows: says how it's read", /How it's read/.test(await p.textContent(".rw-how")) && /answer/i.test(await p.textContent(".rw-roles")));
-  const firstTitles = await p.$$eval("#list .card .t", (ts) => ts.slice(0, 6).map((t) => t.textContent));
-  ok("rows: titles differ from row to row", new Set(firstTitles).size === firstTitles.length, firstTitles.join(" / "));
-  const opt = await p.$("#facets .opt");
-  if (opt) {
-    await opt.click();
-    await p.waitForFunction(() => /matching/.test(document.querySelector("#count").textContent) || /available/.test(document.querySelector("#note").textContent), null, { timeout: 60000 }).catch(() => {});
-    ok("rows: a facet filters (or says it can't yet)", /matching/.test(await p.textContent("#count")) || /isn't available/.test(await p.textContent("#note")), await p.textContent("#count"));
-  }
-  await health(p, "rows SmolDataEnvs 1440");
-  await go(p, "#/r/FineEnvs/SmolDataEnvs?c=default&s=train&i=3", 600);
-  ok("row: an old row link opens its task page", await until(p, ".tp-sec", 30000) && (await here(p)).startsWith("/t/FineEnvs/SmolDataEnvs/train/3"));
-  ok("row: the answer is withheld", /Withheld/.test(await p.textContent(".tp-side")) && !(await p.textContent(".tp-body")).includes('"answer"'));
-  await p.click('.tp-nav a[title^="Next"]');
-  await p.waitForTimeout(2500);
-  ok("row: next task navigates", (await here(p)).includes("train/4"));
-  await p.keyboard.press("ArrowLeft");
-  await p.waitForTimeout(2500);
-  ok("row: ← goes back a task", (await here(p)).includes("train/3"));
-  await health(p, "row 1440");
-
-  // a packed Harbor task (TaskTrove)
-  await go(p, "#/t/open-thoughts/TaskTrove/train/100", 600);
-  ok("packed: unpacked into a file tree", await until(p, ".fv .fv-row.fv-file", 40000));
-  ok("packed: its solution is withheld", await p.$('.fv-row.fv-file.withheld[data-path="solution/solve.sh"]'));
-  ok("packed: runs on Harbor", /Harbor/.test((await (await p.$("#run-card"))?.textContent()) || ""));
-  await health(p, "TaskTrove task 1440");
-
-  // MiMo: the release, as the MiMo explorer shows it
-  await go(p, `#/d/${MIMO}`, 600);
-  ok("MiMo: every environment listed", await until(p, "#list .card", 40000) && /7,780/.test(await p.textContent("#count")));
-  ok("MiMo: a tile per domain, with its grader", (await p.$$("#tiles .dom")).length === 6 && /Graded by hidden unit tests/.test(await p.textContent("#tiles")));
-  await p.click('#tiles .dom[data-tile="Cyber"]');
-  await p.waitForTimeout(500);
-  ok("MiMo: a domain's tile scopes the facets and the map", /Sanitizer/i.test(await p.textContent("#facets")) && /Cyber, by crash type/.test(await p.textContent("#map-title")));
-  await p.fill("#q", "heap overflow png");
-  await p.waitForTimeout(600);
-  ok("MiMo: search ranks and highlights", /best match/.test(await p.textContent("#order-note")) && (await p.$("#list .card mark")));
-  await p.evaluate(() => { document.querySelector("#ov-rewards").open = true; });
-  ok("MiMo: the reward design unfolds", /General rubrics, across the dataset/.test(await p.textContent("#ov-rewards")));
-  await health(p, "MiMo env 1440");
-  await go(p, `#/t/${MIMO}/${MIMO_GENERAL}`, 600);
-  ok("MiMo task: its systems and workspace", await until(p, ".tbl-btn", 90000) && (await p.$(".files-grid .file")));
-  await p.click(".tbl-btn");
-  ok("MiMo task: a table opens with the rows the agent starts with", await until(p, "#modal:not([hidden]) table", 30000));
-  await p.click("#modal-close");
-  await p.click('.files-grid .file[data-kind="document"]');
-  ok("MiMo task: a Word file previews", await until(p, "#modal:not([hidden]) .pv-doc", 40000));
-  await p.click("#modal-close");
-  ok("MiMo task: the rubric's checks, answers withheld", /checks, weighted/.test(await p.textContent("#sec-grading")) && /pass_anchor/.test(await p.textContent(".tp-side")));
-  ok("MiMo task: both runners offered, the MiMo harness first here", /MiMo harness/.test(await p.textContent("#run-runner")));
-  ok("MiMo task: links its Harbor twin", await p.$('.tp-links a[href^="/t/FineEnvs/MiMo-V2.6-RL-harbor-general/"]'));
-  await health(p, "MiMo task 1440");
-  await go(p, `#/r/${MIMO}?c=code&s=train&i=6`, 600);
-  ok("MiMo: an old row link opens the task by its id", await until(p, ".tp-sec", 60000) && /^\/t\/XiaomiMiMo\/MiMo-V2\.6-RL-oss\/format-code-task-/.test(await here(p)));
-  const twin = await p.$eval('.tp-links a[href^="/t/FineEnvs/MiMo-V2.6-RL-harbor-code/"]', (a) => a.getAttribute("href")).catch(() => null);
-  ok("MiMo: links its Harbor twin", !!twin);
-  if (twin) {
-    await go(p, twin, 600);
-    ok("MiMo twin: links back to the release", await until(p, `.tp-links a[href^="/t/${MIMO}/"]`, 40000));
-  }
-  await go(p, "#/task/music-gK-0768", 600);
-  ok("MiMo explorer's addresses still open", await until(p, ".tp-sec", 40000) && (await here(p)) === `/t/${MIMO}/music-gK-0768`);
-  await go(p, "#/community?view=tasks", 600);
-  ok("community: legacy Tasks links open the rollout feed", await until(p, "#cm-filters select[data-f=runner]", 60000) && !(await p.$("#cm-view")));
-  await health(p, "community rollouts 1440");
-
-  // a live Space: playground, tasks, connect
-  await go(p, "#/s/FineEnvs/geoguesser-env", 600);
-  ok("space: what it offers fills in", await liveIn(p));
-  ok("space: status says running", /Running/.test(await p.textContent("#sp-status")));
-  await p.evaluate(() => { const o = document.querySelector(".pg-opts"); if (o) o.open = true; });
-  await p.selectOption("#pg-split", "eval");
-  await p.fill("#pg-index", "5");
-  await p.click("#pg-reset");
-  ok("space: a reset starts an episode with an image", await until(p, "#pg-log .rv-img", 40000));
-  await p.selectOption("#pg-tool", "look");
-  await p.getByRole("spinbutton", { name: "heading_deg", exact: true }).fill("90");
-  await p.click("#pg-call");
-  await p.waitForTimeout(5000);
-  ok("space: a tool call answers in the episode", /Facing 90/.test(await p.textContent("#pg-log")));
-  ok("space: tasks list from its Task API", await until(p, "#tk-table [data-task]", 30000));
-  await p.click("#tk-table [data-task='1']");
-  ok("space: a task opens in full", await until(p, "#tk-detail:not([hidden]) .tk-detail-b"));
-  await p.click('[data-agent="cursor"]');
-  ok("space: connect shows each agent's config", /mcpServers/.test(await p.textContent("#sp-agent")) && (await p.textContent("#sp-agent")).includes("/mcp/FineEnvs/geoguesser-env"));
-  await health(p, "space geoguesser 1440");
-
-  await go(p, "s/FineEnvs/nayana-ocr-env", 600);   // ids and paths hundreds of characters long, no spaces
-  if (await liveIn(p)) {
-    await p.click("#pg-reset");
-    ok("space (long ids): an episode starts", await until(p, "#pg-log .pg-entry", 40000));
-    await p.waitForTimeout(800);
-    await health(p, "space nayana episode 1440");
-  }
-  await go(p, "#/s/FineEnvs/latex-ocr-env", 600);
-  ok("space (reset/step): fills in", await liveIn(p));
-  await p.click("#pg-reset");
-  ok("space (reset/step): reset shows the image", await until(p, "#pg-log .rv-img", 40000));
-  await p.getByRole("textbox", { name: /^latex$/i }).fill("x^2");
-  await p.click("#pg-step");
-  ok("space (reset/step): a step earns a reward", await until(p, "#pg-log .pg-entry:last-of-type .rv-reward", 40000));
-  await health(p, "space latex 1440");
-
-  // a NeMo Gym server: its own routes, with the session's cookie carrying the game
-  await go(p, "#/s/FineEnvs/wordle-nemo-gym", 600);
-  if (await until(p, "#pg-route", 40000)) {
-    ok("nemo gym: labelled as such", /NeMo Gym/.test(await p.textContent("main")));
-    await p.selectOption("#pg-route", { label: "POST /seed_session" });
-    await p.click("#pg-send");
-    await p.waitForTimeout(2500);
-    await p.selectOption("#pg-route", { label: "POST /guess" });
-    ok("nemo gym: a short string is a one-line input", await p.$('input[data-k="word"]'));
-    await p.getByRole("textbox", { name: "Word", exact: true }).fill("crane");
-    await p.click("#pg-send");
-    await p.waitForTimeout(2500);
-    await p.selectOption("#pg-route", { label: "POST /get_history" });
-    await p.click("#pg-send");
-    await p.waitForTimeout(2500);
-    ok("nemo gym: the session keeps the game between calls", /Guess 1: crane/.test(await p.textContent("#pg-log")));
-  } else ok("nemo gym: routes playground renders", false, "no #pg-route (asleep?)");
-  await health(p, "nemo gym space 1440");
-
-  await go(p, "#/s/AdithyaSK/openenv-harbor-ui-test", 600);
-  if (await until(p, "#sec-interface .panel-b", 40000) && (await p.$("#sec-harbor"))) {
-    ok("harbor space: maps its dataset back to the explorer", await p.$('#sec-harbor a[href="/d/FineEnvs/MiMo-V2.6-RL-harbor-terminal"]'));
-  }
-  await health(p, "harbor space 1440");
-  await p.context().close();
-}
-
-// ── the frameworks' rows, and a model-graded task ────────────────────────────
-{
-  const p = await page(1440, "dark");
-  await go(p, "t/nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1/train/0", 600);
-  ok("NeMo Gym: the row reads as a conversation, not a table", await until(p, ".tp-sec", 40000)
-    && await p.evaluate(() => { const t = document.querySelector(".tp-sec"); const turns = t ? [...t.querySelectorAll(".rl-turn")] : [];
-      return turns.length > 1 && turns.every((x) => !x.closest("table")) && turns.some((x) => /user/i.test(x.querySelector(".rl-who")?.textContent || "")); }));
-  // (a tool's output may be shown as a table: data, inside its turn; the turns themselves never are)
-  ok("NeMo Gym: its title is the request, not a row number", !/^(Row )?\d+$/.test((await p.textContent("h1")).trim()));
-  ok("NeMo Gym: the expert's next action is withheld", /expected_action/.test(await p.textContent(".tp-side")) && !(await p.textContent(".tp-body")).includes('"expected_action"'));
-  ok("NeMo Gym: says how to run it with NeMo Gym", /Run it with NeMo Gym/.test(await p.textContent("main")));
-  await health(p, "NeMo Gym row 1440");
-  await go(p, "t/sungyub/deepscaler-preview-verl/train/0", 600);
-  ok("verl: the ground truth is withheld", await until(p, ".tp-sec", 40000) && /ground_truth/.test(await p.textContent(".tp-side")));
-  ok("verl: its math is typeset (KaTeX), not left as TeX", await until(p, "h1 .math .katex", 20000) && !(await p.textContent("h1")).includes("\\frac"));
-  await health(p, "verl row 1440");
-  await go(p, "t/FineEnvs/MiMo-V2.6-RL-harbor-general/tasks/s3k_0052_accounting_audit_tax_en_t2_rl_008", 600);
-  // signed in, the run panel offers the judge; signed out (a Space without a session), the page still says how it's graded
-  ok("judge: a model-graded task offers a judge, through the relay", await until(p, "#run-card", 30000) && (
-    (/Judge model/.test(await p.textContent("#run-card")) && /relay/.test(await p.textContent("#run-card")))
-    || (/Sign in/i.test(await p.textContent("#run-card")) && /Graded by a model/.test(await p.textContent("main")))));
-  await health(p, "model-graded task 1440");
-  await p.context().close();
-}
-
-// ── every page, every width, both themes ─────────────────────────────────────
-const PAGES = [["home", "#/"], ["dataset", `#/d/${HARBOR}`], ["task", `#/t/${HARBOR}/${HTASK}`], ["rows", "#/d/FineEnvs/SmolDataEnvs"],
-  ["row", "#/t/FineEnvs/SmolDataEnvs/train/2"], ["packed", "#/t/open-thoughts/TaskTrove/train/100"],
-  ["space", "#/s/FineEnvs/geoguesser-env"], ["traces", "#/t/open-thoughts/AgentTrove/train/0"], ["mimo", `#/d/${MIMO}`],
-  ["mimo-task", `#/t/${MIMO}/${MIMO_GENERAL}`], ["mimo-code", `#/t/${MIMO}/format-code-task-000720`], ["community", "#/community"]];
-for (const [w, theme] of [[375, "light"], [768, "dark"], [1280, "light"], [1680, "dark"]]) {
-  const p = await page(w, theme);
-  for (const [name, hash] of PAGES) {
-    await go(p, hash, 3500);
-    await p.waitForTimeout(name === "space" ? 6000 : 1500);
-    await p.screenshot({ path: `${SHOTS}/${name}-${w}-${theme}.png`, fullPage: false });
-    await health(p, `${name} ${w} ${theme}`);
-  }
-  await p.context().close();
-}
-
-await browser.close();
-const failed = results.filter((r) => !r.pass);
-console.log(`\n${results.length - failed.length}/${results.length} checks passed`);
-for (const f of failed) console.log(`FAIL  ${f.name}${f.detail ? `  (${f.detail})` : ""}`);
-process.exit(failed.length ? 1 : 0);

web-admin/admin.css

@@ -1,175 +0,0 @@
-/* The admin dashboard, on top of the explorer's app.css and rlx.css. */
-/* admin */
-.ad-tabs { flex-wrap: wrap; }
-.ad-stats { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap: 8px; }
-.ad-stat { background: var(--surface); border: 1px solid var(--border); border-radius: var(--r); padding: 12px 14px; display: grid; gap: 1px; min-width: 0; }
-.ad-stat b { font-size: 20px; font-weight: 650; letter-spacing: -.02em; font-variant-numeric: tabular-nums; }
-.ad-stat span { font-size: 12.5px; color: var(--muted); }
-.ad-stat em { font-style: normal; font-size: 12px; color: var(--faint); }
-.ad-grid { display: grid; grid-template-columns: minmax(0, 1.2fr) minmax(0, 1fr); gap: 16px; margin-top: 16px; }
-.ad-bars { display: grid; grid-template-columns: repeat(14, minmax(0, 1fr)); gap: 4px; height: 120px; align-items: end; }
-.ad-bars div { display: grid; grid-template-rows: 1fr auto; height: 100%; align-items: end; gap: 3px; }
-.ad-bars i { display: block; border-radius: 4px 4px 0 0; background: var(--focus); opacity: .8; min-height: 2px; }
-.ad-bars span { font-size: 10.5px; color: var(--faint); text-align: center; font-variant-numeric: tabular-nums; }
-.ad-new { list-style: none; margin: 0; padding: 0; display: grid; gap: 6px; }
-.ad-new li { display: flex; justify-content: space-between; gap: 10px; font-size: 13px; }
-.ad-new a { display: inline-flex; align-items: center; gap: 6px; min-width: 0; overflow: hidden; }
-.ad-new code { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.ad-runs { display: grid; gap: 0; }
-.ad-run { display: grid; grid-template-columns: 130px minmax(0, 1fr) 140px 200px 60px 90px auto; gap: 12px; align-items: center; padding: 9px 0; border-top: 1px solid var(--border); font-size: 13px; }
-.ad-run:first-child, .ad-runs > p + .ad-run { border-top: 0; }
-.ad-task { display: grid; min-width: 0; } .ad-task b { font-weight: 500; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.ad-task em, .ad-when em { font-style: normal; font-size: 12px; color: var(--faint); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; display: block; }
-.ad-user, .ad-model { color: var(--muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; display: inline-flex; align-items: center; gap: 5px; }
-.ad-when { font-size: 12.5px; color: var(--faint); text-align: right; }
-.ad-act { display: flex; gap: 6px; justify-content: flex-end; flex-wrap: wrap; }
-.ad-envs { display: grid; }
-.ad-env { display: grid; grid-template-columns: minmax(0, 1fr) 170px 80px 90px 70px 70px 150px; gap: 10px; align-items: center; padding: 8px 14px; border-top: 1px solid var(--border); font-size: 13px; }
-.ad-env.head { border-top: 0; background: var(--surface-2); font-size: 11.5px; font-weight: 600; color: var(--faint); text-transform: uppercase; letter-spacing: .04em; }
-.ad-env.gone { opacity: .55; }
-.ad-env .num { text-align: right; font-variant-numeric: tabular-nums; }
-.ad-name { display: flex; align-items: center; gap: 6px; min-width: 0; flex-wrap: wrap; }
-.ad-name a { display: inline-flex; align-items: center; gap: 6px; min-width: 0; max-width: 100%; }
-.ad-name code { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.hf-select-mimo.sm { height: 28px; font-size: 12.5px; width: 100%; }
-.ad-cols { display: grid; grid-template-columns: repeat(auto-fill, minmax(min(100%, 460px), 1fr)); gap: 12px; }
-.ad-form { display: grid; grid-template-columns: 1fr 1fr; gap: 12px 14px; }
-.ad-form .wide { grid-column: 1 / -1; }
-.ad-form textarea { height: auto; padding: 8px 10px; resize: vertical; font-size: 12.5px; line-height: 1.5; }
-.ad-checks { display: flex; flex-wrap: wrap; gap: 8px 18px; font-size: 13.5px; }
-.ad-checks label, .ad-switch { display: inline-flex; align-items: center; gap: 8px; cursor: pointer; }
-.ad-switch span { display: grid; } .ad-switch em { font-style: normal; font-size: 12.5px; color: var(--faint); }
-.ad-audit { list-style: none; margin: 0; padding: 0; display: grid; gap: 8px; font-size: 13px; }
-.ad-audit li { display: grid; grid-template-columns: 110px 140px minmax(0, 1fr); gap: 10px; }
-.ic.up { transform: rotate(180deg); }
-@media (max-width: 1100px) { .ad-stats { grid-template-columns: repeat(3, minmax(0, 1fr)); } .ad-grid { grid-template-columns: minmax(0, 1fr); }
-  .ad-run { grid-template-columns: 120px minmax(0, 1fr) 60px auto; } .ad-run .ad-user, .ad-run .ad-model, .ad-run .ad-when { display: none; }
-  .ad-env { grid-template-columns: minmax(0, 1fr) 140px 120px; } .ad-env > .num { display: none; } }
-@media (max-width: 760px) { .ad-stats { grid-template-columns: repeat(2, minmax(0, 1fr)); } .ad-form { grid-template-columns: minmax(0, 1fr); }
-  .ad-env { grid-template-columns: minmax(0, 1fr); } .ad-env.head { display: none; } .ad-act { justify-content: flex-start; }
-  .ad-run { grid-template-columns: minmax(0, 1fr) auto; } .ad-run > span:first-child { grid-column: 1 / -1; } .ad-audit li { grid-template-columns: minmax(0, 1fr); gap: 0; } }
-
-/* layout: a section list on the left, the section on the right */
-.ad-shell { display: grid; grid-template-columns: 210px minmax(0, 1fr); gap: 28px; padding-top: 22px; padding-bottom: 64px; align-items: start; }
-.ad-nav { position: sticky; top: calc(var(--header-h) + 18px); display: grid; gap: 2px; }
-.ad-nav a { display: flex; align-items: center; gap: 10px; padding: 8px 10px; border-radius: 8px; color: var(--muted); font-weight: 500; font-size: 13.5px; }
-.ad-nav a:hover { background: var(--surface-2); color: var(--text); }
-.ad-nav a.on { background: var(--surface-2); color: var(--text); box-shadow: inset 2px 0 0 var(--text); }
-.ad-nav a .ic { color: var(--faint); }
-.ad-nav a.on .ic { color: var(--text); }
-.ad-nav em { margin-left: auto; font-style: normal; font-size: 11.5px; font-weight: 600; color: var(--muted); background: var(--surface-3); border-radius: 99px; padding: 1px 7px; }
-.ad-nav em.live { color: var(--live); background: color-mix(in srgb, var(--live) 14%, transparent); }
-.ad-main { min-width: 0; }
-.ad-head { display: flex; align-items: flex-end; justify-content: space-between; gap: 12px 20px; flex-wrap: wrap; margin-bottom: 16px; }
-.ad-head h1 { font-size: 22px; letter-spacing: -.02em; }
-.ad-head p { color: var(--muted); font-size: 13.5px; margin-top: 4px; max-width: 720px; }
-.ad-actions { display: flex; gap: 8px; flex-wrap: wrap; }
-.ad-tools { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; margin-bottom: 12px; }
-.ad-tools .search { flex: 1 1 260px; }
-.ad-tools .seg { flex-wrap: wrap; }
-
-/* overview */
-.ad-hello { display: flex; align-items: center; gap: 14px; margin-bottom: 18px; flex-wrap: wrap; }
-.ad-hello h1 { font-size: 22px; letter-spacing: -.02em; }
-.ad-hello p { color: var(--muted); font-size: 13.5px; display: flex; align-items: center; gap: 6px; flex-wrap: wrap; }
-.ad-hello .ad-actions { margin-left: auto; }
-.ad-stat { display: flex; gap: 12px; align-items: flex-start; }
-.ad-stat .ic-wrap { width: 32px; height: 32px; border-radius: 9px; display: grid; place-items: center; background: var(--surface-2); color: var(--muted); flex: none; }
-.ad-stat > div { display: grid; gap: 1px; min-width: 0; }
-.ad-stat.live .ic-wrap { color: var(--live); background: color-mix(in srgb, var(--live) 12%, transparent); }
-.ad-stat.warn .ic-wrap { color: var(--warn); background: color-mix(in srgb, var(--warn) 12%, transparent); }
-.ad-live { margin-top: 16px; border-color: color-mix(in srgb, var(--live) 35%, var(--border)); }
-.ad-models { list-style: none; margin: 0; padding: 0; display: grid; gap: 7px; font-size: 13px; }
-.ad-models li { display: grid; grid-template-columns: minmax(0, 1fr) 90px 30px; gap: 10px; align-items: center; }
-.ad-models code { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-.ad-models b { text-align: right; font-variant-numeric: tabular-nums; }
-.ad-new li { display: grid; grid-template-columns: 40px minmax(0, 1fr); gap: 10px; align-items: center; }
-.ad-new a { display: grid; min-width: 0; }
-.ad-new a em { font-style: normal; font-size: 12px; color: var(--faint); }
-.ad-th { width: 40px; height: 30px; border-radius: 6px; object-fit: cover; border: 1px solid var(--border); background: var(--surface-2); flex: none; }
-.ad-th.ic-only { display: grid; place-items: center; color: var(--faint); }
-.ad-env .ad-th { width: 34px; height: 26px; }
-
-/* people */
-.pfp { border-radius: 50%; flex: none; background: var(--surface-3); object-fit: cover; }
-.pfp.none { display: inline-grid; place-items: center; font-size: 11px; font-weight: 700; color: var(--muted); }
-.person { display: inline-flex; align-items: center; gap: 7px; min-width: 0; font-size: 13px; }
-.person a, .person .link, .person b { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--text); font-weight: 500; }
-.person .link:hover, .person a:hover { text-decoration: underline; }
-.ad-people { display: grid; grid-template-columns: repeat(auto-fill, minmax(min(100%, 300px), 1fr)); gap: 12px; }
-.ad-person { padding: 16px; display: grid; gap: 14px; align-content: start; }
-.ad-person header { display: flex; gap: 12px; align-items: center; }
-.ad-person header > div { display: grid; min-width: 0; }
-.ad-person header a { display: inline-flex; align-items: center; gap: 4px; color: var(--text); }
-.ad-person header em { font-style: normal; font-size: 12.5px; color: var(--faint); }
-.live-txt { color: var(--live); }
-.ad-pstats { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 6px; }
-.ad-pstats div { background: var(--surface-2); border-radius: 8px; padding: 7px 8px; display: grid; }
-.ad-pstats b { font-size: 15px; font-variant-numeric: tabular-nums; }
-.ad-pstats span { font-size: 11.5px; color: var(--faint); }
-.ad-person .btn { justify-self: start; }
-.ad-run.is-live { background: color-mix(in srgb, var(--live) 5%, transparent); }
-.ad-model { display: grid; min-width: 0; }
-.ad-model em { font-style: normal; font-size: 12px; color: var(--faint); }
-.chip.new { color: var(--ok); background: color-mix(in srgb, var(--ok) 12%, transparent); }
-
-/* collections, settings */
-.ad-swatch { width: 24px; height: 24px; border-radius: 7px; display: inline-grid; place-items: center; color: #fff; background: var(--dc); }
-.ad-swatch .ic { color: #fff !important; }
-.ad-settings { display: grid; gap: 0; padding: 4px 20px; max-width: 820px; }
-.ad-set { display: flex; align-items: center; justify-content: space-between; gap: 16px; padding: 16px 0; border-bottom: 1px solid var(--border); flex-wrap: wrap; }
-.ad-set.col { display: grid; gap: 10px; justify-content: stretch; }
-.ad-set b { display: block; font-size: 14px; }
-.ad-set span { font-size: 12.5px; color: var(--faint); }
-.ad-nums { display: flex; align-items: center; gap: 8px; }
-.ad-nums .input { width: 80px; }
-.ad-save-row { display: flex; align-items: center; justify-content: flex-end; gap: 12px; padding: 16px 0; }
-.ad-preview { border-radius: 8px; }
-.toggle { position: relative; display: inline-block; width: 42px; height: 24px; flex: none; cursor: pointer; }
-.toggle input { position: absolute; opacity: 0; width: 100%; height: 100%; margin: 0; cursor: pointer; }
-.toggle i { position: absolute; inset: 0; border-radius: 99px; background: var(--surface-3); transition: background .15s; }
-.toggle i::after { content: ""; position: absolute; top: 3px; left: 3px; width: 18px; height: 18px; border-radius: 50%; background: #fff; box-shadow: var(--shadow-sm); transition: transform .15s; }
-.toggle input:checked + i { background: var(--ok); }
-.toggle input:checked + i::after { transform: translateX(18px); }
-.toggle input:focus-visible + i { box-shadow: 0 0 0 3px color-mix(in srgb, var(--focus) 30%, transparent); }
-.ad-audit li { grid-template-columns: 170px minmax(0, 1fr) 90px; align-items: center; }
-@media (max-width: 1000px) {
-  .ad-shell { grid-template-columns: minmax(0, 1fr); gap: 14px; }
-  .ad-nav { position: static; display: flex; overflow-x: auto; gap: 4px; scrollbar-width: none; margin: 0 calc(-1 * var(--gutter)); padding: 0 var(--gutter); }
-  .ad-nav a { flex: none; } .ad-nav a.on { box-shadow: inset 0 -2px 0 var(--text); border-radius: 8px 8px 0 0; }
-}
-@media (max-width: 760px) { .ad-hello .ad-actions { margin-left: 0; } .ad-pstats { grid-template-columns: repeat(2, minmax(0, 1fr)); } .ad-audit li { grid-template-columns: minmax(0, 1fr); } }
-
-/* Evidence and maintenance are separate from dataset indexes and saved runs. */
-.ad-operations { margin: 16px 0; }
-.ad-ops-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 18px 24px; }
-.ad-ops-grid > div { min-width: 0; }
-.ad-ops-grid p { margin: 6px 0 10px; overflow-wrap: anywhere; }
-.ad-ops-grid dd, .ad-ops-grid dt { min-width: 0; overflow-wrap: anywhere; }
-.ad-check-states, .ad-runner-summary { display: flex; flex-wrap: wrap; gap: 6px; }
-.ad-check-states, .ad-ops-note { grid-column: 1 / -1; }
-.ad-check-states .chip { max-width: 100%; white-space: normal; overflow-wrap: anywhere; }
-.ad-ops-note summary { cursor: pointer; margin-bottom: 10px; }
-.ad-tools .input, .ad-tools select { min-width: 0; max-width: 100%; width: auto; }
-.ad-tools .search { min-width: 0; }
-.ad-name > .chip { max-width: 100%; overflow: hidden; text-overflow: ellipsis; }
-.ad-stat b { overflow-wrap: anywhere; }
-.ad-task, .ad-model, .ad-when, .ad-act { min-width: 0; }
-.ad-main .panel { min-width: 0; }
-.ad-main .tbl { overflow-x: auto; max-width: 100%; }
-.ad-main #ad-run-error { margin-bottom: 10px; color: var(--muted); font-size: 13px; }
-@media (max-width: 760px) {
-  .ad-ops-grid { grid-template-columns: minmax(0, 1fr); }
-  .ad-hello h1 { overflow-wrap: anywhere; }
-  .ad-stat { padding: 10px; gap: 8px; }
-  .ad-stat .ic-wrap { display: none; }
-  .ad-tools .search { flex-basis: 100%; }
-  .ad-tools > select { flex: 1 1 130px; }
-  .ad-head .ad-actions { width: 100%; }
-  .ad-run { gap: 8px; }
-  .ad-run .ad-act { grid-column: 1 / -1; }
-}
-
-@media (min-width: 1101px) and (max-width: 1450px) { .ad-stats { grid-template-columns: repeat(3, minmax(0, 1fr)); } }
-
-.ad-name > .faint { min-width: 0; max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }

web-admin/admin.js

@@ -1,406 +0,0 @@
-// The admin dashboard, on its own private Space, for FineEnvs members: what's happening (rollouts, people, new
-// environments), and the controls (what trends at the top, what's hidden, the collections, indexing, the rollout
-// switches). The server checks membership on every call. Links to rollouts, datasets and Spaces open the explorer.
-import { $, api, esc, fmt, ago, dur, sk, emptyState, toast, statusPill, rewardBadge, spinner } from "/js/util.js";
-import { icon } from "/js/icons.js";
-import { getSession } from "/js/session.js";
-
-const TABS = [["overview", "Overview", "grid"], ["rollouts", "Rollouts", "play"], ["people", "People", "users"], ["environments", "Environments", "database"],
-              ["collections", "Collections", "layout"], ["indexes", "Indexing & API checks", "archive"], ["settings", "Settings", "gauge"], ["audit", "Audit log", "list"]];
-const enc = (s) => s.split("/").map(encodeURIComponent).join("/");
-const compact = new Intl.NumberFormat("en-US", { notation: "compact", maximumFractionDigits: 1 });
-const bytes = (n) => (n == null ? "–" : n > 1e6 ? `${(n / 1e6).toFixed(1)} MB` : `${Math.round(n / 1e3)} KB`);
-let EXPLORER = "";   // the public explorer: datasets, Spaces and rollouts open there
-const envHref = (e) => `${EXPLORER}/${e.kind === "space" ? "s" : "d"}/${enc(e.id)}`;
-const runHref = (id) => `${EXPLORER}/run/${encodeURIComponent(id)}`;
-const thumb = (id) => `https://cdn-thumbnails.huggingface.co/social-thumbnails/spaces/${enc(id)}.png`;
-let alive = true, timer = null, counts = {}, events = null;
-const runnerName = v => ({harbor:"Harbor", mimo:"MiMo", "nemo-gym":"NeMo Gym", openenv:"OpenEnv", verifiers:"Verifiers", verl:"verl", skyrl:"SkyRL"}[v] || v || "Unknown");
-export function unmount() { alive = false; clearTimeout(timer); events?.abort(); }
-
-// a person: their Hub picture (or their initial), their name, a link to their profile
-const pfp = (name, src, size = 22) => (src ? `<img class="pfp" src="${esc(src)}" alt="" width="${size}" height="${size}" loading="lazy">`
-  : `<span class="pfp none" style="width:${size}px;height:${size}px">${esc((name || "?").slice(0, 1).toUpperCase())}</span>`);
-const person = (name, src, { link = true, filter = false } = {}) => `<span class="person">${pfp(name, src)}${filter
-  ? `<button class="link" data-user="${esc(name)}" title="Only ${esc(name)}'s rollouts">${esc(name)}</button>`
-  : link ? `<a href="https://huggingface.co/${encodeURIComponent(name)}" target="_blank" rel="noopener">${esc(name)}</a>` : `<b>${esc(name)}</b>`}</span>`;
-
-export async function mount(el, { qs, explorer }) {
-  alive = true;
-  events?.abort(); events = new AbortController();
-  EXPLORER = explorer || "";
-  const s = getSession();
-  if (!s.user || !s.is_admin) {
-    el.innerHTML = `<div class="wrap page">${emptyState("shield", "Admins only", s.user ? `The admin dashboard is for members of the ${esc(s.admin_org)} organization on Hugging Face.`
-      : `Sign in with a ${esc(s.admin_org || "FineEnvs")} account.`, s.user ? "" : `<a class="btn primary" href="/login">${icon("user", 15)}Sign in with Hugging Face</a>`)}</div>`;
-    return;
-  }
-  let tab = TABS.some(([k]) => k === qs.get("tab")) ? qs.get("tab") : "overview";
-  const preset = { user: qs.get("user") || "" };
-  el.innerHTML = `<div class="wrap ad-shell fade-in">
-    <nav class="ad-nav" id="ad-nav" aria-label="Admin sections"></nav>
-    <section class="ad-main"><div id="ad-body"></div></section></div>`;
-  const nav = () => {
-    $("#ad-nav", el).innerHTML = TABS.map(([k, l, ic]) => `<a href="#/${k === "overview" ? "" : `?tab=${k}`}" data-tab="${k}" class="${k === tab ? "on" : ""}">
-      ${icon(ic, 15)}<span>${l}</span>${counts[k] ? `<em class="${k === "rollouts" ? "live" : ""}">${counts[k]}</em>` : ""}</a>`).join("");
-  };
-  const show = () => {
-    clearTimeout(timer);
-    nav();
-    history.replaceState(null, "", `#/${tab === "overview" ? "" : `?tab=${tab}${tab === "rollouts" && preset.user ? `&user=${encodeURIComponent(preset.user)}` : ""}`}`);
-    $("#ad-body", el).replaceWith(Object.assign(document.createElement("div"), {id:"ad-body"}));
-    const body = $("#ad-body", el);
-    body.innerHTML = `<div class="panel"><div class="panel-b">${sk.lines(80, 60, 90, 70)}</div></div>`;
-    ({ overview, rollouts, people, environments, collections, indexes, settings, audit })[tab](body, { go, preset, s }).catch((e) => {
-      if (alive && body.isConnected) body.innerHTML = `<div class="note-box err">${icon("alert")}<span>${esc(e.message)}</span></div>`;
-    });
-    window.scrollTo(0, 0);
-  };
-  const go = (t, opts = {}) => { tab = t; Object.assign(preset, opts); show(); };
-  el.addEventListener("click", (e) => {
-    const t = e.target.closest("[data-tab]");
-    if (t) { e.preventDefault(); preset.user = ""; go(t.dataset.tab); }
-    const u = e.target.closest("[data-user]");
-    if (u) { e.preventDefault(); go("rollouts", { user: u.dataset.user }); }
-  }, {signal:events.signal});
-  show();
-  // live counts beside the sections: running rollouts, new environments
-  api("/api/admin/overview").then((o) => { counts = { rollouts: o.rollouts.live || "", environments: o.new_count || "" }; if (alive) nav(); }).catch(() => {});
-}
-
-const head = (title, sub, actions = "") => `<div class="ad-head"><div><h1>${title}</h1>${sub ? `<p>${sub}</p>` : ""}</div><div class="ad-actions">${actions}</div></div>`;
-const stat = (ic, n, label, sub = "", tone = "") => `<div class="ad-stat ${tone}"><span class="ic-wrap">${icon(ic, 16)}</span><div><b>${n}</b><span>${label}</span>${sub ? `<em>${sub}</em>` : ""}</div></div>`;
-const runRow = (r, actions = false) => `<div class="ad-run${r.live ? " is-live" : ""}">
-  <span>${statusPill(r.status)}</span>
-  <a class="ad-task" href="${runHref(r.id)}" target="_blank" rel="noopener"><b title="${esc(r.title || r.path)}">${esc(r.title || r.path)}</b><em title="${esc(r.dataset)}">${esc(r.dataset)} · ${esc(runnerName(r.runner))}</em><em>${r.community ? "On Community" : r.moderated ? "Moderated" : r.visibility === "public" ? "Public · not eligible for Community" : "Private"}</em></a>
-  ${person(r.user, r.avatar, { filter: true })}
-  <span class="ad-model" title="${esc(r.model)}">${esc((r.model || "").split("/")[1] || r.model || "endpoint")}<em>${esc(r.harness || runnerName(r.runner))}</em></span>
-  <span>${rewardBadge(r.reward, r.status)}</span>
-  <span class="ad-when">${ago(r.created_at)}<em>${dur(r.wall_s || ((r.finished_at || Date.now() / 1000) - (r.started_at || r.created_at)))}</em></span>
-  ${actions ? `<span class="ad-act">${r.live ? `<button class="btn sm danger" data-cancel="${esc(r.id)}">${icon("stop", 12)}Stop</button>` : ""}
-    ${r.moderated ? `<button class="btn sm" data-unhide="${esc(r.id)}">Remove moderation</button>` : r.community ? `<button class="btn sm ghost" data-hide="${esc(r.id)}">Hide from Community</button>` : ""}</span>` : ""}</div>`;
-
-async function runActions(body, reload) {
-  body.runEvents?.abort(); body.runEvents = new AbortController();
-  body.addEventListener("click", async (e) => {
-    const c = e.target.closest("[data-cancel]"), h = e.target.closest("[data-hide]"), u = e.target.closest("[data-unhide]");
-    try {
-      if (c) { if (!confirm("Stop this rollout? The sandbox shuts down and it isn't graded.")) return;
-        await api(`/api/admin/rollouts/${c.dataset.cancel}/cancel`, { method: "POST" }); toast("Asked the explorer to stop it: a few seconds"); }
-      else if (h) { if (!confirm("Take this rollout off Community? Its owner still sees it.")) return;
-        await api(`/api/admin/rollouts/${h.dataset.hide}/moderate`, { method: "POST", body: { hidden: true } }); toast("Hidden from Community"); }
-      else if (u) { await api(`/api/admin/rollouts/${u.dataset.unhide}/moderate`, { method: "POST", body: { hidden: false } }); toast("Moderation removed; Community eligibility still applies"); }
-      else return;
-      reload();
-    } catch (err) { toast(err.message); }
-  }, {signal:body.runEvents.signal});
-}
-
-// ── overview ─────────────────────────────────────────────────────────────────
-async function overview(body, { go, s }) {
-  const o = await api("/api/admin/overview");
-  if (!alive || !body.isConnected) return;
-  const r = o.rollouts, e = o.environments, on = o.settings.rollouts_enabled;
-  const peak = Math.max(1, ...r.by_day.map(([, n]) => n));
-  const live = o.live;
-  const last = o.recent[0];
-  body.innerHTML = `
-    <div class="ad-hello">${pfp(s.user.name, s.user.avatar, 44)}<div><h1>Hi, ${esc(s.user.name)}</h1>
-      <p><span class="dot" style="--dc:${on ? "var(--ok)" : "var(--warn)"}"></span> Rollouts are ${on ? "on" : "<b>paused</b>"} · ${fmt.format(r.live)} running now${last ? ` · last one ${ago(last.created_at)}` : ""}</p></div>
-      <div class="ad-actions"><button class="btn ${on ? "" : "primary"}" id="ov-toggle" type="button">${icon(on ? "stop" : "play", 14)}${on ? "Pause rollouts" : "Resume rollouts"}</button>
-        <button class="btn" type="button" data-go="settings">${icon("message", 14)}Banner</button><button class="btn" type="button" data-go="indexes">${icon("archive", 14)}Indexing & API checks</button></div></div>
-    <div class="ad-stats">
-      ${stat("play", fmt.format(r.live), "running now", `${fmt.format(r.today)} in the last 24 hours`, r.live ? "live" : "")}
-      ${stat("list", fmt.format(r.total), "rollouts in all", `${fmt.format(r.week)} in the last 7 days`)}
-      ${stat("users", fmt.format(r.public), "on Community", `${fmt.format(r.private)} private · ${fmt.format(r.users)} people`)}
-      ${stat("alert", r.finished ? `${Math.round((100 * r.failed) / r.finished)}%` : "–", "failed or stopped", `of ${fmt.format(r.finished)} finished`, r.finished && r.failed / r.finished > 0.3 ? "warn" : "")}
-      ${stat("database", fmt.format(e.public.datasets), "visible datasets", `${fmt.format(e.public.tasks)} indexed task records`)}
-      ${stat("globe", fmt.format(e.public.spaces), "visible checked Spaces", `${fmt.format(e.spaces)} discovery candidates`)}
-    </div>
-    ${operations(o.operations)}
-    ${live.length ? `<section class="panel ad-live"><div class="panel-h"><h2><i class="pulse" style="color:var(--live)"></i>Running now</h2><a class="aside" href="#" data-go="rollouts">All rollouts</a></div>
-      <div class="panel-b ad-runs">${live.map((x) => runRow(x, true)).join("")}</div></section>` : ""}
-    <div class="ad-runner-summary">${r.by_runner.map(([name,n]) => `<span class="chip">${esc(runnerName(name))} · ${fmt.format(n)}</span>`).join("")}</div>
-    <div class="ad-grid">
-      <section class="panel"><div class="panel-h"><h2>${icon("play", 15)}Rollouts, last 14 days</h2><span class="aside">${fmt.format(r.week)} in the last 7 days</span></div>
-        <div class="panel-b"><div class="ad-bars">${r.by_day.map(([d, n]) => `<div title="${esc(d)}: ${n} rollout${n === 1 ? "" : "s"}"><i style="height:${Math.max(2, (100 * n) / peak)}%"></i><span>${d.slice(8)}</span></div>`).join("")}</div>
-        ${r.by_model.length ? `<div class="sec-label" style="margin-top:16px">Most-used models</div><ul class="ad-models">${r.by_model.map(([m, n]) => `<li><code>${esc(m)}</code>
-          <span class="share"><i style="width:${(100 * n) / r.by_model[0][1]}%"></i></span><b>${fmt.format(n)}</b></li>`).join("")}</ul>` : ""}</div></section>
-      <section class="panel"><div class="panel-h"><h2>${icon("flame", 15)}New on the Hub</h2><a class="aside" href="#" data-go="environments">Curate</a></div>
-        <div class="panel-b">${o.new.length ? `<ul class="ad-new">${o.new.slice(0, 9).map((x) => `<li>
-          ${x.kind === "space" ? `<img class="ad-th" src="${thumb(x.id)}" alt="" loading="lazy">` : `<span class="ad-th ic-only">${icon("database", 14)}</span>`}
-          <a href="${envHref(x)}" title="${esc(x.id)}" target="_blank" rel="noopener"><code>${esc(x.id)}</code><em>${x.kind === "space" ? "Space" : "Dataset"} · ${ago(Date.parse(x.created) / 1000)}${x.collection ? ` · in ${esc(x.collection)}` : ""}</em></a></li>`).join("")}</ul>`
-          : `<p class="muted sm">Nothing new in the last two weeks.</p>`}</div></section>
-    </div>
-    <section class="panel" style="margin-top:16px"><div class="panel-h"><h2>${icon("clock", 15)}Latest rollouts</h2><a class="aside" href="#" data-go="rollouts">All rollouts</a></div>
-      <div class="panel-b ad-runs">${o.recent.length ? o.recent.map((x) => runRow(x)).join("") : emptyState("play", "No rollouts yet", "They show up here as soon as someone runs one.")}</div></section>`;
-  body.querySelectorAll("[data-go]").forEach((b) => b.addEventListener("click", (ev) => { ev.preventDefault(); go(b.dataset.go); }));
-  $("#ov-toggle", body).addEventListener("click", async () => {
-    if (on && !confirm("Pause rollouts for everyone? Running ones finish; new ones are refused until you resume.")) return;
-    try { await api("/api/admin/settings", { method: "PUT", body: { ...pick(o.settings), rollouts_enabled: !on } }); toast(on ? "Rollouts paused" : "Rollouts resumed"); overview(body, { go, s }); }
-    catch (err) { toast(err.message); }
-  });
-  runActions(body, () => overview(body, { go, s }));
-}
-const pick = (st) => ({ rollouts_enabled: st.rollouts_enabled, max_active: st.max_active, max_per_user: st.max_per_user, agents: st.agents, announcement: st.announcement });
-
-// ── rollouts ─────────────────────────────────────────────────────────────────
-async function rollouts(body, { preset }) {
-  const st = { status: "", q: "", user: preset.user || "", runner: "", visibility: "", limit: 100 };
-  let sequence = 0, pending = null;
-  body.innerHTML = `${head("Rollouts", "All saved runners, including private runs. Community eligibility requires a completed, graded, unrestricted public rollout.")}
-    <div class="ad-tools"><div class="search">${icon("search", 16)}<input id="ad-q" type="search" aria-label="Search rollouts" placeholder="Task, environment, model, person or id"></div>
-      <select class="input" id="ad-runner" aria-label="Runner"><option value="">All runners</option></select>
-      <select class="input" id="ad-vis" aria-label="Visibility"><option value="">All visibility</option><option value="community">On Community</option><option value="private">Private</option><option value="public">Public records</option><option value="moderated">Moderated</option></select>
-      <select class="input" id="ad-st" aria-label="Status">${[["", "All statuses"], ["live", "Running"], ["done", "Done"], ["failed", "Failed"], ["cancelled", "Stopped"], ["interrupted", "Interrupted"]].map(([k,l])=>`<option value="${k}">${l}</option>`).join("")}</select>
-      <button class="btn" id="ad-refresh" type="button">${icon("refresh",14)}Refresh</button><span id="ad-who"></span></div>
-    <div id="ad-run-error" role="status"></div><div class="panel"><div class="panel-b ad-runs" id="ad-runs">${sk.lines(80, 70, 90)}</div></div>
-    <div class="more-row"><button class="btn" id="ad-run-more" hidden>Load more</button></div>`;
-  const load = async () => {
-    clearTimeout(timer); pending?.abort(); pending = new AbortController(); const request = ++sequence;
-    try {
-      const d = await api(`/api/admin/rollouts?${new URLSearchParams(st)}`, {signal:pending.signal});
-      if (!alive || !body.isConnected || request !== sequence) return;
-      $("#ad-run-error",body).textContent = "";
-      $("#ad-runner",body).innerHTML = '<option value="">All runners</option>' + d.runners.map(v=>`<option value="${esc(v)}" ${v===st.runner?'selected':''}>${esc(runnerName(v))}</option>`).join("");
-      $("#ad-who", body).innerHTML = st.user ? `<button class="pill" id="ad-clear-user" type="button"><span>by</span>${esc(st.user)}${icon("x", 13)}</button>` : "";
-      $("#ad-runs", body).innerHTML = d.runs.length ? `<p class="muted sm">Showing ${fmt.format(d.runs.length)} of ${fmt.format(d.total)} rollouts</p>${d.runs.map((r) => runRow(r, true)).join("")}` : emptyState("filter", "No rollouts here", "Try another filter.");
-      $("#ad-run-more",body).hidden = d.runs.length >= d.total || st.limit >= 500;
-      if (d.total > 500 && st.limit >= 500) $("#ad-run-error",body).textContent = "Showing the latest 500 matches. Refine your filters to find older runs.";
-      if (d.runs.some(r=>r.live)) timer = setTimeout(()=>body.isConnected && load(), 5000);
-    } catch(e) { if(e.name!=="AbortError" && body.isConnected) $("#ad-run-error",body).textContent=e.message; }
-  };
-  let t;
-  $("#ad-q", body).addEventListener("input", e=>{clearTimeout(t); pending?.abort(); ++sequence; st.q=e.target.value.trim(); st.limit=100; t=setTimeout(()=>body.isConnected && load(),250);});
-  for(const [id,key] of [["ad-runner","runner"],["ad-vis","visibility"],["ad-st","status"]]) $("#"+id,body).addEventListener("change",e=>{st[key]=e.target.value;st.limit=100;load();});
-  $("#ad-refresh",body).addEventListener("click",load);
-  $("#ad-run-more",body).addEventListener("click",()=>{st.limit+=100;load();});
-  body.addEventListener("click",e=>{if(e.target.closest("#ad-clear-user")){st.user="";preset.user="";load();}});
-  runActions(body,load); await load();
-}
-
-// ── people ───────────────────────────────────────────────────────────────────
-async function people(body, { go }) {
-  const d = await api("/api/admin/people");
-  if (!alive || !body.isConnected) return;
-  body.innerHTML = `${head("People", "Everyone who has run a rollout, most recent first.")}
-    ${d.people.length ? `<div class="ad-people">${d.people.map((p) => `<article class="panel ad-person">
-      <header>${pfp(p.name, p.avatar, 40)}<div><a href="https://huggingface.co/${encodeURIComponent(p.name)}" target="_blank" rel="noopener"><b>${esc(p.name)}</b> ${icon("external", 12)}</a>
-        <em>active ${ago(p.last)}${p.live ? ` · <span class="live-txt">${p.live} running</span>` : ""}</em></div></header>
-      <div class="ad-pstats"><div><b>${fmt.format(p.runs)}</b><span>rollouts</span></div><div><b>${fmt.format(p.scored)}</b><span>graded</span></div>
-        <div><b>${p.runs ? `${Math.round((100 * p.done) / p.runs)}%` : "–"}</b><span>finished</span></div><div><b>${fmt.format(p.public)}</b><span>on Community</span></div></div>
-      <dl class="kv sm"><dt>Models</dt><dd>${p.models.map(([m, n]) => `<code>${esc(m.split("/")[1] || m)}</code> <span class="faint">${n}</span>`).join(", ")}</dd>
-        <dt>Datasets</dt><dd>${p.datasets.map(([x, n]) => `${esc(x)} <span class="faint">${n}</span>`).join(", ")}</dd>
-        <dt>Since</dt><dd>${new Date(p.first * 1000).toLocaleDateString()}</dd></dl>
-      <button class="btn sm" type="button" data-user="${esc(p.name)}">${icon("play", 12)}Their rollouts</button></article>`).join("")}</div>`
-      : `<div class="panel">${emptyState("users", "Nobody yet", "People show up here after their first rollout.")}</div>`}`;
-}
-
-// ── environments: what trends, what's hidden, what's featured ────────────────
-async function environments(body) {
-  const d = await api("/api/admin/environments");
-  if (!alive || !body.isConnected) return;
-  const st = { q: "", kind: "", flag: "", health: "", shown: 60 };
-  const cols = d.collections;
-  const now = Date.now();
-  const isNew = (x) => x.created && now - Date.parse(x.created) < 14 * 864e5;
-  const n = (f) => d.environments.filter(f).length;
-  body.innerHTML = `${head("Environments", "Pin to feature separately above the trending row on Explore; hide to take off every listing (the page still opens by link); put in a collection to feature it.")}
-    <div class="ad-tools"><div class="search">${icon("search", 16)}<input id="ad-q" type="search" aria-label="Search environments" placeholder="Search environments…"></div>
-      <div class="seg" id="ad-flag">${[["", "All", d.environments.length], ["new", "New", n(isNew)], ["pinned", "Pinned", n((x) => x.pinned)], ["hidden", "Hidden", n((x) => x.hidden)],
-        ["loose", "In no collection", n((x) => !x.collection)], ["unindexed", "No file index", n((x) => x.kind === "dataset" && !x.indexed)]]
-        .map(([k, l, c]) => `<button type="button" data-flag="${k}" aria-pressed="${k === ""}">${l}<span>${fmt.format(c)}</span></button>`).join("")}</div>
-      <select class="hf-select-mimo" id="ad-kind" aria-label="Environment type"><option value="">Datasets and Spaces</option><option value="dataset">Datasets</option><option value="space">Spaces</option></select><select class="input" id="ad-health" aria-label="API evidence"><option value="">All API evidence</option><option value="ready">Checked Spaces</option><option value="candidate">Unverified / unavailable Spaces</option><option value="Check expired">Expired checks</option><option value="Checks failed">OpenEnv checks failed</option><option value="Not running">Not running</option></select></div><p class="fine">Discovery candidates are kept here for review. Only Spaces with fresh supported API evidence appear in the default explorer. Versions are declared dependencies, not runtime attestations.</p>
-    <div class="panel"><div class="ad-envs" id="ad-envs"></div></div>
-    <div class="more-row"><button class="btn" id="ad-more" type="button">Show more</button></div>`;
-  const draw = () => {
-    const q = st.q.toLowerCase();
-    const rows = d.environments.filter((x) => (!st.kind || x.kind === st.kind) && (!q || `${x.id} ${x.heading || ""} ${x.tags.join(" ")}`.toLowerCase().includes(q))
-      && (!st.health || (x.kind === "space" && (st.health === "ready" ? x.ready : st.health === "candidate" ? !x.ready : x.api_status === st.health)))
-      && (!st.flag || (st.flag === "new" ? isNew(x) : st.flag === "pinned" ? x.pinned : st.flag === "hidden" ? x.hidden
-        : st.flag === "loose" ? !x.collection : x.kind === "dataset" && !x.indexed)))
-      .sort((a, b) => (b.pinned - a.pinned) || (b.trending - a.trending) || (b.likes - a.likes) || (b.downloads - a.downloads));
-    $("#ad-envs", body).innerHTML = rows.length ? `<div class="ad-env head"><span>Environment</span><span>Collection</span><span class="num">Trending</span><span class="num">Downloads</span>
-      <span class="num">Tasks</span><span class="num">Rollouts</span><span></span></div>` + rows.slice(0, st.shown).map((x) => `<div class="ad-env${x.hidden ? " gone" : ""}">
-      <span class="ad-name">${x.kind === "space" ? `<img class="ad-th" src="${thumb(x.id)}" alt="" loading="lazy">` : `<span class="ad-th ic-only">${icon("database", 14)}</span>`}
-        <a href="${envHref(x)}" title="${esc(x.id)}" target="_blank" rel="noopener"><code>${esc(x.id)}</code></a>
-        ${x.kind === "space" ? `<span class="chip ${x.ready ? "new" : ""}" title="${esc(x.api_status || "Not checked")}">${esc(x.ready ? (x.openenv ? "OpenEnv API checked" : x.framework + " API checked") : x.api_status || "Not checked")}</span><span class="faint xs" title="${esc((x.declared_version || "Unknown version") + " · " + (x.version_source || "Unknown source"))}">${esc(x.declared_version || "Unknown version")}</span>` : `<span class="chip">${esc(x.id === "XiaomiMiMo/MiMo-V2.6-RL-oss" ? "MiMo" : x.framework === "rows" ? "RL dataset" : runnerName(x.framework))}</span>`}
-        ${x.pinned ? `<span class="chip">${icon("flag", 11)}Pinned</span>` : ""}${x.hidden ? `<span class="chip">Hidden</span>` : ""}${isNew(x) ? `<span class="chip new">New</span>` : ""}</span>
-      <span><select class="hf-select-mimo sm" data-feature="${esc(x.key)}" aria-label="Collection"><option value="">No collection</option>${cols.map((c) => `<option value="${c.id}" ${x.collection === c.id ? "selected" : ""}>${esc(c.group)}</option>`).join("")}</select></span>
-      <span class="num">${fmt.format(x.trending || 0)}</span><span class="num">${x.kind === "dataset" ? compact.format(x.downloads) : `${compact.format(x.likes)} ♥`}</span>
-      <span class="num">${x.indexed?.tasks != null ? fmt.format(x.indexed.tasks) : x.kind === "dataset" && x.framework === "harbor" ? `<button class="link" data-index="${esc(x.key)}">Index</button>` : "–"}</span>
-      <span class="num">${fmt.format(x.rollouts || 0)}</span>
-      <span class="ad-act"><button class="btn sm ${x.pinned ? "" : "ghost"}" data-act="${x.pinned ? "unpin" : "pin"}" data-key="${esc(x.key)}" title="${x.pinned ? "Unpin" : "Feature above trending"}">${icon("flag", 12)}${x.pinned ? "Unpin" : "Pin"}</button>
-        <button class="btn sm ${x.hidden ? "" : "ghost"}" data-act="${x.hidden ? "unhide" : "hide"}" data-key="${esc(x.key)}">${x.hidden ? "Unhide" : "Hide"}</button></span></div>`).join("")
-      : emptyState("search", "Nothing here", "Try another filter.");
-    $("#ad-more", body).hidden = rows.length <= st.shown;
-  };
-  const act = async (key, action, extra = {}) => {
-    if (action === "hide" && !confirm(`Hide ${key.replace(/^space:/, "")} from every listing?`)) return draw();
-    try {
-      await api("/api/admin/environments", { method: "POST", body: { key, action, ...extra } });
-      const x = d.environments.find((y) => y.key === key);
-      if (x) {
-        if (action === "pin" || action === "unpin") x.pinned = action === "pin";
-        if (action === "hide" || action === "unhide") x.hidden = action === "hide";
-        if (action === "feature" || action === "unfeature") x.collection = extra.collection || null;
-      }
-      toast({ pin: "Pinned: shown as an editorial pick", unpin: "Unpinned", hide: "Hidden from listings", unhide: "Back in listings", feature: "Added to the collection",
-              unfeature: "Taken out of its collection", index: "Indexing started" }[action]);
-      draw();
-    } catch (e) { toast(e.message); }
-  };
-  let t;
-  $("#ad-q", body).addEventListener("input", (e) => { clearTimeout(t); t = setTimeout(() => { st.q = e.target.value.trim(); st.shown = 60; draw(); }, 150); });
-  $("#ad-health",body).addEventListener("change",e=>{st.health=e.target.value;st.shown=60;draw();});
-  $("#ad-kind", body).addEventListener("change", (e) => { st.kind = e.target.value; st.shown=60; draw(); });
-  $("#ad-flag", body).addEventListener("click", (e) => { const b = e.target.closest("[data-flag]"); if (!b) return; st.flag = b.dataset.flag;
-    body.querySelectorAll("#ad-flag [data-flag]").forEach((x) => x.setAttribute("aria-pressed", String(x === b))); draw(); });
-  $("#ad-more", body).addEventListener("click", () => { st.shown += 100; draw(); });
-  body.addEventListener("click", (e) => {
-    const b = e.target.closest("[data-act]");
-    if (b) act(b.dataset.key, b.dataset.act);
-    const i = e.target.closest("[data-index]");
-    if (i) { i.outerHTML = spinner(); act(i.dataset.index, "index"); }
-  });
-  body.addEventListener("change", (e) => {
-    const s = e.target.closest("[data-feature]");
-    if (s) act(s.dataset.feature, s.value ? "feature" : "unfeature", s.value ? { collection: s.value } : {});
-  });
-  draw();
-}
-
-// ── collections ──────────────────────────────────────────────────────────────
-async function collections(body) {
-  const d = await api("/api/admin/collections");
-  if (!alive || !body.isConnected) return;
-  let cols = d.collections.map((c) => ({ ...c, ids: [...c.ids] }));
-  let dirty = false;
-  const draw = () => {
-    body.innerHTML = `${head("Collections", "The tiles on Explore, in this order. One environment per line: a dataset id, or <code>space:org/name</code> for a Space.",
-      `<button class="btn" id="ad-add" type="button">${icon("plus", 14)}Add a collection</button><button class="btn primary" id="ad-save" type="button" ${dirty ? "" : "disabled"}>${icon("check", 14)}Save</button>`)}
-      <div class="ad-cols">${cols.map((c, i) => `<section class="panel" data-i="${i}"><div class="panel-h"><h2><span class="ad-swatch" style="--dc:var(--c-${esc(c.color)})">${icon(c.icon, 14)}</span>${esc(c.group || "New collection")}
-        <span class="faint xs">${c.ids.length} environment${c.ids.length === 1 ? "" : "s"}</span></h2>
-        <span class="aside"><button class="icon-btn" data-up="${i}" ${i ? "" : "disabled"} aria-label="Move up" title="Move up">${icon("chevronDown", 14, "up")}</button>
-        <button class="icon-btn" data-down="${i}" ${i < cols.length - 1 ? "" : "disabled"} aria-label="Move down" title="Move down">${icon("chevronDown", 14)}</button>
-        <button class="icon-btn" data-del="${i}" aria-label="Delete" title="Delete">${icon("x", 14)}</button></span></div>
-        <div class="panel-b ad-form">
-          <label class="field"><span>Name</span><input class="input" data-f="group" value="${esc(c.group)}" maxlength="40"></label>
-          <label class="field"><span>Id <em>lowercase, for links</em></span><input class="input mono" data-f="id" value="${esc(c.id)}" maxlength="31"></label>
-          <label class="field wide"><span>About</span><input class="input" data-f="about" value="${esc(c.about || "")}" maxlength="80"></label>
-          <label class="field"><span>Icon</span><select class="hf-select-mimo" data-f="icon">${d.icons.map((x) => `<option ${x === c.icon ? "selected" : ""}>${x}</option>`).join("")}</select></label>
-          <label class="field"><span>Colour</span><select class="hf-select-mimo" data-f="color">${d.colors.map((x) => `<option ${x === c.color ? "selected" : ""}>${x}</option>`).join("")}</select></label>
-          <label class="field wide"><span>Environments</span><textarea class="input mono" data-f="ids" rows="${Math.min(10, c.ids.length + 2)}">${esc(c.ids.join("\n"))}</textarea></label>
-        </div></section>`).join("")}</div>`;
-  };
-  const read = () => body.querySelectorAll("[data-i]").forEach((sec) => {
-    const c = cols[+sec.dataset.i];
-    sec.querySelectorAll("[data-f]").forEach((f) => { c[f.dataset.f] = f.dataset.f === "ids" ? f.value.split("\n").map((x) => x.trim()).filter(Boolean) : f.value.trim(); });
-  });
-  const touch = () => { dirty = true; const b = $("#ad-save", body); if (b) b.disabled = false; };
-  body.addEventListener("input", touch);
-  body.addEventListener("change", touch);
-  body.addEventListener("click", async (e) => {
-    const up = e.target.closest("[data-up]"), down = e.target.closest("[data-down]"), del = e.target.closest("[data-del]");
-    if (up || down || del) { read(); dirty = true; }
-    if (up) { const i = +up.dataset.up; [cols[i - 1], cols[i]] = [cols[i], cols[i - 1]]; draw(); }
-    else if (down) { const i = +down.dataset.down; [cols[i + 1], cols[i]] = [cols[i], cols[i + 1]]; draw(); }
-    else if (del) { if (confirm(`Delete the collection “${cols[+del.dataset.del].group}”? Its environments stay on the Hub.`)) { cols.splice(+del.dataset.del, 1); draw(); } }
-    else if (e.target.closest("#ad-add")) { read(); dirty = true; cols.push({ id: `new-${cols.length + 1}`, group: "New collection", about: "", icon: "grid", color: "code", ids: [] }); draw(); }
-    else if (e.target.closest("#ad-save")) {
-      read();
-      try { cols = (await api("/api/admin/collections", { method: "PUT", body: { collections: cols } })).collections.map((c) => ({ ...c, ids: [...c.ids] })); dirty = false; draw(); toast("Saved: Explore shows them within seconds"); }
-      catch (err) { toast(err.message); }
-    }
-  });
-  draw();
-}
-
-function operations(o) {
-  const job=o.indexer, snap=o.snapshot, c=o.checks, tasks=o.task_catalog;
-  const state=job.stale ? "Update overdue" : job.state === "indexing" ? "Indexing" : job.state === "retrying" ? "Retry scheduled" : job.state ? "Waiting for next cycle" : "Waiting for first report";
-  const when=v=>v ? ago(v) : "Not recorded";
-  return `<section class="panel ad-operations"><div class="panel-h"><h2>${icon("refresh",15)}Catalog operations</h2><span class="aside">Shared explorer state</span></div><div class="panel-b ad-ops-grid">
-    <div><b>Automatic indexing</b><p class="${job.stale || job.error ? 'err-text' : 'muted'}">${esc(state)}</p><dl class="kv sm"><dt>Last success</dt><dd>${when(job.last_success)}</dd><dt>Next attempt</dt><dd>${job.next_at ? esc(new Date(job.next_at*1000).toLocaleString()) : "Not recorded"}</dd><dt>Snapshot</dt><dd>${snap.built_at ? esc(new Date(snap.built_at).toLocaleString()) : "No snapshot yet"}</dd></dl>${job.error || snap.error ? `<p class="err-text">${esc(job.error || snap.error)}</p>` : ''}</div>
-    <div><b>Space API checks</b><p>${fmt.format(c.ready)} checked · ${fmt.format(c.openenv)} OpenEnv · ${fmt.format(c.candidates)} candidates</p><dl class="kv sm"><dt>Latest check</dt><dd>${when(c.latest_at)}</dd><dt>Freshness</dt><dd>${c.fresh_seconds/60} minutes</dd><dt>Reported tasks</dt><dd>${fmt.format(tasks.tasks)} in ${fmt.format(tasks.spaces)} Spaces${tasks.partial_spaces ? ` · ${tasks.partial_spaces} partial catalogs` : ''}</dd></dl></div>
-    <div class="ad-check-states">${Object.entries(c.statuses).map(([v,n])=>`<span class="chip">${esc(v)} · ${fmt.format(n)}</span>`).join('')}</div>
-    <p class="fine ad-ops-note">Task entries reported by Space APIs are separate from downloaded, searchable task records. Checks do not wake sleeping Spaces or certify grading quality. The explorer runs maintenance automatically while it is online.</p>
-    ${c.versions.length ? `<details class="ad-ops-note"><summary>Declared OpenEnv versions (${c.versions.length})</summary><div class="ad-check-states">${c.versions.map(([v,n])=>`<span class="chip">${esc(v)} · ${fmt.format(n)}</span>`).join('')}</div></details>` : ''}
-  </div></section>`;
-}
-
-// ── indexes ──────────────────────────────────────────────────────────────────
-async function indexes(body) {
-  const d = await api("/api/admin/indexes");
-  if (!alive || !body.isConnected) return;
-  body.indexEvents?.abort(); body.indexEvents = new AbortController();
-  const jobs = Object.entries(d.jobs);
-  body.innerHTML = `${head("Indexing & API checks", "Automatic maintenance, fresh protocol evidence and dataset indexes across frameworks.", '<button class="btn" id="ad-index-refresh">Refresh status</button>')}
-    ${operations(d.operations)}
-    <div class="ad-tools"><div class="search">${icon("database", 16)}<input id="ad-spec" placeholder="A public Harbor dataset: org/name"></div>
-      <button class="btn primary" id="ad-go" type="button">${icon("play", 14)}Index it</button></div>
-    ${jobs.length ? `<section class="panel" style="margin-bottom:12px"><div class="panel-h"><h2>${spinner()}Indexing now</h2></div><div class="panel-b"><dl class="kv">${jobs.map(([k, j]) =>
-      `<dt><code>${esc(k)}</code></dt><dd>${esc(j.state)}${j.total ? ` · ${fmt.format(j.done || 0)} of ${fmt.format(j.total)}` : ""}${j.error ? ` · <span class="err-text">${esc(j.error)}</span>` : ""}</dd>`).join("")}</dl></div></section>` : ""}
-    <div class="panel"><div class="tbl" style="max-height:none;border:0"><table><thead><tr><th>Dataset</th><th class="num">Tasks</th><th>Built</th><th class="num">Index</th><th class="num">Pack</th><th></th></tr></thead><tbody>
-    ${d.indexes.map((x) => `<tr><td><a class="u" href="${EXPLORER}/d/${enc(x.spec)}" target="_blank" rel="noopener"><code>${esc(x.spec)}</code></a></td><td class="num">${x.tasks != null ? fmt.format(x.tasks) : "–"}</td>
-      <td>${x.built ? ago(x.built) : "–"}${x.current ? "" : ` <span class="chip">old format</span>`}</td><td class="num">${bytes(x.bytes)}</td><td class="num">${bytes(x.pack_bytes)}</td>
-      <td><button class="btn sm ghost" data-reindex="${esc(x.spec)}">${icon("refresh", 12)}Rebuild</button></td></tr>`).join("")}</tbody></table></div></div>`;
-  const go = async (spec) => {
-    try { const result = await api("/api/admin/environments", { method: "POST", body: { key: spec, action: "index" } }); toast(result.job?.state === "done" ? "Index is current" : result.job?.state === "error" ? result.job.error || "Indexing failed" : `Indexing ${spec}`); timer = setTimeout(() => alive && body.isConnected && indexes(body), 1500); }
-    catch (e) { toast(e.message); }
-  };
-  $("#ad-index-refresh",body).addEventListener("click",()=>indexes(body));
-  $("#ad-go", body).addEventListener("click", () => { const v = $("#ad-spec", body).value.trim(); if (v) go(v); });
-  $("#ad-spec", body).addEventListener("keydown", (e) => { if (e.key === "Enter") $("#ad-go", body).click(); });
-  body.addEventListener("click", (e) => { const b = e.target.closest("[data-reindex]"); if (b) go(b.dataset.reindex); }, {signal:body.indexEvents.signal});
-  if (jobs.length) timer = setTimeout(() => alive && body.isConnected && indexes(body), 3000);
-}
-
-// ── settings ─────────────────────────────────────────────────────────────────
-async function settings(body) {
-  const s = await api("/api/admin/settings");
-  if (!alive || !body.isConnected) return;
-  body.innerHTML = `${head("Settings", "They apply to the explorer within seconds.")}
-    <section class="panel"><div class="panel-b ad-settings">
-      <div class="ad-set"><div><b>Rollouts</b><span>Off pauses new rollouts for everyone; running ones finish.</span></div>
-        <label class="toggle"><input type="checkbox" id="st-on" aria-label="Enable rollouts" ${s.rollouts_enabled ? "checked" : ""}><i></i></label></div>
-      <div class="ad-set"><div><b>Rollouts at once</b><span>The whole explorer, then each person.</span></div>
-        <div class="ad-nums"><input class="input" type="number" id="st-max" min="1" max="200" value="${s.max_active}" aria-label="The whole explorer"><span class="faint">/</span>
-          <input class="input" type="number" id="st-user" min="1" max="20" value="${s.max_per_user}" aria-label="Each person"></div></div>
-      <div class="ad-set"><div><b>Harbor agent harnesses</b><span>Controls Harbor runs. MiMo and NeMo Gym use their own supported execution paths.</span></div>
-        <div class="ad-checks">${s.all_agents.map((a) => `<label><input type="checkbox" data-agent="${a.id}" ${s.agents.includes(a.id) ? "checked" : ""}> ${esc(a.name)}</label>`).join("")}</div></div>
-      <div class="ad-set col"><div><b>Announcement</b><span>One line above every page of the explorer; empty for none.</span></div>
-        <input class="input" id="st-ann" maxlength="280" value="${esc(s.announcement)}" placeholder="e.g. Rollouts are slow today: a provider is overloaded.">
-        <div class="announce ad-preview" id="st-prev" ${s.announcement ? "" : "hidden"}><div class="wrap">${icon("info", 14)}<span>${esc(s.announcement)}</span></div></div></div>
-      <div class="ad-save-row"><span class="faint sm" id="st-dirty"></span><button class="btn primary" id="st-save" type="button">${icon("check", 14)}Save settings</button></div>
-    </div></section>`;
-  const mark = () => { $("#st-dirty", body).textContent = "Unsaved changes"; };
-  body.addEventListener("input", (e) => {
-    mark();
-    if (e.target.id === "st-ann") { $("#st-prev", body).hidden = !e.target.value.trim(); $("#st-prev span", body).textContent = e.target.value; }
-  });
-  body.addEventListener("change", mark);
-  $("#st-save", body).addEventListener("click", async () => {
-    const on = $("#st-on", body).checked;
-    if (!on && s.rollouts_enabled && !confirm("Pause rollouts for everyone?")) return;
-    try {
-      const r = await api("/api/admin/settings", { method: "PUT", body: { rollouts_enabled: on, max_active: +$("#st-max", body).value,
-        max_per_user: +$("#st-user", body).value, agents: [...body.querySelectorAll("[data-agent]:checked")].map((x) => x.dataset.agent), announcement: $("#st-ann", body).value.trim() } });
-      Object.assign(s, r);
-      $("#st-dirty", body).textContent = "";
-      toast("Saved");
-    } catch (e) { toast(e.message); }
-  });
-}
-
-// ── audit ────────────────────────────────────────────────────────────────────
-async function audit(body) {
-  const [d, ppl] = await Promise.all([api("/api/admin/audit"), api("/api/admin/people").catch(() => ({ people: [] }))]);
-  if (!alive || !body.isConnected) return;
-  const pics = Object.fromEntries(ppl.people.map((p) => [p.name, p.avatar]));
-  const me = getSession().user;
-  if (me) pics[me.name] = pics[me.name] || me.avatar;
-  body.innerHTML = `${head("Audit log", "Every change made here, newest first.")}<div class="panel"><div class="panel-b">${d.entries.length ? `<ol class="ad-audit">${d.entries.map((x) => `<li>
-    ${person(x.user, pics[x.user])}<span>${esc(x.note || Object.keys(x.after || {}).join(", ") || "changed settings")}</span><span class="faint" title="${new Date(x.at * 1000).toLocaleString()}">${ago(x.at)}</span></li>`).join("")}</ol>`
-    : emptyState("list", "Nothing yet", "Changes made here show up in this log.")}</div></div>`;
-}

web-admin/index.html

@@ -1,41 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
-  <title>HF RL Explorer admin</title>
-  <meta name="robots" content="noindex">
-  <link rel="icon" href="https://huggingface.co/front/assets/huggingface_logo-noborder.svg" type="image/svg+xml">
-  <link rel="preconnect" href="https://fonts.googleapis.com">
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
-  <link rel="stylesheet" href="/app.css">
-  <link rel="stylesheet" href="/rlx.css">
-  <link rel="stylesheet" href="/admin/admin.css">
-  <script src="/js/boot.js"></script>
-</head>
-<body>
-  <div class="progress" id="progress" aria-hidden="true"><i></i></div>
-  <header class="top">
-    <div class="wrap top-inner">
-      <a class="brand" href="#/" aria-label="HF RL Explorer admin, home">
-        <img class="logo" src="https://huggingface.co/front/assets/huggingface_logo-noborder.svg" alt="" width="30" height="30">
-        <span class="name">HF RL Explorer <span>Admin</span></span>
-      </a>
-      <nav class="nav" aria-label="Main"><a href="#/" class="on">Dashboard</a><a id="to-explorer" href="/" target="_blank" rel="noopener">Explorer ↗</a></nav>
-      <div class="top-right">
-        <button class="icon-btn" id="theme" type="button" aria-label="Toggle dark mode" title="Toggle dark mode"></button>
-        <div id="account"></div>
-      </div>
-    </div>
-  </header>
-  <main id="view"><div class="boot" aria-label="Loading"><span class="spinner lg"></span></div></main>
-  <div class="scrim" id="scrim" hidden></div>
-  <div class="modal" id="modal" role="dialog" aria-modal="true" hidden><div class="modal-bar"><span id="modal-icon"></span><span id="modal-title"></span><span class="grow"></span>
-    <a class="btn sm" id="modal-open" target="_blank" rel="noopener" hidden></a><button class="icon-btn" id="modal-close" type="button" aria-label="Close"></button></div><div class="modal-body" id="modal-body"></div></div>
-  <div id="dialog-root"></div>
-  <div class="toast" id="toast" role="status" hidden></div>
-  <footer class="foot"><div class="wrap"><span>HF RL Explorer admin · private to the FineEnvs organization</span><span class="grow"></span><span id="foot-version"></span></div></footer>
-  <script type="module" src="/admin/main.js"></script>
-</body>
-</html>

web-admin/main.js

@@ -1,28 +0,0 @@
-// The admin Space's shell: who you are, the theme, and the dashboard (web-admin/admin.js).
-import { $, api, esc, storage } from "/js/util.js";
-import { icon } from "/js/icons.js";
-import { getSession, setSession } from "/js/session.js";
-import * as dash from "/admin/admin.js";
-
-async function boot() {
-  try { setSession(await api("/api/me")); } catch { setSession({ user: null }); }
-  const s = getSession();
-  $("#to-explorer").href = s.explorer || "/";
-  if (s.version) $("#foot-version").innerHTML = `v${esc(s.version)} · <code>${esc(s.source || "")}</code>`;
-  $("#account").innerHTML = s.user ? `<span class="acct-btn" title="${esc(s.user.name)}">${s.user.avatar ? `<img src="${esc(s.user.avatar)}" alt="">` : ""}<span class="name">${esc(s.user.name)}</span></span>
-    ${s.local ? "" : `<button class="btn sm ghost" id="signout" type="button">${icon("logout", 13)}Sign out</button>`}` : "";
-  $("#signout")?.addEventListener("click", async () => { await api("/api/logout", { method: "POST" }).catch(() => {}); location.reload(); });
-  const route = () => {
-    dash.unmount();
-    const qs = new URLSearchParams((location.hash.split("?")[1]) || "");
-    dash.mount($("#view"), { qs, explorer: s.explorer });
-  };
-  addEventListener("hashchange", route);
-  route();
-}
-
-const isDark = () => (document.documentElement.dataset.theme ? document.documentElement.dataset.theme === "dark" : matchMedia("(prefers-color-scheme: dark)").matches);
-const paint = () => { $("#theme").innerHTML = icon(isDark() ? "sun" : "moon", 17); };
-paint();
-$("#theme").addEventListener("click", () => { document.documentElement.dataset.theme = isDark() ? "light" : "dark"; storage.set("theme", document.documentElement.dataset.theme); paint(); });
-boot();