adding details

app.py

@@ -6,7 +6,13 @@ from contextlib import asynccontextmanager
 from apscheduler.schedulers.background import BackgroundScheduler
 import logging
 
-from backend.data_loader import download_dataset_snapshots, load_scoreboard, load_requests
+from backend.data_loader import (
+    download_dataset_snapshots,
+    load_scoreboard,
+    load_requests,
+    build_details_index,
+    load_benchmark_details,
+)
 from backend.submission_handler import submit_model
 from backend.config import TASKS, API, hf_api_token
 from fastapi import FastAPI, Request, Form, BackgroundTasks, HTTPException
@@ -17,6 +23,7 @@ logging.getLogger("apscheduler").setLevel(logging.WARNING)
 # --- Global Cache Variables ---
 GLOBAL_LEADERBOARD_DATA = []
 GLOBAL_QUEUE_DATA = {}
+GLOBAL_DETAILS_INDEX = {}
 
 ACCEPTED_PAGES = ["about.html", "header.html", "leaderboard.html", "submit.html"]
 
@@ -84,6 +91,15 @@ def update_queue_cache():
     except Exception as e:
         logging.error(f"❌ Error updating queue cache: {e}")
 
+
+def update_details_cache():
+    """Builds details-parquet index and updates the global variable."""
+    global GLOBAL_DETAILS_INDEX
+    try:
+        GLOBAL_DETAILS_INDEX = build_details_index()
+    except Exception as e:
+        logging.error(f"❌ Error updating details cache: {e}")
+
 # --- Lifespan & Scheduler ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -91,6 +107,7 @@ async def lifespan(app: FastAPI):
     download_dataset_snapshots()
     update_leaderboard_cache()
     update_queue_cache()
+    update_details_cache()
     
     # 2. Schedule periodic updates
     scheduler = BackgroundScheduler()
@@ -101,6 +118,7 @@ async def lifespan(app: FastAPI):
     # Cache updates (every 10 mins)
     scheduler.add_job(update_leaderboard_cache, "interval", minutes=10)
     scheduler.add_job(update_queue_cache, "interval", minutes=10)
+    scheduler.add_job(update_details_cache, "interval", minutes=10)
     
     scheduler.start()
     
@@ -143,6 +161,26 @@ async def get_model_likes(
         logging.error(f"Error fetching likes for {model_name}: {e}")
         return JSONResponse(content={"error": str(e)}, status_code=400)
 
+
+@app.post("/api/benchmark-details")
+async def get_benchmark_details(
+    model_name: str = Form(...),
+    benchmark: str = Form(...),
+):
+    """Fetches per-question details for a specific model benchmark score."""
+    try:
+        if not GLOBAL_DETAILS_INDEX:
+            update_details_cache()
+        payload = load_benchmark_details(
+            model_name=model_name,
+            benchmark_display=benchmark,
+            details_index=GLOBAL_DETAILS_INDEX,
+        )
+        return JSONResponse(content=payload)
+    except Exception as e:
+        logging.error(f"Error fetching benchmark details for {model_name}/{benchmark}: {e}")
+        return JSONResponse(content={"error": str(e)}, status_code=400)
+
 @app.post("/api/submit")
 async def handle_submission(
     model_name: str = Form(...),

backend/config.py

@@ -7,6 +7,7 @@ OWNER: str = "qimma"
 REPO_ID: str = f"{OWNER}/Qimma-Leaderboard"
 RESULTS_REPO_ID: str = f"{OWNER}/leaderboard-results"
 REQUESTS_REPO_ID: str = f"{OWNER}/leaderboard-requests"
+DETAILS_REPO_ID: str = f"{OWNER}/leaderboard-details"
 
 SLACK_WEBHOOK_URL = os.getenv("SLACK_WEBHOOK_URL", "")
 

backend/data_loader.py

@@ -5,16 +5,22 @@ import os
 import contextlib
 import io
 import logging
+import re
+import ast
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import Dict, List, Any, Optional
+from urllib.parse import quote
 
 import numpy as np
 import pandas as pd
+import requests
 from huggingface_hub import snapshot_download
 from datetime import datetime
+from huggingface_hub.constants import HF_HUB_CACHE
 from backend.config import (
     API,
+    DETAILS_REPO_ID,
     REQUESTS_REPO_ID,
     RESULTS_REPO_ID,
     TASKS,
@@ -37,15 +43,136 @@ _TASKS_BY_SOURCE = {
 }
 
 
+def _extract_task_bases(task_key: Any) -> List[str]:
+    if isinstance(task_key, list):
+        bases: List[str] = []
+        for item in task_key:
+            bases.extend(_extract_task_bases(item))
+        return bases
+
+    if not isinstance(task_key, str):
+        return []
+
+    key = task_key.strip()
+    if not key:
+        return []
+
+    return [key.split(":", 1)[0].split("|", 1)[0].strip()]
+
+
+BENCHMARK_DISPLAY_TO_BASES: Dict[str, List[str]] = {}
+for task_key, _, display in TASKS:
+    bases = BENCHMARK_DISPLAY_TO_BASES.setdefault(display, [])
+    for base in _extract_task_bases(task_key):
+        if base and base not in bases:
+            bases.append(base)
+
+
 # -----------------------------------------------------------------------------
 # Utilities
 # -----------------------------------------------------------------------------
 
 def silent_snapshot_download(**kwargs):
-    with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
+    # with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
         return snapshot_download(**kwargs)
 
 
+def _resolve_details_base_path() -> Path:
+    repo_cache_root = Path(HF_HUB_CACHE) / f"datasets--{DETAILS_REPO_ID.replace('/', '--')}"
+    snapshots_root = repo_cache_root / "snapshots"
+    if snapshots_root.exists():
+        candidates = [p for p in snapshots_root.iterdir() if p.is_dir()]
+        if candidates:
+            return max(candidates, key=lambda p: p.stat().st_mtime)
+
+    manual_root = repo_cache_root / "manual-snapshot"
+    manual_root.mkdir(parents=True, exist_ok=True)
+    return manual_root
+
+
+def _download_details_file(relative_path: str, base_path: Path, retries: int = 3) -> bool:
+    encoded_rel_path = quote(relative_path, safe="/")
+    url = f"https://huggingface.co/datasets/{DETAILS_REPO_ID}/resolve/main/{encoded_rel_path}"
+    headers = {}
+    if hf_api_token:
+        headers["Authorization"] = f"Bearer {hf_api_token}"
+
+    target_path = base_path / relative_path
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    partial_path = target_path.with_suffix(target_path.suffix + ".part")
+
+    for attempt in range(1, retries + 1):
+        try:
+            with requests.get(url, stream=True, timeout=(10, 90), headers=headers) as resp:
+                resp.raise_for_status()
+                with open(partial_path, "wb") as f:
+                    for chunk in resp.iter_content(chunk_size=1024 * 1024):
+                        if chunk:
+                            f.write(chunk)
+            os.replace(partial_path, target_path)
+            return True
+        except Exception as e:
+            with contextlib.suppress(Exception):
+                partial_path.unlink(missing_ok=True)
+            logger.warning(
+                "Retry %s/%s for details file '%s' failed: %s",
+                attempt,
+                retries,
+                relative_path,
+                e,
+            )
+    return False
+
+
+def _sync_details_dataset(base_path: Path):
+    try:
+        remote_files = [
+            f for f in API.list_repo_files(repo_id=DETAILS_REPO_ID, repo_type="dataset")
+            if f.endswith(".parquet")
+        ]
+    except Exception as e:
+        logger.warning("Could not list files for details repo '%s': %s", DETAILS_REPO_ID, e)
+        return
+
+    local_files = {
+        str(p.relative_to(base_path)).replace(os.sep, "/")
+        for p in base_path.rglob("*.parquet")
+    }
+    missing_files = [f for f in remote_files if f not in local_files]
+
+    total_count = len(remote_files)
+    local_count = len(local_files)
+    if not missing_files:
+        logger.info("Details files ready: %s/%s", local_count, total_count)
+        return
+
+    logger.info(
+        "Details files ready: %s/%s. Downloading %s missing files...",
+        local_count,
+        total_count,
+        len(missing_files),
+    )
+
+    failed_files: List[str] = []
+    total_missing = len(missing_files)
+    for idx, rel_path in enumerate(missing_files, start=1):
+        logger.info("Downloading missing details file %s/%s: %s", idx, total_missing, rel_path)
+        if not _download_details_file(rel_path, base_path):
+            failed_files.append(rel_path)
+
+    if failed_files:
+        logger.warning(
+            "Details sync incomplete. Downloaded %s/%s missing files. Still missing %s files.",
+            total_missing - len(failed_files),
+            total_missing,
+            len(failed_files),
+        )
+        for rel_path in failed_files:
+            logger.warning("Still missing: %s", rel_path)
+    else:
+        logger.info("Details sync complete: downloaded %s/%s missing files.", total_missing, total_missing)
+
+
 def download_datasets():
     """
     Download requests + results datasets (read-only, anonymous).
@@ -64,6 +191,10 @@ def download_datasets():
     )
     os.environ["EVAL_RESULTS_PATH"] = res_path
 
+    details_base = _resolve_details_base_path()
+    _sync_details_dataset(details_base)
+    os.environ["EVAL_DETAILS_PATH"] = str(details_base)
+
 
 # -----------------------------------------------------------------------------
 # Requests
@@ -154,6 +285,305 @@ def _parse_result_file(path: Path) -> Optional[Dict[str, Any]]:
     return row
 
 
+def _parse_details_filename(path: Path) -> Optional[Dict[str, Any]]:
+    stem = path.stem
+    if "_" not in stem:
+        return None
+
+    details_part, dt_str = stem.rsplit("_", 1)
+    if not details_part.startswith("details_"):
+        return None
+
+    try:
+        parsed_dt = datetime.strptime(dt_str, "%Y-%m-%dT%H-%M-%S.%f")
+    except Exception:
+        return None
+
+    task_full = details_part[len("details_"):].strip()
+    if not task_full:
+        return None
+
+    benchmark_base = task_full.split(":", 1)[0].split("|", 1)[0].strip()
+    if ":" in task_full:
+        subtask = task_full.split(":", 1)[1].strip()
+    else:
+        subtask = benchmark_base
+
+    subtask = re.sub(r"\|\d+$", "", subtask).strip() or "overall"
+
+    return {
+        "benchmark_base": benchmark_base,
+        "subtask": subtask,
+        "datetime": parsed_dt,
+        "task_full": task_full,
+    }
+
+
+def build_details_index() -> Dict[str, Dict[str, Dict[str, Dict[str, Any]]]]:
+    """
+    Build an index of latest detail parquet paths per model/benchmark/subtask.
+    """
+    details_base = os.getenv("EVAL_DETAILS_PATH")
+    if not details_base:
+        return {}
+
+    base_path = Path(details_base)
+    if not base_path.exists():
+        return {}
+
+    index: Dict[str, Dict[str, Dict[str, Dict[str, Any]]]] = {}
+
+    for p in base_path.rglob("*.parquet"):
+        parsed = _parse_details_filename(p)
+        if not parsed:
+            continue
+
+        try:
+            rel_parts = p.relative_to(base_path).parts
+        except Exception:
+            continue
+        if len(rel_parts) < 2:
+            continue
+
+        model_name = "/".join(rel_parts[:-1]).strip("/")
+        if not model_name:
+            continue
+
+        benchmark_base = parsed["benchmark_base"]
+        subtask = parsed["subtask"]
+        dt = parsed["datetime"]
+
+        model_bucket = index.setdefault(model_name, {})
+        bench_bucket = model_bucket.setdefault(benchmark_base, {})
+        current = bench_bucket.get(subtask)
+        if current is None or dt > current["datetime"]:
+            bench_bucket[subtask] = {
+                "path": str(p),
+                "datetime": dt,
+                "task_full": parsed["task_full"],
+            }
+
+    return index
+
+
+def _as_list(value: Any) -> List[Any]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    if isinstance(value, tuple):
+        return list(value)
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    return [value]
+
+
+def _as_dict(value: Any) -> Dict[str, Any]:
+    if isinstance(value, dict):
+        return value
+
+    if isinstance(value, (bytes, bytearray)):
+        try:
+            value = value.decode("utf-8", errors="ignore")
+        except Exception:
+            return {}
+
+    if isinstance(value, str):
+        s = value.strip()
+        if not s:
+            return {}
+        try:
+            parsed = json.loads(s)
+            return parsed if isinstance(parsed, dict) else {}
+        except Exception:
+            try:
+                parsed = ast.literal_eval(s)
+                return parsed if isinstance(parsed, dict) else {}
+            except Exception:
+                return {}
+
+    if isinstance(value, list):
+        # Some parquet backends can expose map-like structs as list of pairs.
+        try:
+            if all(isinstance(item, (list, tuple)) and len(item) == 2 for item in value):
+                return {str(k): v for k, v in value}
+        except Exception:
+            return {}
+
+    return {}
+
+
+def _py_scalar(value: Any) -> Any:
+    if isinstance(value, np.generic):
+        return value.item()
+    return value
+
+
+def _extract_predicted_answer(model_response: Dict[str, Any], choices: List[Any]) -> Any:
+    logprobs = model_response.get("logprobs")
+    if logprobs is not None and choices:
+        values = _as_list(logprobs)
+        try:
+            idx = int(np.argmax(np.asarray(values, dtype=float)))
+            if 0 <= idx < len(choices):
+                return choices[idx]
+        except Exception:
+            pass
+
+    text_post_processed = _as_list(model_response.get("text_post_processed"))
+    if text_post_processed:
+        return text_post_processed[0]
+
+    text = _as_list(model_response.get("text"))
+    if text:
+        return text[0]
+
+    return None
+
+
+def _first_non_empty(values: Any) -> Optional[str]:
+    for v in _as_list(values):
+        if v is None:
+            continue
+        s = str(v).strip()
+        if s:
+            return s
+    return None
+
+
+def _read_detail_parquet(path: str, subtask: str) -> List[Dict[str, Any]]:
+    try:
+        df = pd.read_parquet(path)
+    except Exception as e:
+        logger.warning("Could not read details parquet '%s': %s", path, e)
+        return []
+
+    rows: List[Dict[str, Any]] = []
+    for record in df.to_dict(orient="records"):
+        doc = _as_dict(record.get("doc"))
+        metric = _as_dict(record.get("metric"))
+        model_response = _as_dict(record.get("model_response"))
+
+        choices = _as_list(doc.get("choices"))
+        choices = [_py_scalar(c) for c in choices]
+        gold_idx = doc.get("gold_index")
+        gold_answer = None
+        if isinstance(gold_idx, (int, np.integer)) and 0 <= int(gold_idx) < len(choices):
+            gold_answer = choices[int(gold_idx)]
+
+        metric_value = None
+        metric_name = None
+        if isinstance(metric, dict) and metric:
+            metric_name = next(iter(metric.keys()))
+            try:
+                metric_value = float(next(iter(metric.values())))
+            except Exception:
+                metric_value = None
+
+        model_response_dict = model_response if isinstance(model_response, dict) else {}
+        predicted_answer = _extract_predicted_answer(model_response_dict, choices)
+        output_text = _first_non_empty(model_response_dict.get("text_post_processed"))
+        if output_text is None:
+            output_text = _first_non_empty(model_response_dict.get("text"))
+        if output_text is None and predicted_answer is not None:
+            output_text = str(predicted_answer)
+
+        is_correct = None
+        if metric_value is not None and metric_value in (0.0, 1.0):
+            is_correct = bool(metric_value)
+
+        prompt = (
+            doc.get("query")
+            or doc.get("original_query")
+            or doc.get("instruction")
+            or model_response_dict.get("input")
+            or ""
+        )
+
+        rows.append({
+            "subtask": subtask,
+            "question_id": _py_scalar(doc.get("id")),
+            "task_name": _py_scalar(doc.get("task_name")),
+            "prompt": prompt,
+            "input_prompt": model_response_dict.get("input"),
+            "output": output_text,
+            "choices": [str(c) for c in choices],
+            "gold_answer": _py_scalar(gold_answer),
+            "predicted_answer": _py_scalar(predicted_answer),
+            "is_correct": is_correct,
+            "metric_name": metric_name,
+            "metric": metric_value,
+        })
+
+    return rows
+
+
+def load_benchmark_details(
+    model_name: str,
+    benchmark_display: str,
+    details_index: Dict[str, Dict[str, Dict[str, Dict[str, Any]]]],
+    max_rows: int = 250,
+) -> Dict[str, Any]:
+    """
+    Load per-question benchmark details for a model from indexed parquet files.
+    """
+    model_bucket = details_index.get(model_name, {})
+    if not model_bucket:
+        target_model = model_name.strip().lower()
+        for indexed_model, bucket in details_index.items():
+            if indexed_model.strip().lower() == target_model:
+                model_bucket = bucket
+                break
+
+    benchmark_bases = BENCHMARK_DISPLAY_TO_BASES.get(benchmark_display, [])
+    if not benchmark_bases:
+        benchmark_bases = [benchmark_display]
+
+    selected_entries: List[tuple[str, Dict[str, Any]]] = []
+    for base in benchmark_bases:
+        subtasks = model_bucket.get(base, {})
+        if not subtasks:
+            base_l = base.strip().lower()
+            for indexed_base, bucket in model_bucket.items():
+                if indexed_base.strip().lower() == base_l:
+                    subtasks = bucket
+                    break
+        for subtask, info in subtasks.items():
+            selected_entries.append((subtask, info))
+
+    if not selected_entries:
+        return {"benchmark": benchmark_display, "subtasks": [], "rows": []}
+
+    selected_entries.sort(key=lambda x: x[0].lower())
+
+    all_rows: List[Dict[str, Any]] = []
+    subtasks_summary: List[Dict[str, Any]] = []
+    for subtask, info in selected_entries:
+        rows = _read_detail_parquet(info["path"], subtask)
+        all_rows.extend(rows)
+
+        valid = [r for r in rows if isinstance(r.get("is_correct"), bool)]
+        correct = sum(1 for r in valid if r["is_correct"])
+        total = len(valid)
+        accuracy = round((correct / total) * 100, 2) if total > 0 else None
+        subtasks_summary.append({
+            "subtask": subtask,
+            "total": len(rows),
+            "scored": total,
+            "correct": correct,
+            "accuracy": accuracy,
+        })
+
+    if len(all_rows) > max_rows:
+        all_rows = all_rows[:max_rows]
+
+    return {
+        "benchmark": benchmark_display,
+        "subtasks": subtasks_summary,
+        "rows": all_rows,
+    }
+
+
 def _fetch_hf_metadata(model_name: str) -> Dict[str, Any]:
     try:
         info = API.model_info(repo_id=model_name, token=hf_api_token)

frontend/leaderboard.html

@@ -546,6 +546,48 @@
         </div>
     </div>
 
+    <div id="benchmarkModal" class="hidden fixed inset-0 z-[110]" aria-labelledby="benchmark-modal-title" role="dialog"
+        aria-modal="true">
+        <div class="fixed inset-0 bg-slate-900/60 backdrop-blur-sm transition-opacity modal-backdrop"
+            onclick="window.closeBenchmarkDetails()"></div>
+
+        <div
+            class="fixed top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 z-[111] w-[95%] md:w-[75%] max-h-[90vh] overflow-y-auto bg-white dark:bg-slate-900 rounded-2xl shadow-2xl border border-slate-200 dark:border-slate-700 modal-content">
+            <div
+                class="sticky top-0 z-10 flex items-start justify-between px-6 py-5 bg-white/80 dark:bg-slate-900/80 backdrop-blur-md border-b border-slate-100 dark:border-slate-800">
+                <div>
+                    <h3 id="benchmarkModalTitle"
+                        class="text-xl md:text-2xl font-bold text-slate-900 dark:text-white leading-tight break-words pr-4">
+                    </h3>
+                </div>
+                <button type="button" onclick="window.closeBenchmarkDetails()"
+                    class="text-slate-400 hover:text-slate-600 dark:hover:text-slate-300 transition-colors p-1 rounded-full hover:bg-slate-100 dark:hover:bg-slate-800">
+                    <i data-lucide="x" class="w-6 h-6"></i>
+                </button>
+            </div>
+
+            <div class="p-6 space-y-6">
+                <div id="benchmarkSummary" class="grid grid-cols-1 md:grid-cols-3 gap-3"></div>
+                <div class="border border-slate-200 dark:border-slate-700 rounded-xl overflow-hidden">
+                    <div
+                        class="grid grid-cols-12 text-xs font-bold uppercase tracking-wide bg-slate-50 dark:bg-slate-800 text-slate-500 dark:text-slate-400 px-4 py-3">
+                        <div class="col-span-2">Subtask</div>
+                        <div class="col-span-6">Prompt / Output</div>
+                        <div class="col-span-2">Gold</div>
+                        <div class="col-span-2">Predicted</div>
+                    </div>
+                    <div id="benchmarkRows" class="divide-y divide-slate-100 dark:divide-slate-800"></div>
+                </div>
+            </div>
+
+            <div
+                class="bg-slate-50 dark:bg-slate-800/50 px-6 py-4 border-t border-slate-100 dark:border-slate-800 text-center">
+                <button onclick="window.closeBenchmarkDetails()"
+                    class="text-sm text-slate-500 hover:text-slate-800 dark:hover:text-slate-200">Close Details</button>
+            </div>
+        </div>
+    </div>
+
     <script>
             (function () {
                 const $ = s => document.querySelector(s);
@@ -564,6 +606,12 @@
                     const n = toNumber(v);
                     return n === null ? "Unknown" : String(Math.floor(n));
                 };
+                const escapeHtml = (value) => String(value ?? "")
+                    .replace(/&/g, "&amp;")
+                    .replace(/</g, "&lt;")
+                    .replace(/>/g, "&gt;")
+                    .replace(/\"/g, "&quot;")
+                    .replace(/'/g, "&#039;");
 
                 let lbData = [], grid, maxMeta = 100, minMeta = 0, tableColumns = [];
                 let currentSort = { colId: null, dir: 'none' };
@@ -683,6 +731,81 @@
                     applyFilters();
                 }
 
+                // --- BENCHMARK DETAILS MODAL ---
+                window.openBenchmarkDetails = async function (modelName, benchmark) {
+                    $('#benchmarkModalTitle').innerText = `${benchmark} Details — ${modelName}`;
+                    $('#benchmarkSummary').innerHTML = "";
+                    $('#benchmarkRows').innerHTML = `<div class="p-6 text-sm text-slate-500 dark:text-slate-400">Loading details...</div>`;
+
+                    $('#benchmarkModal').classList.remove('hidden');
+                    document.body.style.overflow = 'hidden';
+                    if (window.lucide) lucide.createIcons();
+
+                    const formData = new FormData();
+                    formData.append("model_name", modelName);
+                    formData.append("benchmark", benchmark);
+
+                    try {
+                        const res = await fetch("/api/benchmark-details", { method: "POST", body: formData });
+                        const payload = await res.json();
+                        if (!res.ok) throw new Error(payload.error || "Failed to load details");
+
+                        const subtasks = payload.subtasks || [];
+                        const rows = payload.rows || [];
+
+                        if (!subtasks.length && !rows.length) {
+                            $('#benchmarkSummary').innerHTML = `<div class="col-span-full p-4 rounded-lg bg-slate-50 dark:bg-slate-800 text-sm text-slate-500 dark:text-slate-400">No details found for this benchmark/model.</div>`;
+                            $('#benchmarkRows').innerHTML = "";
+                            return;
+                        }
+
+                        $('#benchmarkSummary').innerHTML = subtasks.map(s => `
+                            <div class="p-3 rounded-lg border border-slate-200 dark:border-slate-700 bg-slate-50 dark:bg-slate-800/70">
+                                <div class="text-xs text-slate-500 dark:text-slate-400">${escapeHtml(s.subtask)}</div>
+                                <div class="text-sm font-bold text-slate-800 dark:text-slate-100 mt-1">${s.accuracy === null ? "Unknown" : `${s.accuracy}%`}</div>
+                                <div class="text-xs text-slate-500 dark:text-slate-400 mt-0.5">${s.correct}/${s.scored} correct</div>
+                            </div>
+                        `).join("");
+
+                        $('#benchmarkRows').innerHTML = rows.map(r => {
+                            const correctBadge = r.is_correct === true
+                                ? `<span class="text-emerald-600 dark:text-emerald-400 font-semibold">Correct</span>`
+                                : (r.is_correct === false
+                                    ? `<span class="text-rose-600 dark:text-rose-400 font-semibold">Wrong</span>`
+                                    : `<span class="text-slate-500 dark:text-slate-400 font-semibold">Unknown</span>`);
+                            const prompt = escapeHtml(asUnknown(r.prompt));
+                            const output = escapeHtml(asUnknown(r.output));
+                            const sampleMeta = [
+                                r.question_id ? `id: ${escapeHtml(r.question_id)}` : null,
+                                r.metric_name ? `metric: ${escapeHtml(r.metric_name)}` : null,
+                                r.metric !== null && r.metric !== undefined ? `score: ${escapeHtml(r.metric)}` : null,
+                            ].filter(Boolean).join(" | ");
+
+                            return `
+                                <div class="grid grid-cols-12 gap-3 px-4 py-3 text-xs">
+                                    <div class="col-span-2 text-slate-600 dark:text-slate-300">${escapeHtml(r.subtask)}</div>
+                                    <div class="col-span-6 text-slate-700 dark:text-slate-200">
+                                        <div class="font-semibold text-slate-800 dark:text-slate-100 whitespace-pre-wrap">${prompt}</div>
+                                        <div class="mt-2 text-slate-500 dark:text-slate-400 whitespace-pre-wrap"><span class="font-semibold">Output:</span> ${output}</div>
+                                        ${sampleMeta ? `<div class="mt-1 text-slate-400 dark:text-slate-500">${sampleMeta}</div>` : ``}
+                                        <div class="mt-1">${correctBadge}</div>
+                                    </div>
+                                    <div class="col-span-2 text-slate-600 dark:text-slate-300">${escapeHtml(asUnknown(r.gold_answer))}</div>
+                                    <div class="col-span-2 text-slate-600 dark:text-slate-300">${escapeHtml(asUnknown(r.predicted_answer))}</div>
+                                </div>
+                            `;
+                        }).join("");
+                    } catch (err) {
+                        $('#benchmarkSummary').innerHTML = "";
+                        $('#benchmarkRows').innerHTML = `<div class="p-6 text-sm text-rose-600 dark:text-rose-400">${escapeHtml(err.message || "Failed to load details")}</div>`;
+                    }
+                };
+
+                window.closeBenchmarkDetails = function () {
+                    $('#benchmarkModal').classList.add('hidden');
+                    document.body.style.overflow = '';
+                };
+
                 // --- MODAL LOGIC ---
                 window.openModelDetails = function (modelName) {
                     const model = lbData.find(r => r["Model Name"] === modelName);
@@ -910,6 +1033,7 @@
                 function prepareColumns(data) {
                     const keys = Object.keys(data[0] || {});
                     const typeIdx = keys.findIndex(k => ["T", "Type", "Full Type"].includes(k));
+                    const modelNameIdx = keys.findIndex(k => k === "Model Name");
                     const vis = tableColumns.reduce((acc, c) => ({ ...acc, [c.id]: c.hidden }), {});
 
                     tableColumns = keys.map(key => {
@@ -960,15 +1084,23 @@
                         } else if (isScore || isAvg) {
 
                             // -- NEW LOGIC FOR SCORE DISPLAY STATUS --
-                            const renderBar = (c) => {
+                            const renderBar = (c, modelName, benchmark) => {
                                 const n = parseFloat(c); if (isNaN(n)) return c;
                                 const h = (Math.max(0, Math.min(100, n)) / 100) * 120;
-                                return gridjs.html(`<div class="flex justify-center"><div style="background: linear-gradient(to right, hsla(${h},85%,50%,0.3) ${n}%, hsla(${h},85%,50%,0.05) ${n}%); border: 1px solid hsla(${h},85%,40%,0.3);" class="w-24 py-1 rounded-md text-center text-xs font-bold text-slate-700 dark:text-slate-200 shadow-sm">${n.toFixed(2)}<span class="text-[10px] font-normal opacity-70 ml-0.5">%</span></div></div>`);
+                                const bar = `<div class="flex justify-center"><div style="background: linear-gradient(to right, hsla(${h},85%,50%,0.3) ${n}%, hsla(${h},85%,50%,0.05) ${n}%); border: 1px solid hsla(${h},85%,40%,0.3);" class="w-24 py-1 rounded-md text-center text-xs font-bold text-slate-700 dark:text-slate-200 shadow-sm">${n.toFixed(2)}<span class="text-[10px] font-normal opacity-70 ml-0.5">%</span></div></div>`;
+                                if (!isScore || !modelName) return gridjs.html(bar);
+                                const em = encodeURIComponent(modelName);
+                                const eb = encodeURIComponent(benchmark);
+                                return gridjs.html(`<button onclick="window.openBenchmarkDetails(decodeURIComponent('${em}'), decodeURIComponent('${eb}'))" class="w-full text-left hover:opacity-90 transition-opacity" title="Click for per-question details">${bar}</button>`);
                             };
 
-                            const renderRaw = (c) => {
+                            const renderRaw = (c, modelName, benchmark) => {
                                 const n = parseFloat(c); if (isNaN(n)) return c;
-                                return gridjs.html(`<div class="flex justify-center text-xs font-bold text-slate-700 dark:text-slate-300 py-1">${n.toFixed(2)}</div>`);
+                                const raw = `<div class="flex justify-center text-xs font-bold text-slate-700 dark:text-slate-300 py-1">${n.toFixed(2)}</div>`;
+                                if (!isScore || !modelName) return gridjs.html(raw);
+                                const em = encodeURIComponent(modelName);
+                                const eb = encodeURIComponent(benchmark);
+                                return gridjs.html(`<button onclick="window.openBenchmarkDetails(decodeURIComponent('${em}'), decodeURIComponent('${eb}'))" class="w-full text-left hover:opacity-90 transition-opacity" title="Click for per-question details">${raw}</button>`);
                             };
 
                             let shouldUseBar = false;
@@ -981,7 +1113,10 @@
                                 shouldUseBar = false;
                             }
 
-                            def.formatter = shouldUseBar ? renderBar : renderRaw;
+                            def.formatter = (c, r) => {
+                                const modelName = (modelNameIdx > -1 && r.cells[modelNameIdx]) ? r.cells[modelNameIdx].data : "";
+                                return shouldUseBar ? renderBar(c, modelName, key) : renderRaw(c, modelName, key);
+                            };
 
                         } else if (key === "Rank") {
                             def.width = '110px';

requirements.txt

@@ -10,3 +10,5 @@ transformers==5.1.0
 Jinja2==3.1.6
 python-multipart==0.0.22
 tiktoken
+# fastparquet
+# pyarrow