Make the manage panel work across versions, and fix what it did wrong

Three defects, all from the panel predating versioning.

Delete removed the queue entry as well as the score. The request is shared by every
version, so deleting a v8 score also destroyed the v7 row's metadata and left no way
to re-run without resubmitting. Delete is now two actions: 'Delete <version> score'
drops that version's file and keeps the queue entry, and 'Remove entirely' takes the
request plus every version's score. The old wording promised the second while the
button was reached from a single version.

Nothing showed which versions a model was actually on. The status badge is global --
one request serves all versions -- so a model reading FINISHED could have no score on
the board being viewed. Each row now carries a chip per version, and the panel header
counts how many are scored versus missing on the current one.

There was no way to start a version. The worker only claims PENDING / RUNNING / RERUN,
so after a sweep every model sits at FINISHED and a new version would evaluate nothing
at all. /api/requeue-all sets them back to RERUN, defaulting to only the models with no
score on the target version so a half-finished sweep resumes instead of restarting.

test_manage.py covers all of it against a stubbed Hub: per-version presence, that a
scoped delete leaves the other version and the request alone, that scope=all removes
both, and that requeue skips models already scored or already queued.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app.py

@@ -286,11 +286,16 @@ def _results_paths(model: str, version: str | None = None) -> list[str]:
 class ModelRef(BaseModel):
     model: str
     version: str | None = None
+    # "version" removes only this version's score and leaves the queue entry, so the
+    # model can be re-evaluated. "all" removes the queue entry and every version's
+    # score. Deleting a v8 score used to destroy the shared request too, which took
+    # the v7 row's metadata with it and left no way to re-run without resubmitting.
+    scope: str = "version"
 
 
 @app.get("/api/manage")
 def manage(request: Request, version: str | None = None):
-    """Every request + whether a public/private score exists. Owner-only."""
+    """Every request + where its scores live, per benchmark version. Owner-only."""
     _require_owner(request, check_origin=False)   # read-only GET
     api = HfApi(token=HF_TOKEN)
     have = {}
@@ -304,10 +309,16 @@ def manage(request: Request, version: str | None = None):
     rows = []
     for r in _list_requests():
         m = r.get("model", "")
-        where = set()
-        for path in _results_paths(m, version):
-            where |= have.get(path, set())
-        where = sorted(where)
+        # Presence per version, so the panel can show at a glance which boards a
+        # model is actually on. `result_in` stays for the selected version because
+        # the older UI read it.
+        by_version = {}
+        for v in VERSIONS:
+            where = set()
+            for path in _results_paths(m, v):
+                where |= have.get(path, set())
+            if where:
+                by_version[v] = sorted(where)
         rows.append({
             "model": m,
             "status": r.get("status"),
@@ -315,10 +326,12 @@ def manage(request: Request, version: str | None = None):
             "submitted_by": r.get("submitted_by"),
             "source": r.get("source", "open"),
             "visibility": r.get("visibility", "public"),
-            "result_in": where,
+            "result_in": by_version.get(_clean_version(version), []),
+            "results_by_version": by_version,
         })
     rows.sort(key=lambda x: x.get("submitted_time") or "", reverse=True)
-    return {"models": rows, "owner": LEADERBOARD_OWNER}
+    return {"models": rows, "owner": LEADERBOARD_OWNER,
+            "versions": VERSIONS, "version": _clean_version(version)}
 
 
 @app.post("/api/model/delete")
@@ -329,19 +342,25 @@ def model_delete(request: Request, body: ModelRef):
     if not MODEL_RE.match(model):
         raise HTTPException(400, "Bad model id.")
     api = HfApi(token=HF_TOKEN)
+    scope = (body.scope or "version").strip().lower()
+    if scope not in ("version", "all"):
+        raise HTTPException(400, "scope must be 'version' or 'all'.")
     removed = []
-    for r in _list_requests():
-        if r.get("model") == model and r.get("_path"):
-            try:
-                api.delete_file(path_in_repo=r["_path"], repo_id=REQUESTS_REPO,
-                                repo_type="dataset",
-                                commit_message=f"Remove request {model}")
-                removed.append(f"request:{r['_path']}")
-            except Exception as e:
-                print(f"[delete] request {model}: {type(e).__name__}: {e}")
+    if scope == "all":
+        for r in _list_requests():
+            if r.get("model") == model and r.get("_path"):
+                try:
+                    api.delete_file(path_in_repo=r["_path"], repo_id=REQUESTS_REPO,
+                                    repo_type="dataset",
+                                    commit_message=f"Remove request {model}")
+                    removed.append(f"request:{r['_path']}")
+                except Exception as e:
+                    print(f"[delete] request {model}: {type(e).__name__}: {e}")
     version = _clean_version(body.version)
+    targets = ([p for v in VERSIONS for p in _results_paths(model, v)]
+               if scope == "all" else _results_paths(model, version))
     for repo in (RESULTS_REPO, RESULTS_PRIVATE_REPO):
-        for path in _results_paths(model, version):
+        for path in dict.fromkeys(targets):
             try:
                 api.delete_file(path_in_repo=path, repo_id=repo,
                                 repo_type="dataset",
@@ -350,9 +369,13 @@ def model_delete(request: Request, body: ModelRef):
             except Exception:
                 pass      # simply not present there
     if not removed:
-        raise HTTPException(404, f"Nothing found for {model}.")
+        raise HTTPException(
+            404,
+            f"{model} has no score on {version}." if scope == "version"
+            else f"Nothing found for {model}.")
+    what = f"every version of {model}" if scope == "all" else f"{model} from {version}"
     return {"ok": True, "removed": removed,
-            "message": f"Deleted {model} ({len(removed)} file(s))."}
+            "message": f"Deleted {what} ({len(removed)} file(s))."}
 
 
 @app.post("/api/model/rerun")
@@ -377,7 +400,65 @@ def model_rerun(request: Request, body: ModelRef):
         path_or_fileobj=json.dumps(payload, ensure_ascii=False, indent=1).encode("utf-8"),
         path_in_repo=hit["_path"], repo_id=REQUESTS_REPO, repo_type="dataset",
         commit_message=f"{model} -> RERUN")
-    return {"ok": True, "message": f"{model} queued for re-evaluation (RERUN)."}
+    return {"ok": True,
+            "message": f"{model} queued for re-evaluation (RERUN). It lands on "
+                       f"whichever version the worker is running (its RUN_ID)."}
+
+
+class RequeueRef(BaseModel):
+    version: str | None = None
+    # Default to only what is missing, so re-running a half-finished sweep does not
+    # discard the models that already landed.
+    only_missing: bool = True
+
+
+@app.post("/api/requeue-all")
+def requeue_all(request: Request, body: RequeueRef):
+    """Set every queued model to RERUN so a whole version can be evaluated.
+
+    The worker only ever picks up PENDING / RUNNING / RERUN, so after a sweep every
+    model sits at FINISHED and a new version would evaluate nothing at all. This is
+    the switch that starts the next version's run."""
+    _require_owner(request)
+    version = _clean_version(body.version)
+    api = HfApi(token=HF_TOKEN)
+
+    have = set()
+    for repo in (RESULTS_REPO, RESULTS_PRIVATE_REPO):
+        try:
+            have |= {f for f in api.list_repo_files(repo, repo_type="dataset")
+                     if f.endswith(".json")}
+        except Exception:
+            pass
+
+    queued, skipped = [], []
+    for r in _list_requests():
+        model = r.get("model")
+        if not model or not r.get("_path"):
+            continue
+        scored = any(p in have for p in _results_paths(model, version))
+        if body.only_missing and scored:
+            skipped.append(model)
+            continue
+        if str(r.get("status") or "").upper() in ("PENDING", "RUNNING", "RERUN"):
+            skipped.append(model)      # already on the worker's list
+            continue
+        payload = {k: v for k, v in r.items() if k != "_path"}
+        payload["status"] = "RERUN"
+        try:
+            api.upload_file(
+                path_or_fileobj=json.dumps(payload, ensure_ascii=False, indent=1).encode("utf-8"),
+                path_in_repo=r["_path"], repo_id=REQUESTS_REPO, repo_type="dataset",
+                commit_message=f"{model} -> RERUN (requeue for {version})")
+            queued.append(model)
+        except Exception as e:
+            print(f"[requeue-all] {model}: {type(e).__name__}: {e}")
+    msg = (f"Queued {len(queued)} model(s) for {version}."
+           + (f" Skipped {len(skipped)} already scored or already queued." if skipped else ""))
+    if not queued:
+        msg = (f"Nothing to queue for {version} — "
+               f"{len(skipped)} model(s) are already scored or already in the queue.")
+    return {"ok": True, "queued": queued, "skipped": skipped, "message": msg}
 
 
 @app.get("/api/private-results")

index.html

@@ -172,6 +172,13 @@ table.board tbody tr:hover td:nth-child(1),table.board tbody tr:hover td:nth-chi
 .mbtn:hover{border-color:var(--accent);color:var(--accent)}
 .mbtn.danger:hover{border-color:#e06666;color:#e06666}
 .b-private{background:rgba(120,120,200,.16);color:#9aa4e0}
+.vchip{font:600 10px "IBM Plex Mono";padding:2px 7px;border-radius:6px;border:1px solid var(--border);
+  color:var(--ink-mute);white-space:nowrap}
+.vchip.on{border-color:var(--accent);color:var(--accent)}
+.vchip.here{box-shadow:inset 0 0 0 1px var(--accent)}
+.mbar{display:flex;align-items:center;gap:9px;flex-wrap:wrap;padding:9px 0 11px;
+  border-bottom:1px solid var(--border);margin-bottom:6px}
+.mbar .grow{flex:1 1 auto}
 .prog{margin:2px 0 12px;padding:11px 13px;border-radius:12px;background:rgba(var(--cell-heat),.07);
       border:1px solid var(--border)}
 .prog .ptop{display:flex;align-items:baseline;gap:9px;flex-wrap:wrap;font-size:13px}
@@ -293,6 +300,12 @@ footer{margin-top:30px;text-align:center;color:var(--ink-mute);font-size:12px}
   <div class="grid2 one" id="managePanel" hidden>
     <div class="panel">
       <h3><span class="k">Manage</span> Your submitted models<span id="manageCount" class="qcount"></span></h3>
+      <div class="mbar" id="manageBar" hidden>
+        <span class="vchip here" id="mbarVer"></span>
+        <span class="grow" style="font-size:12px;color:var(--ink-mute)" id="mbarNote"></span>
+        <button class="mbtn" id="btnQueueMissing">Queue models missing here</button>
+        <button class="mbtn" id="btnQueueAll">Queue every model</button>
+      </div>
       <div id="manageList"><div class="mrow" style="color:var(--ink-mute)">Loading…</div></div>
       <div class="msg" id="manageMsg"></div>
     </div>
@@ -923,7 +936,13 @@ async function loadManage(){
     const d=await r.json();
     panel.hidden=false;
     const models=Array.isArray(d.models)?d.models:[];
+    const versions=Array.isArray(d.versions)&&d.versions.length?d.versions:VERSIONS.map(v=>v.id);
     document.getElementById('manageCount').textContent=`${models.length} submitted`;
+    const missing=models.length-models.filter(m=>((m.results_by_version||{})[CURRENT.id]||[]).length).length;
+    document.getElementById('manageBar').hidden=false;
+    document.getElementById('mbarVer').textContent='managing '+CURRENT.id;
+    document.getElementById('mbarNote').textContent=
+      `${models.length-missing} scored on ${CURRENT.id}, ${missing} missing`;
     if(!models.length){list.innerHTML='<div class="mrow" style="color:var(--ink-mute)">Nothing submitted yet.</div>';return;}
     list.innerHTML=models.map(m=>{
       const s=(m.status||'').toUpperCase();
@@ -931,13 +950,30 @@ async function loadManage(){
       const tags=[`<span class="badge ${cls}">${s}</span>`];
       if(m.visibility==='private')tags.push('<span class="badge b-private">PRIVATE</span>');
       if(m.source==='closed')tags.push('<span class="badge b-pending">API</span>');
+      // Where this model actually has a score. The status badge above is global —
+      // one request serves every version — so it says nothing about which board the
+      // model is on. These chips do.
+      const byv=m.results_by_version||{};
+      const chips=versions.map(v=>{
+        const on=Array.isArray(byv[v])&&byv[v].length;
+        const priv=on&&byv[v].includes('private')&&!byv[v].includes('public');
+        return `<span class="vchip${on?' on':''}${v===CURRENT.id?' here':''}" title="${
+          on?`scored on ${v}${priv?' (private)':''}`:`no score on ${v}`}">${v}${on?(priv?' ●':' ✓'):' —'}</span>`;
+      }).join('');
+      const hasHere=Array.isArray(byv[CURRENT.id])&&byv[CURRENT.id].length;
       return `<div class="mrow" data-model="${esc(m.model)}">
         <span class="mname" title="${esc(m.model)}">${esc(m.model)}</span>
-        ${tags.join('')}
+        ${tags.join('')}${chips}
         <button class="mbtn" data-act="rerun">Re-run</button>
-        <button class="mbtn danger" data-act="delete">Delete</button>
+        <button class="mbtn danger" data-act="delete"${hasHere?'':' disabled title="no score on this version"'}>Delete ${esc(CURRENT.id)} score</button>
+        <button class="mbtn danger" data-act="purge">Remove entirely</button>
       </div>`;}).join('');
     list.querySelectorAll('button[data-act]').forEach(b=>b.onclick=()=>manageAct(b));
+    const bm=document.getElementById('btnQueueMissing'), ba=document.getElementById('btnQueueAll');
+    bm.textContent=`Queue ${missing} missing on ${CURRENT.id}`;
+    bm.disabled=!missing;
+    bm.onclick=()=>requeue(true,bm);
+    ba.onclick=()=>requeue(false,ba);
   }catch(e){
     panel.hidden=true;
     list.innerHTML=`<div class="mrow" style="color:var(--ink-mute)">Could not load (${esc(String(e))}).</div>`;
@@ -946,21 +982,46 @@ async function loadManage(){
 
 async function manageAct(btn){
   const row=btn.closest('.mrow'), model=row.dataset.model, act=btn.dataset.act;
-  if(act==='delete'&&!confirm(`Delete ${model}?\n\nThis removes its queue entry AND its score from the leaderboard. It cannot be undone �� only a fresh evaluation would bring it back.`))return;
+  const label=btn.textContent;
+  // 'delete' drops only the score on the version being viewed. 'purge' removes the
+  // queue entry and every version's score — the request is shared across versions,
+  // so purging while looking at v8 also takes the v7 row down.
+  if(act==='delete'&&!confirm(
+      `Remove ${model}'s ${CURRENT.id} score?\n\nIts queue entry stays, so it can be evaluated again. Scores on other versions are untouched.`))return;
+  if(act==='purge'&&!confirm(
+      `Remove ${model} entirely?\n\nThis deletes its queue entry AND its score on EVERY version, ${CURRENT.id} included. It cannot be undone — only a fresh submission would bring it back.`))return;
   row.querySelectorAll('button').forEach(b=>b.disabled=true);
-  btn.textContent=act==='delete'?'Deleting…':'Queuing…';
+  btn.textContent=act==='rerun'?'Queuing…':'Removing…';
+  const url=act==='rerun'?'/api/model/rerun':'/api/model/delete';
+  const body={model,version:CURRENT.id};
+  if(act!=='rerun')body.scope=(act==='purge')?'all':'version';
   try{
-    const r=await fetch(`/api/model/${act}`,{method:'POST',credentials:'same-origin',
-      headers:{'Content-Type':'application/json'},body:JSON.stringify({model,version:CURRENT.id})});
+    const r=await fetch(url,{method:'POST',credentials:'same-origin',
+      headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
     const d=await r.json().catch(()=>({}));
     if(r.ok){mmsg(d.message||'Done.','ok');await loadManage();
-      if(act==='delete')setTimeout(()=>location.reload(),1200);}
+      if(act!=='rerun')setTimeout(()=>location.reload(),1200);}
     else{mmsg(d.detail||d.message||('Error '+r.status),'err');
       row.querySelectorAll('button').forEach(b=>b.disabled=false);
-      btn.textContent=act==='delete'?'Delete':'Re-run';}
+      btn.textContent=label;}
   }catch(e){mmsg('Network error — please try again.','err');
     row.querySelectorAll('button').forEach(b=>b.disabled=false);
-    btn.textContent=act==='delete'?'Delete':'Re-run';}
+    btn.textContent=label;}
+}
+
+async function requeue(onlyMissing,btn){
+  const what=onlyMissing?`every model with no ${CURRENT.id} score`:`ALL models, including the ${CURRENT.id} ones already scored`;
+  if(!confirm(`Queue ${what} for re-evaluation?\n\nThey run on whichever version the worker has as its RUN_ID — make sure that is ${CURRENT.id} before starting it.`))return;
+  const label=btn.textContent; btn.disabled=true; btn.textContent='Queuing…';
+  try{
+    const r=await fetch('/api/requeue-all',{method:'POST',credentials:'same-origin',
+      headers:{'Content-Type':'application/json'},
+      body:JSON.stringify({version:CURRENT.id,only_missing:onlyMissing})});
+    const d=await r.json().catch(()=>({}));
+    mmsg(r.ok?(d.message||'Queued.'):(d.detail||d.message||('Error '+r.status)),r.ok?'ok':'err');
+    if(r.ok)await loadManage();
+  }catch(e){mmsg('Network error — please try again.','err');}
+  btn.disabled=false; btn.textContent=label;
 }
 
 // show the pinned-column edge shadow only while the table is scrolled right

test_manage.py

@@ -0,0 +1,95 @@
+"""Exercise the real manage/delete/requeue routes with the Hub stubbed out."""
+import sys, types, json, importlib.util
+
+import os
+os.environ["HF_TOKEN"] = "stub-token"
+os.environ["LEADERBOARD_OWNER"] = "Mushari440"
+
+# ---- fake Hub state -------------------------------------------------------
+FILES = {
+    "Mushari440/results": {
+        "v7/org/results_alpha.json", "v7/org/results_beta.json",
+        "v8/org/results_alpha.json",
+    },
+    "Mushari440/results-private": set(),
+    "Mushari440/requests": {"org/alpha.json", "org/beta.json", "org/gamma.json"},
+}
+REQ = {
+    "org/alpha.json": {"model": "org/alpha", "status": "FINISHED"},
+    "org/beta.json":  {"model": "org/beta",  "status": "FINISHED"},
+    "org/gamma.json": {"model": "org/gamma", "status": "PENDING"},
+}
+COMMITS = []
+
+class FakeApi:
+    def __init__(self, *a, **k): pass
+    def list_repo_files(self, repo_id=None, repo_type=None, *a, **k):
+        return sorted(FILES.get(repo_id or a[0] if a else repo_id, set()))
+    def delete_file(self, path_in_repo=None, repo_id=None, **k):
+        if path_in_repo not in FILES.get(repo_id, set()):
+            raise RuntimeError("404")
+        FILES[repo_id].discard(path_in_repo)
+        if repo_id == "Mushari440/requests":
+            REQ.pop(path_in_repo, None)      # the queue entry lives in both fakes
+        COMMITS.append(("delete", repo_id, path_in_repo))
+    def upload_file(self, path_or_fileobj=None, path_in_repo=None, repo_id=None, **k):
+        body = json.loads(path_or_fileobj.decode() if isinstance(path_or_fileobj, bytes) else path_or_fileobj)
+        REQ[path_in_repo] = body
+        COMMITS.append(("upload", repo_id, path_in_repo, body.get("status")))
+
+spec = importlib.util.spec_from_file_location("spaceapp", os.path.join(os.path.dirname(__file__), "app.py"))
+app = importlib.util.module_from_spec(spec)
+sys.modules["spaceapp"] = app
+spec.loader.exec_module(app)
+
+app.HfApi = FakeApi
+app.api = FakeApi()
+app._require_owner = lambda *a, **k: "Mushari440"
+app._list_requests = lambda: [dict(v, _path=k) for k, v in REQ.items()]
+
+fails = []
+def check(name, got, want):
+    ok = got == want
+    if not ok:
+        fails.append(name)
+        print(f"  FAIL  {name}\n        got  {got}\n        want {want}")
+    else:
+        print(f"  PASS  {name}")
+
+R = types.SimpleNamespace(headers={}, cookies={}, session={})
+
+print("manage reports presence per version")
+rows = {m["model"]: m for m in app.manage(R, version="v8")["models"]}
+check("alpha scored on v7 and v8", sorted(rows["alpha" if "alpha" in rows else "org/alpha"]["results_by_version"]), ["v7", "v8"])
+check("beta scored on v7 only",    sorted(rows["org/beta"]["results_by_version"]), ["v7"])
+check("gamma scored nowhere",      rows["org/gamma"]["results_by_version"], {})
+check("result_in follows the asked version", rows["org/beta"]["result_in"], [])
+
+print("\ndelete scope='version' touches only that version")
+app.model_delete(R, app.ModelRef(model="org/alpha", version="v8", scope="version"))
+check("v8 score gone",        "v8/org/results_alpha.json" in FILES["Mushari440/results"], False)
+check("v7 score untouched",   "v7/org/results_alpha.json" in FILES["Mushari440/results"], True)
+check("request kept",         "org/alpha.json" in REQ, True)
+
+print("\ndelete scope='all' removes the model everywhere")
+app.model_delete(R, app.ModelRef(model="org/beta", version="v7", scope="all"))
+check("v7 score gone",  "v7/org/results_beta.json" in FILES["Mushari440/results"], False)
+check("request gone",   "org/beta.json" in REQ, False)
+
+print("\nrequeue only_missing skips models already scored on the target version")
+FILES["Mushari440/results"] = {"v7/org/results_alpha.json", "v8/org/results_alpha.json"}
+REQ["org/alpha.json"] = {"model": "org/alpha", "status": "FINISHED"}
+REQ["org/delta.json"] = {"model": "org/delta", "status": "FINISHED"}
+out = app.requeue_all(R, app.RequeueRef(version="v8", only_missing=True))
+check("alpha skipped (already on v8)", "org/alpha" in out["skipped"], True)
+check("delta queued",                  "org/delta" in out["queued"], True)
+check("gamma skipped (already PENDING)", "org/gamma" in out["skipped"], True)
+check("delta status is RERUN",         REQ["org/delta.json"]["status"], "RERUN")
+
+print("\nrequeue only_missing=False re-queues scored models too")
+REQ["org/alpha.json"] = {"model": "org/alpha", "status": "FINISHED"}
+out = app.requeue_all(R, app.RequeueRef(version="v8", only_missing=False))
+check("alpha queued this time", "org/alpha" in out["queued"], True)
+
+print("\nFAILURES:", fails or "none")
+sys.exit(1 if fails else 0)