Upload folder using huggingface_hub

README.md

@@ -68,6 +68,11 @@ export MODEL_NAME=qwen/qwen3.6-plus:free
 python inference.py --dataset-path dataset/py_tasks.csv --episodes-per-task 5
 ```
 
+### Run Inference From Space UI
+
+When deployed, the Space homepage serves a UI at `/` (also `/web`) that starts
+`inference.py` in the background and streams logs live.
+
 ### `inference.py` flags
 
 | Flag | Type | Default | Description |
@@ -75,10 +80,8 @@ python inference.py --dataset-path dataset/py_tasks.csv --episodes-per-task 5
 | `--dataset-path` | `str` | `dataset/py_tasks.csv` | Processed task CSV used by env |
 | `--episodes-per-task` | `int` | `5` | Episodes per selected task type |
 | `--task-types` | `str` | `classify,root_cause,fix_proposal` | Comma-separated task types |
-| `--no-progress` | bool | `False` | Disable progress bars |
-| `--trace-agent` | bool | `False` | Print model output, action/tool call, and step results |
-| `--trace-prompts` | bool | `False` | Also print prompts sent to the model |
-| `--trace-max-chars` | `int` | `2500` | Max chars per traced block |
+| `--max-steps` | `int` | `20` | Max steps per episode |
+| `--benchmark-name` | `str` | `flakysleuth` | Label printed in `[START]` logs |
 
 Trace to log:
 ```bash

server/app.py

@@ -1,16 +1,20 @@
 from __future__ import annotations
 
+from pathlib import Path
 from typing import Any
 
-from fastapi import Body, FastAPI, HTTPException
-from fastapi.responses import RedirectResponse
-from pydantic import BaseModel, ValidationError
+from fastapi import Body, FastAPI, HTTPException, Query
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel, Field, ValidationError
 
 from env.environment import FlakySleuthEnv
 from env.models import FlakySleuthAction, FlakySleuthObservation
+from server.inference_runner import InferenceRunner
+from server.ui import render_home_page
 
 app = FastAPI(title="FlakySleuth Environment")
 env = FlakySleuthEnv()
+inference_runner = InferenceRunner(Path(__file__).resolve().parent.parent)
 
 
 class FlakySleuthState(BaseModel):
@@ -22,6 +26,17 @@ class FlakySleuthState(BaseModel):
     cumulative_progress: float
 
 
+class InferenceRunRequest(BaseModel):
+    dataset_path: str = Field(default="dataset/py_tasks.csv")
+    episodes_per_task: int = Field(default=1, ge=1, le=50)
+    task_types: str = Field(default="classify,root_cause,fix_proposal")
+    max_steps: int = Field(default=20, ge=1, le=100)
+    benchmark_name: str = Field(default="flakysleuth")
+    api_base_url: str | None = None
+    model_name: str | None = None
+    api_key: str | None = None
+
+
 @app.post("/reset")
 def reset() -> dict[str, Any]:
     observation = env.reset()
@@ -74,13 +89,39 @@ def health() -> dict[str, str]:
 
 
 @app.get("/", include_in_schema=False)
-def root() -> RedirectResponse:
-    return RedirectResponse(url="/docs", status_code=307)
+def root() -> HTMLResponse:
+    return HTMLResponse(render_home_page())
 
 
 @app.get("/web", include_in_schema=False)
-def web() -> RedirectResponse:
-    return RedirectResponse(url="/docs", status_code=307)
+def web() -> HTMLResponse:
+    return HTMLResponse(render_home_page())
+
+
+@app.post("/web/inference/start", include_in_schema=False)
+def start_inference(payload: InferenceRunRequest) -> dict[str, Any]:
+    request_payload = payload.model_dump()
+    try:
+        return inference_runner.start(request_payload)
+    except FileNotFoundError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    except ValueError as exc:
+        raise HTTPException(status_code=422, detail=str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(status_code=409, detail=str(exc)) from exc
+
+
+@app.get("/web/inference/status", include_in_schema=False)
+def inference_status(tail: int = Query(default=450, ge=20, le=2000)) -> dict[str, Any]:
+    return inference_runner.snapshot(tail=tail)
+
+
+@app.post("/web/inference/stop", include_in_schema=False)
+def stop_inference() -> dict[str, Any]:
+    stopped = inference_runner.stop()
+    snapshot = inference_runner.snapshot(tail=450)
+    snapshot["stopped"] = stopped
+    return snapshot
 
 
 @app.get("/metadata")

server/inference_runner.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import threading
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class InferenceJob:
+    job_id: str
+    status: str
+    started_at: float
+    command: list[str]
+    config: dict[str, Any]
+    logs: list[str] = field(default_factory=list)
+    return_code: int | None = None
+    finished_at: float | None = None
+    error: str | None = None
+    stop_requested: bool = False
+    summaries: list[dict[str, Any]] = field(default_factory=list)
+
+
+class InferenceRunner:
+    """Run inference.py in the background and expose live status."""
+
+    def __init__(self, repo_root: Path):
+        self._repo_root = repo_root.resolve()
+        self._lock = threading.Lock()
+        self._job: InferenceJob | None = None
+        self._proc: subprocess.Popen[str] | None = None
+
+    def start(self, payload: dict[str, Any]) -> dict[str, Any]:
+        with self._lock:
+            if self._job and self._job.status in {"starting", "running"}:
+                raise RuntimeError("An inference run is already in progress.")
+
+        dataset_rel = str(payload.get("dataset_path", "dataset/py_tasks.csv")).strip()
+        episodes = int(payload.get("episodes_per_task", 1))
+        max_steps = int(payload.get("max_steps", 20))
+        task_types = str(payload.get("task_types", "classify,root_cause,fix_proposal")).strip()
+        benchmark_name = str(payload.get("benchmark_name", "flakysleuth")).strip()
+
+        if not dataset_rel:
+            raise ValueError("dataset_path must not be empty.")
+        if episodes < 1 or episodes > 50:
+            raise ValueError("episodes_per_task must be between 1 and 50.")
+        if max_steps < 1 or max_steps > 100:
+            raise ValueError("max_steps must be between 1 and 100.")
+        if not task_types:
+            raise ValueError("task_types must not be empty.")
+        if not benchmark_name:
+            raise ValueError("benchmark_name must not be empty.")
+
+        dataset_path = self._resolve_dataset_path(dataset_rel)
+        command = [
+            sys.executable,
+            "inference.py",
+            "--dataset-path",
+            os.path.relpath(dataset_path, self._repo_root),
+            "--episodes-per-task",
+            str(episodes),
+            "--task-types",
+            task_types,
+            "--max-steps",
+            str(max_steps),
+            "--benchmark-name",
+            benchmark_name,
+        ]
+
+        job = InferenceJob(
+            job_id=uuid.uuid4().hex[:12],
+            status="starting",
+            started_at=time.time(),
+            command=command,
+            config={
+                "dataset_path": os.path.relpath(dataset_path, self._repo_root),
+                "episodes_per_task": episodes,
+                "task_types": task_types,
+                "max_steps": max_steps,
+                "benchmark_name": benchmark_name,
+                "api_base_url": _clean_optional_text(payload.get("api_base_url")),
+                "model_name": _clean_optional_text(payload.get("model_name")),
+                "api_key_provided": bool(_clean_optional_text(payload.get("api_key"))),
+            },
+        )
+        self._append_log(job, f"[UI] Starting run {job.job_id}")
+        self._append_log(job, f"[UI] Command: {' '.join(command)}")
+
+        with self._lock:
+            self._job = job
+
+        worker = threading.Thread(
+            target=self._run_job,
+            args=(job, payload),
+            daemon=True,
+        )
+        worker.start()
+        return self.snapshot(tail=300)
+
+    def stop(self) -> bool:
+        with self._lock:
+            job = self._job
+            proc = self._proc
+            if not job or not proc or job.status not in {"starting", "running"}:
+                return False
+            job.stop_requested = True
+
+        if proc.poll() is None:
+            proc.terminate()
+            try:
+                proc.wait(timeout=8)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait(timeout=8)
+        return True
+
+    def snapshot(self, tail: int = 300) -> dict[str, Any]:
+        with self._lock:
+            if self._job is None:
+                return {
+                    "has_job": False,
+                    "status": "idle",
+                    "logs": [],
+                }
+
+            job = self._job
+            logs_tail = job.logs[-max(20, min(tail, 2000)) :]
+            return {
+                "has_job": True,
+                "job_id": job.job_id,
+                "status": job.status,
+                "started_at": job.started_at,
+                "finished_at": job.finished_at,
+                "return_code": job.return_code,
+                "error": job.error,
+                "config": job.config,
+                "command": job.command,
+                "summaries": job.summaries,
+                "logs": logs_tail,
+            }
+
+    def _run_job(self, job: InferenceJob, payload: dict[str, Any]) -> None:
+        env = os.environ.copy()
+        api_key = _clean_optional_text(payload.get("api_key"))
+        api_base_url = _clean_optional_text(payload.get("api_base_url"))
+        model_name = _clean_optional_text(payload.get("model_name"))
+
+        if api_key:
+            env["API_KEY"] = api_key
+        if api_base_url:
+            env["API_BASE_URL"] = api_base_url
+        if model_name:
+            env["MODEL_NAME"] = model_name
+
+        with self._lock:
+            job.status = "running"
+
+        process: subprocess.Popen[str] | None = None
+        try:
+            process = subprocess.Popen(
+                job.command,
+                cwd=self._repo_root,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                env=env,
+            )
+            with self._lock:
+                self._proc = process
+
+            assert process.stdout is not None
+            for raw_line in process.stdout:
+                line = raw_line.rstrip("\n")
+                if not line:
+                    continue
+                self._append_log(job, line)
+                summary = _parse_end_line(line)
+                if summary:
+                    with self._lock:
+                        job.summaries.append(summary)
+
+            return_code = process.wait()
+            extra_log: str | None = None
+            with self._lock:
+                job.return_code = return_code
+                job.finished_at = time.time()
+                if job.stop_requested:
+                    job.status = "stopped"
+                    extra_log = "[UI] Run stopped by user request."
+                elif return_code == 0:
+                    job.status = "completed"
+                else:
+                    job.status = "failed"
+                    extra_log = f"[UI] Process exited with code {return_code}."
+                self._proc = None
+            if extra_log:
+                self._append_log(job, extra_log)
+        except Exception as exc:
+            extra_log = f"[UI] Runner failed: {exc}"
+            with self._lock:
+                job.error = str(exc)
+                job.finished_at = time.time()
+                job.status = "failed"
+                self._proc = None
+            self._append_log(job, extra_log)
+        finally:
+            if process and process.stdout:
+                process.stdout.close()
+
+    def _append_log(self, job: InferenceJob, line: str) -> None:
+        with self._lock:
+            job.logs.append(line)
+            if len(job.logs) > 3000:
+                del job.logs[: len(job.logs) - 3000]
+
+    def _resolve_dataset_path(self, dataset_path: str) -> Path:
+        candidate = Path(dataset_path)
+        if not candidate.is_absolute():
+            candidate = (self._repo_root / candidate).resolve()
+        else:
+            candidate = candidate.resolve()
+
+        # Keep data access bounded to the repository.
+        if os.path.commonpath([str(self._repo_root), str(candidate)]) != str(self._repo_root):
+            raise ValueError("dataset_path must point to a file inside the repository.")
+        if not candidate.exists():
+            raise FileNotFoundError(f"Dataset file not found: {dataset_path}")
+        if not candidate.is_file():
+            raise ValueError(f"dataset_path is not a file: {dataset_path}")
+        return candidate
+
+
+def _clean_optional_text(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    return text or None
+
+
+def _parse_end_line(line: str) -> dict[str, Any] | None:
+    # Example:
+    # [END] success=true steps=3 score=1.00 rewards=0.00,0.20,1.00
+    if not line.startswith("[END] "):
+        return None
+
+    payload: dict[str, str] = {}
+    for token in line[len("[END] ") :].split(" "):
+        if "=" not in token:
+            continue
+        key, value = token.split("=", 1)
+        payload[key.strip()] = value.strip()
+
+    if "success" not in payload or "steps" not in payload or "score" not in payload:
+        return None
+
+    rewards_raw = payload.get("rewards", "")
+    rewards: list[float] = []
+    for token in rewards_raw.split(","):
+        token = token.strip()
+        if not token:
+            continue
+        try:
+            rewards.append(float(token))
+        except ValueError:
+            continue
+
+    try:
+        return {
+            "success": payload["success"].lower() == "true",
+            "steps": int(payload["steps"]),
+            "score": float(payload["score"]),
+            "rewards": rewards,
+        }
+    except Exception:
+        return None

server/ui.py

@@ -0,0 +1,521 @@
+from __future__ import annotations
+
+
+def render_home_page() -> str:
+    return """
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>FlakySleuth Run Studio</title>
+  <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=Space+Grotesk:wght@500;600;700&family=IBM+Plex+Mono:wght@400;500&display=swap" rel="stylesheet" />
+  <style>
+    :root {
+      --bg-top: #edf7f1;
+      --bg-bottom: #d2ead8;
+      --ink: #17211d;
+      --muted: #4c6359;
+      --accent: #0f8b63;
+      --accent-2: #e5783b;
+      --panel: rgba(255, 255, 255, 0.86);
+      --border: rgba(15, 139, 99, 0.22);
+      --card-shadow: 0 22px 46px rgba(14, 51, 37, 0.16);
+      --display: "Space Grotesk", "Avenir Next", "Segoe UI", sans-serif;
+      --mono: "IBM Plex Mono", "SFMono-Regular", Consolas, monospace;
+    }
+
+    * {
+      box-sizing: border-box;
+    }
+
+    body {
+      margin: 0;
+      color: var(--ink);
+      font-family: var(--display);
+      min-height: 100vh;
+      background:
+        radial-gradient(circle at 12% 16%, rgba(230, 120, 59, 0.16), transparent 42%),
+        radial-gradient(circle at 86% 12%, rgba(15, 139, 99, 0.2), transparent 40%),
+        linear-gradient(164deg, var(--bg-top), var(--bg-bottom));
+      animation: backdropFade 700ms ease-out;
+    }
+
+    @keyframes backdropFade {
+      from { opacity: 0; transform: translateY(4px); }
+      to { opacity: 1; transform: translateY(0); }
+    }
+
+    .shell {
+      max-width: 1100px;
+      margin: 24px auto;
+      padding: 0 16px 24px;
+      display: grid;
+      gap: 16px;
+    }
+
+    .hero {
+      border: 1px solid var(--border);
+      background: var(--panel);
+      border-radius: 20px;
+      box-shadow: var(--card-shadow);
+      padding: 22px 22px 18px;
+      animation: slideIn 500ms ease-out;
+    }
+
+    @keyframes slideIn {
+      from { opacity: 0; transform: translateY(12px); }
+      to { opacity: 1; transform: translateY(0); }
+    }
+
+    .eyebrow {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      font-size: 12px;
+      color: var(--muted);
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+    }
+
+    .dot {
+      width: 10px;
+      height: 10px;
+      border-radius: 50%;
+      background: var(--accent);
+      box-shadow: 0 0 0 6px rgba(15, 139, 99, 0.15);
+    }
+
+    h1 {
+      margin: 10px 0 8px;
+      font-size: clamp(1.6rem, 2.6vw, 2.35rem);
+      line-height: 1.1;
+      letter-spacing: -0.02em;
+    }
+
+    .hero p {
+      margin: 0;
+      color: var(--muted);
+      max-width: 760px;
+      line-height: 1.5;
+    }
+
+    .panel-grid {
+      display: grid;
+      grid-template-columns: 1fr;
+      gap: 16px;
+    }
+
+    .panel {
+      border: 1px solid var(--border);
+      background: var(--panel);
+      border-radius: 20px;
+      box-shadow: var(--card-shadow);
+      padding: 18px;
+      animation: slideIn 560ms ease-out;
+    }
+
+    .panel h2 {
+      margin: 0 0 12px;
+      font-size: 1.1rem;
+      letter-spacing: -0.01em;
+    }
+
+    .form-grid {
+      display: grid;
+      gap: 12px;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+    }
+
+    .field {
+      display: grid;
+      gap: 6px;
+    }
+
+    .field.span-2 {
+      grid-column: span 2;
+    }
+
+    label {
+      font-size: 13px;
+      color: var(--muted);
+    }
+
+    input {
+      width: 100%;
+      border: 1px solid rgba(18, 88, 63, 0.22);
+      border-radius: 10px;
+      padding: 10px 11px;
+      font: 500 14px/1.2 var(--mono);
+      color: var(--ink);
+      background: rgba(255, 255, 255, 0.92);
+      transition: border-color 180ms ease, box-shadow 180ms ease;
+    }
+
+    input:focus {
+      outline: none;
+      border-color: var(--accent);
+      box-shadow: 0 0 0 4px rgba(15, 139, 99, 0.14);
+    }
+
+    .actions {
+      margin-top: 6px;
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+    }
+
+    button {
+      border: 0;
+      border-radius: 11px;
+      font: 600 14px/1 var(--display);
+      padding: 11px 14px;
+      cursor: pointer;
+      transition: transform 180ms ease, opacity 180ms ease, filter 180ms ease;
+    }
+
+    button:hover {
+      transform: translateY(-1px);
+    }
+
+    button:disabled {
+      opacity: 0.55;
+      cursor: not-allowed;
+      transform: none;
+    }
+
+    .btn-run {
+      background: var(--accent);
+      color: #fff;
+    }
+
+    .btn-stop {
+      background: #f2b38f;
+      color: #431d05;
+    }
+
+    .btn-docs {
+      background: #dce8e1;
+      color: #234437;
+      text-decoration: none;
+      display: inline-flex;
+      align-items: center;
+      border-radius: 11px;
+      padding: 11px 14px;
+      font: 600 14px/1 var(--display);
+    }
+
+    .status-row {
+      display: grid;
+      grid-template-columns: 1fr;
+      gap: 10px;
+    }
+
+    .pill {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      width: fit-content;
+      border-radius: 999px;
+      padding: 6px 11px;
+      font: 600 13px/1 var(--display);
+      background: #e1ece6;
+      color: #2d4b3e;
+    }
+
+    .pill .status-dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: #60756a;
+    }
+
+    .pill.running .status-dot {
+      background: var(--accent);
+      box-shadow: 0 0 0 7px rgba(15, 139, 99, 0.12);
+    }
+
+    .pill.failed .status-dot {
+      background: #af4020;
+    }
+
+    .pill.completed .status-dot {
+      background: #1d724e;
+    }
+
+    .pill.stopped .status-dot {
+      background: var(--accent-2);
+    }
+
+    .meta {
+      display: grid;
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+      gap: 8px;
+      font: 500 12px/1.4 var(--mono);
+      color: #2f4f43;
+    }
+
+    .meta strong {
+      color: #193428;
+    }
+
+    .log-wrap {
+      margin-top: 8px;
+      border-radius: 14px;
+      border: 1px solid rgba(20, 66, 50, 0.2);
+      overflow: hidden;
+      background: #0f1a16;
+    }
+
+    .log-head {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      color: #b7d5c8;
+      font: 500 12px/1 var(--mono);
+      padding: 10px 12px;
+      border-bottom: 1px solid rgba(170, 208, 193, 0.16);
+      background: #13201b;
+    }
+
+    pre {
+      margin: 0;
+      padding: 12px;
+      color: #d8f3e7;
+      font: 400 12.5px/1.45 var(--mono);
+      max-height: 360px;
+      overflow: auto;
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+
+    .help {
+      margin-top: 8px;
+      color: #37594b;
+      font-size: 12px;
+      line-height: 1.45;
+    }
+
+    @media (max-width: 880px) {
+      .form-grid {
+        grid-template-columns: 1fr;
+      }
+
+      .field.span-2 {
+        grid-column: span 1;
+      }
+
+      .meta {
+        grid-template-columns: 1fr;
+      }
+    }
+  </style>
+</head>
+<body>
+  <main class="shell">
+    <section class="hero">
+      <span class="eyebrow"><span class="dot"></span>FlakySleuth Space</span>
+      <h1>Run Inference From The Browser</h1>
+      <p>Launch <code>inference.py</code>, monitor stdout live, and inspect episode summaries without leaving this Space. The API endpoints for OpenEnv stay available at the same time.</p>
+    </section>
+
+    <section class="panel-grid">
+      <div class="panel">
+        <h2>Run Configuration</h2>
+        <form id="run-form" class="form-grid">
+          <div class="field span-2">
+            <label for="dataset_path">Dataset Path</label>
+            <input id="dataset_path" name="dataset_path" value="dataset/py_tasks.csv" />
+          </div>
+
+          <div class="field">
+            <label for="episodes_per_task">Episodes Per Task</label>
+            <input id="episodes_per_task" name="episodes_per_task" type="number" min="1" max="50" value="1" />
+          </div>
+
+          <div class="field">
+            <label for="max_steps">Max Steps</label>
+            <input id="max_steps" name="max_steps" type="number" min="1" max="100" value="20" />
+          </div>
+
+          <div class="field span-2">
+            <label for="task_types">Task Types (comma-separated)</label>
+            <input id="task_types" name="task_types" value="classify,root_cause,fix_proposal" />
+          </div>
+
+          <div class="field span-2">
+            <label for="benchmark_name">Benchmark Label</label>
+            <input id="benchmark_name" name="benchmark_name" value="flakysleuth" />
+          </div>
+
+          <div class="field span-2">
+            <label for="api_base_url">API Base URL (optional)</label>
+            <input id="api_base_url" name="api_base_url" placeholder="https://api.openai.com/v1 or provider endpoint" />
+          </div>
+
+          <div class="field">
+            <label for="model_name">Model Name (optional)</label>
+            <input id="model_name" name="model_name" placeholder="gpt-4o-mini, qwen/qwen3.6-plus:free, etc." />
+          </div>
+
+          <div class="field">
+            <label for="api_key">API Key (optional)</label>
+            <input id="api_key" name="api_key" type="password" placeholder="Uses server env vars if empty" />
+          </div>
+        </form>
+
+        <div class="actions">
+          <button id="btn-run" class="btn-run" type="button">Start Inference</button>
+          <button id="btn-stop" class="btn-stop" type="button">Stop Run</button>
+          <a class="btn-docs" href="/docs" target="_blank" rel="noreferrer">Open API Docs</a>
+        </div>
+        <p class="help">Tip: if no API key is provided, <code>inference.py</code> falls back to its heuristic agent.</p>
+      </div>
+
+      <div class="panel">
+        <h2>Run Status</h2>
+        <div class="status-row">
+          <div id="status-pill" class="pill"><span class="status-dot"></span><span id="status-text">idle</span></div>
+          <div class="meta">
+            <div><strong>Job ID:</strong> <span id="meta-job-id">-</span></div>
+            <div><strong>Return Code:</strong> <span id="meta-return-code">-</span></div>
+            <div><strong>Started:</strong> <span id="meta-started">-</span></div>
+            <div><strong>Finished:</strong> <span id="meta-finished">-</span></div>
+          </div>
+          <div class="log-wrap">
+            <div class="log-head">
+              <span>Live Logs</span>
+              <span id="log-count">0 lines</span>
+            </div>
+            <pre id="log-output">No run started yet.</pre>
+          </div>
+          <div class="help" id="summary-line"></div>
+        </div>
+      </div>
+    </section>
+  </main>
+
+  <script>
+    const form = document.getElementById("run-form");
+    const runButton = document.getElementById("btn-run");
+    const stopButton = document.getElementById("btn-stop");
+    const statusPill = document.getElementById("status-pill");
+    const statusText = document.getElementById("status-text");
+    const jobIdEl = document.getElementById("meta-job-id");
+    const returnCodeEl = document.getElementById("meta-return-code");
+    const startedEl = document.getElementById("meta-started");
+    const finishedEl = document.getElementById("meta-finished");
+    const logEl = document.getElementById("log-output");
+    const logCountEl = document.getElementById("log-count");
+    const summaryEl = document.getElementById("summary-line");
+
+    function readFormPayload() {
+      return {
+        dataset_path: form.dataset_path.value.trim(),
+        episodes_per_task: Number(form.episodes_per_task.value),
+        task_types: form.task_types.value.trim(),
+        max_steps: Number(form.max_steps.value),
+        benchmark_name: form.benchmark_name.value.trim(),
+        api_base_url: form.api_base_url.value.trim() || null,
+        model_name: form.model_name.value.trim() || null,
+        api_key: form.api_key.value.trim() || null,
+      };
+    }
+
+    function formatTime(epoch) {
+      if (!epoch) return "-";
+      try {
+        return new Date(epoch * 1000).toLocaleString();
+      } catch (_) {
+        return "-";
+      }
+    }
+
+    function setStatus(status) {
+      const normalized = (status || "idle").toLowerCase();
+      statusPill.classList.remove("running", "failed", "completed", "stopped");
+      if (["running", "failed", "completed", "stopped"].includes(normalized)) {
+        statusPill.classList.add(normalized);
+      }
+      statusText.textContent = normalized;
+      runButton.disabled = normalized === "running" || normalized === "starting";
+      stopButton.disabled = !(normalized === "running" || normalized === "starting");
+    }
+
+    function renderSummary(summaries) {
+      if (!Array.isArray(summaries) || summaries.length === 0) {
+        summaryEl.textContent = "";
+        return;
+      }
+      const last = summaries[summaries.length - 1];
+      summaryEl.textContent = `Latest episode: success=${last.success} score=${last.score} steps=${last.steps}`;
+    }
+
+    function renderStatus(state) {
+      setStatus(state.status || "idle");
+      jobIdEl.textContent = state.job_id || "-";
+      returnCodeEl.textContent = state.return_code === null || state.return_code === undefined ? "-" : String(state.return_code);
+      startedEl.textContent = formatTime(state.started_at);
+      finishedEl.textContent = formatTime(state.finished_at);
+
+      const logs = Array.isArray(state.logs) ? state.logs : [];
+      logCountEl.textContent = `${logs.length} lines`;
+      logEl.textContent = logs.length ? logs.join("\\n") : "No logs yet.";
+      logEl.scrollTop = logEl.scrollHeight;
+
+      renderSummary(state.summaries || []);
+    }
+
+    async function fetchStatus() {
+      try {
+        const response = await fetch("/web/inference/status?tail=450", { method: "GET" });
+        if (!response.ok) return;
+        const state = await response.json();
+        renderStatus(state);
+      } catch (_) {}
+    }
+
+    async function startRun() {
+      runButton.disabled = true;
+      try {
+        const response = await fetch("/web/inference/start", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(readFormPayload()),
+        });
+
+        const payload = await response.json();
+        if (!response.ok) {
+          const detail = typeof payload.detail === "string" ? payload.detail : "Could not start inference.";
+          alert(detail);
+          return;
+        }
+        renderStatus(payload);
+      } catch (_) {
+        alert("Could not start inference. Check logs and try again.");
+      } finally {
+        form.api_key.value = "";
+      }
+    }
+
+    async function stopRun() {
+      stopButton.disabled = true;
+      try {
+        const response = await fetch("/web/inference/stop", { method: "POST" });
+        if (!response.ok) return;
+        const state = await response.json();
+        renderStatus(state);
+      } catch (_) {}
+    }
+
+    runButton.addEventListener("click", startRun);
+    stopButton.addEventListener("click", stopRun);
+
+    fetchStatus();
+    window.setInterval(fetchStatus, 2200);
+  </script>
+</body>
+</html>
+"""