feat: binary Y/N verdict; 2x2 layout; shared claim queue (no cross-annotator overlap)

app.py

@@ -1,8 +1,17 @@
 """MBench-V annotation UI (Gradio Space).
 
-Streams videos from `studyOverflow/TempMemoryData` (no local copy); writes
-annotations back to the same dataset repo under `annotations/`, batched via
-`CommitScheduler`.
+Streams videos from `studyOverflow/TempMemoryData`; writes annotations back to
+`annotations/` on the same repo (batched via `CommitScheduler`, every 5 min).
+
+Key design:
+  - Binary task: "Does this video exhibit a memory issue?" (Yes / No)
+  - No-overlap work queue: each (model, task_id) is claimed by at most one
+    annotator at a time.  Submitted items stay claimed forever; pending
+    claims expire after PENDING_TIMEOUT_MIN so a disconnected user doesn't
+    hold a task hostage.
+  - Per-session randomized full-pool shuffle, each annotator skips over
+    already-claimed items until they find their next fresh one.  So the
+    order they see is fully randomized and there is zero assignment logic.
 """
 
 from __future__ import annotations
@@ -10,13 +19,14 @@ from __future__ import annotations
 import json
 import os
 import random
+import threading
 import time
 import uuid
 from pathlib import Path
 from typing import Any
 
 import gradio as gr
-from huggingface_hub import CommitScheduler, hf_hub_download, hf_hub_url
+from huggingface_hub import CommitScheduler, HfApi, hf_hub_download, hf_hub_url
 
 # ---------------------------------------------------------------------------
 # Config
@@ -25,8 +35,6 @@ from huggingface_hub import CommitScheduler, hf_hub_download, hf_hub_url
 DATASET_REPO = "studyOverflow/TempMemoryData"
 MERGED_JSON_PATH = "MBench-V/merged.json"
 
-# 8 fully-reorganized models (584 videos each). All 8 models have complete
-# data as of 2026-05-01.
 MODELS: list[str] = [
     "causal_forcing",
     "self_forcing",
@@ -44,7 +52,9 @@ ANN_DIR = Path("annotations_local")
 ANN_DIR.mkdir(exist_ok=True)
 PROCESS_ID = uuid.uuid4().hex[:8]
 ANN_FILE = ANN_DIR / f"ann_{PROCESS_ID}.jsonl"
-COMMIT_INTERVAL_MIN = 5
+
+COMMIT_INTERVAL_MIN = 5         # CommitScheduler push period
+PENDING_TIMEOUT_SEC = 30 * 60   # a pending (claimed but unsubmitted) item expires after this
 
 
 # ---------------------------------------------------------------------------
@@ -53,10 +63,8 @@ COMMIT_INTERVAL_MIN = 5
 
 def _load_merged() -> list[dict[str, Any]]:
     local = hf_hub_download(
-        repo_id=DATASET_REPO,
-        filename=MERGED_JSON_PATH,
-        repo_type="dataset",
-        token=HF_TOKEN,
+        repo_id=DATASET_REPO, filename=MERGED_JSON_PATH,
+        repo_type="dataset", token=HF_TOKEN,
     )
     with open(local, encoding="utf-8") as f:
         return json.load(f)
@@ -65,42 +73,33 @@ def _load_merged() -> list[dict[str, Any]]:
 TASKS: list[dict[str, Any]] = _load_merged()
 TASK_BY_ID: dict[str, dict[str, Any]] = {t["task_id"]: t for t in TASKS}
 
+POOL: list[tuple[str, str]] = [(m, t["task_id"]) for m in MODELS for t in TASKS]
+POOL_SET: set[tuple[str, str]] = set(POOL)
+print(f"[mbench-ann] loaded {len(TASKS)} tasks × {len(MODELS)} models = {len(POOL)} items")
 
-def _extract_prompt(task: dict[str, Any]) -> str:
-    """Return the 5-segment prompt (level_3), joined with segment headers.
 
-    All MBench-V models were actually fed the 5-segment (level_3) prompts at
-    inference time, so this is what annotators should see. If level_3 is
-    missing for some reason we fall back to the finest available level.
-    """
+def _video_url(model: str, task_id: str) -> str:
+    return hf_hub_url(
+        DATASET_REPO,
+        filename=f"MBench-V/{model}/videos/{task_id}.mp4",
+        repo_type="dataset",
+    )
+
+
+def _extract_prompt(task: dict[str, Any]) -> str:
+    """Always return the 5-segment (level_3) prompt, joined with segment headers."""
     gp = task.get("generation_prompts") or {}
     prompts = gp.get("prompts") or {}
-    # Prefer the canonical 5-segment split; otherwise fall back gracefully.
     for level in ("level_3", "level_4", "level_2", "level_1"):
         val = prompts.get(level)
         if isinstance(val, list) and val:
             n = len(val)
-            parts = []
-            for i, seg in enumerate(val, 1):
-                parts.append(f"— Segment {i}/{n} —\n{seg}")
-            return "\n\n".join(parts)
+            return "\n\n".join(f"— Segment {i}/{n} —\n{seg}" for i, seg in enumerate(val, 1))
         if isinstance(val, str) and val:
             return val
     return "(no prompt found)"
 
 
-POOL: list[tuple[str, str]] = [(m, t["task_id"]) for m in MODELS for t in TASKS]
-print(f"[mbench-ann] loaded {len(TASKS)} tasks × {len(MODELS)} models = {len(POOL)} items")
-
-
-def _video_url(model: str, task_id: str) -> str:
-    return hf_hub_url(
-        DATASET_REPO,
-        filename=f"MBench-V/{model}/videos/{task_id}.mp4",
-        repo_type="dataset",
-    )
-
-
 # ---------------------------------------------------------------------------
 # CommitScheduler
 # ---------------------------------------------------------------------------
@@ -108,51 +107,25 @@ def _video_url(model: str, task_id: str) -> str:
 scheduler: CommitScheduler | None = None
 if HF_TOKEN:
     scheduler = CommitScheduler(
-        repo_id=DATASET_REPO,
-        repo_type="dataset",
-        folder_path=str(ANN_DIR),
-        path_in_repo="annotations",
-        every=COMMIT_INTERVAL_MIN,
-        token=HF_TOKEN,
-        private=False,
-        squash_history=False,
+        repo_id=DATASET_REPO, repo_type="dataset",
+        folder_path=str(ANN_DIR), path_in_repo="annotations",
+        every=COMMIT_INTERVAL_MIN, token=HF_TOKEN,
+        private=False, squash_history=False,
     )
     print(f"[mbench-ann] CommitScheduler started (every {COMMIT_INTERVAL_MIN} min)")
 else:
     print("[mbench-ann] WARNING: HF_TOKEN not set — annotations stay local only")
 
 
-def _append_annotation(record: dict[str, Any]) -> None:
-    line = json.dumps(record, ensure_ascii=False)
-    if scheduler is not None:
-        with scheduler.lock:
-            with ANN_FILE.open("a", encoding="utf-8") as f:
-                f.write(line + "\n")
-    else:
-        with ANN_FILE.open("a", encoding="utf-8") as f:
-            f.write(line + "\n")
-    # Update in-memory mirror so progress stats react immediately (the
-    # committed file only arrives on the dataset every COMMIT_INTERVAL_MIN).
-    HISTORICAL_ANNOTATIONS.append(record)
-
-
 # ---------------------------------------------------------------------------
-# Load historical annotations (for dedup + progress stats)
+# Historical annotations → bootstrap the "submitted" set
 # ---------------------------------------------------------------------------
 
 def _fetch_remote_annotations() -> list[dict[str, Any]]:
-    """Download and parse every .jsonl file under `annotations/` on the dataset repo.
-
-    Returns a list of records. Silently returns [] if the folder does not exist
-    or any download fails — annotation UX should never be blocked by this.
-    """
-    from huggingface_hub import HfApi
     records: list[dict[str, Any]] = []
     try:
         api = HfApi(token=HF_TOKEN)
-        files = api.list_repo_files(
-            repo_id=DATASET_REPO, repo_type="dataset",
-        )
+        files = api.list_repo_files(repo_id=DATASET_REPO, repo_type="dataset")
     except Exception as e:
         print(f"[mbench-ann] list_repo_files failed: {e}")
         return records
@@ -182,126 +155,206 @@ HISTORICAL_ANNOTATIONS: list[dict[str, Any]] = _fetch_remote_annotations()
 print(f"[mbench-ann] loaded {len(HISTORICAL_ANNOTATIONS)} historical annotation records")
 
 
-def _global_stats() -> tuple[int, int]:
-    """(total_records, unique_(model,task_id)_pairs_covered)."""
-    seen: set[tuple[str, str]] = set()
-    for r in HISTORICAL_ANNOTATIONS:
-        if "model" in r and "task_id" in r:
-            seen.add((r["model"], r["task_id"]))
-    return len(HISTORICAL_ANNOTATIONS), len(seen)
+# ---------------------------------------------------------------------------
+# Shared work-queue state
+# ---------------------------------------------------------------------------
+# STATE_LOCK guards SUBMITTED and PENDING. Both are modified on every login,
+# skip, submit, and prompt-for-next-item.
 
+STATE_LOCK = threading.Lock()
 
-def _annotator_seen(annotator: str) -> set[tuple[str, str]]:
-    """`(model, task_id)` pairs already annotated by this annotator."""
-    annotator_l = annotator.strip().lower()
-    seen: set[tuple[str, str]] = set()
-    for r in HISTORICAL_ANNOTATIONS:
-        if (r.get("annotator") or "").strip().lower() == annotator_l:
-            seen.add((r.get("model", ""), r.get("task_id", "")))
-    return seen
+# (model, task_id) keys of items already submitted (permanently consumed).
+SUBMITTED: set[tuple[str, str]] = {
+    (r["model"], r["task_id"])
+    for r in HISTORICAL_ANNOTATIONS
+    if "model" in r and "task_id" in r and (r["model"], r["task_id"]) in POOL_SET
+}
 
+# Currently claimed-but-not-submitted: {(model, task_id): (annotator, claim_ts)}
+PENDING: dict[tuple[str, str], tuple[str, float]] = {}
 
-def _global_stats_md() -> str:
-    total, unique = _global_stats()
-    pool_sz = len(POOL)
-    pct = (unique / pool_sz * 100) if pool_sz else 0
-    return (
-        f"**Dataset progress**: {total} total annotations submitted • "
-        f"{unique} / {pool_sz} unique (model, task_id) pairs covered ({pct:.1f}%)"
-    )
+print(f"[mbench-ann] work-queue bootstrap: submitted={len(SUBMITTED)}, remaining={len(POOL) - len(SUBMITTED)}")
+
+
+def _reap_expired_pending() -> None:
+    """Drop entries in PENDING that have passed the timeout. Caller must hold STATE_LOCK."""
+    now = time.time()
+    expired = [k for k, (_, ts) in PENDING.items() if now - ts > PENDING_TIMEOUT_SEC]
+    for k in expired:
+        PENDING.pop(k, None)
+    if expired:
+        print(f"[mbench-ann] reaped {len(expired)} expired pending items")
+
+
+def _claim_next(annotator: str, order: list[int], idx_start: int) -> tuple[int, tuple[str, str] | None]:
+    """Find the first unclaimed pool index at or after idx_start and claim it.
+
+    Returns (new_idx, (model, task_id)) or (len(order), None) if none left.
+    Atomic under STATE_LOCK.
+    """
+    with STATE_LOCK:
+        _reap_expired_pending()
+        idx = idx_start
+        while idx < len(order):
+            mt = POOL[order[idx]]
+            if mt in SUBMITTED or mt in PENDING:
+                idx += 1
+                continue
+            # Claim it.
+            PENDING[mt] = (annotator, time.time())
+            return idx, mt
+        return len(order), None
+
+
+def _release_pending(annotator: str, mt: tuple[str, str] | None, *, reason: str) -> None:
+    """Give a claim back to the pool. No-op if the claim isn't owned by this annotator."""
+    if mt is None:
+        return
+    with STATE_LOCK:
+        entry = PENDING.get(mt)
+        if entry and entry[0] == annotator:
+            PENDING.pop(mt, None)
+
+
+def _record_submit(annotator: str, mt: tuple[str, str]) -> None:
+    """Mark a claim as permanently submitted."""
+    with STATE_LOCK:
+        PENDING.pop(mt, None)
+        SUBMITTED.add(mt)
 
 
+def _append_annotation(record: dict[str, Any]) -> None:
+    line = json.dumps(record, ensure_ascii=False)
+    if scheduler is not None:
+        with scheduler.lock:
+            with ANN_FILE.open("a", encoding="utf-8") as f:
+                f.write(line + "\n")
+    else:
+        with ANN_FILE.open("a", encoding="utf-8") as f:
+            f.write(line + "\n")
+    HISTORICAL_ANNOTATIONS.append(record)
+
 
 # ---------------------------------------------------------------------------
 # UI helpers
 # ---------------------------------------------------------------------------
 
-def _format_meta(model: str, task: dict[str, Any], idx: int, total: int) -> str:
+def _stats_md() -> str:
+    with STATE_LOCK:
+        _reap_expired_pending()
+        n_sub = len(SUBMITTED)
+        n_pend = len(PENDING)
+    total = len(POOL)
+    pct = 100.0 * n_sub / total if total else 0.0
+    return (
+        f"**Global progress**: {n_sub} / {total} submitted ({pct:.1f}%)"
+        f" • {n_pend} currently being annotated by someone"
+        f" • {total - n_sub - n_pend} left"
+    )
+
+
+def _meta_md(model: str, task: dict[str, Any], state: dict) -> str:
+    done_by_me = state.get("submitted_count", 0)
+    claimed_n = state.get("claimed_n", 0)
     lines = [
-        f"**Progress**: {idx + 1} / {total}",
+        f"**Your submissions this session**: {done_by_me} (claimed {claimed_n} so far)",
         f"**Model**: `{model}`",
         f"**task_id**: `{task['task_id']}`",
-        f"**category**: `{task.get('category', '?')}`  •  **subcategory**: `{task.get('subcategory', '?')}`",
-        f"**source_task**: `{task.get('source_task', '?')}`",
     ]
-    if task.get("task_type"):
-        lines.append(f"**task_type**: `{task['task_type']}`")
     return "\n\n".join(lines)
 
 
-def _load_item(pool_order: list[int], idx: int) -> tuple[str, str, str]:
-    if idx < 0 or idx >= len(pool_order):
-        return "<div style='padding:24px;color:#888'>All done — no more items.</div>", "**All done!** No more items.", ""
-    model, task_id = POOL[pool_order[idx]]
-    task = TASK_BY_ID[task_id]
-    url = _video_url(model, task_id)
-    # Render a native <video> so the browser streams directly from HF CDN,
-    # bypassing gradio's server-side SSRF-protected download (which blocks
-    # the xet-bridge hostnames).
-    video_html = (
+def _render_video_html(url: str) -> str:
+    return (
         f'<video src="{url}" controls autoplay loop muted playsinline '
-        f'style="width:100%;max-height:520px;background:#000;border-radius:8px;">'
+        f'style="width:100%;height:520px;background:#000;border-radius:8px;object-fit:contain;">'
         f'Your browser does not support HTML5 video.</video>'
     )
+
+
+PLACEHOLDER_VIDEO = (
+    "<div style='height:520px;display:flex;align-items:center;justify-content:center;"
+    "color:#888;background:#111;border-radius:8px;'>"
+    "Enter your name and click <b>Start</b> to load a video."
+    "</div>"
+)
+
+ALL_DONE_VIDEO = (
+    "<div style='height:520px;display:flex;align-items:center;justify-content:center;"
+    "color:#4a7;background:#111;border-radius:8px;font-size:18px;'>"
+    "🎉 All items have been annotated. Thank you!"
+    "</div>"
+)
+
+
+def _next_item_for(state: dict) -> tuple[str, str, str, dict]:
+    """Advance `state` to the next unclaimed item and return render strings.
+
+    Returns (video_html, meta_md, prompt_text, updated_state).
+    """
+    annotator = state["annotator"]
+    order = state["order"]
+    idx = state.get("idx", 0)
+
+    # Release the currently-held claim if any (e.g. after submit the caller
+    # already released it; on first call there's nothing to release).
+    new_idx, mt = _claim_next(annotator, order, idx)
+    state["idx"] = new_idx
+    if mt is None:
+        state["current"] = None
+        return ALL_DONE_VIDEO, "**All done.** Nothing left in the pool.", "", state
+
+    state["current"] = mt
+    state["claimed_n"] = state.get("claimed_n", 0) + 1
+    model, task_id = mt
+    task = TASK_BY_ID[task_id]
     return (
-        video_html,
-        _format_meta(model, task, idx, len(pool_order)),
+        _render_video_html(_video_url(model, task_id)),
+        _meta_md(model, task, state),
         _extract_prompt(task),
+        state,
     )
 
 
 # ---------------------------------------------------------------------------
-# Gradio callbacks — all return plain Python values (no gr.update mix)
+# Gradio callbacks
 # ---------------------------------------------------------------------------
 
 def start_session(annotator: str, state: dict):
     annotator = (annotator or "").strip()
     if not annotator:
         return (
-            state, "", "⚠️ Please enter a name first.", "",
-            "⚠️ Please enter a name first.", _global_stats_md(),
+            state, PLACEHOLDER_VIDEO, "", "",
+            "⚠️ Please enter a name first.", _stats_md(),
         )
-    # Filter out (model, task_id) already annotated by this annotator
-    seen = _annotator_seen(annotator)
-    order: list[int] = [i for i, (m, t) in enumerate(POOL) if (m, t) not in seen]
-    rng = random.Random(f"{annotator}-{int(time.time())}")
+    # Release any claim an older session of this user still holds in-memory.
+    # (We can't detect cross-browser sessions of the same user, but within one
+    # process a user holding an old claim and logging in again will free it.)
+    order = list(range(len(POOL)))
+    rng = random.Random(f"{annotator}-{int(time.time())}-{uuid.uuid4().hex}")
     rng.shuffle(order)
-    state = {"annotator": annotator, "order": order, "idx": 0}
-    if not order:
-        status = (
-            f"🎉 Welcome back `{annotator}` — you have already annotated every item. Nothing left to do!"
-        )
-        return (
-            state,
-            "<div style='padding:24px;color:#888;text-align:center'>All done!</div>",
-            "**All done.**",
-            "",
-            status,
-            _global_stats_md(),
-        )
-    video_html, meta, prompt = _load_item(order, 0)
-    skipped = len(POOL) - len(order)
-    status = (
-        f"✅ Logged in as `{annotator}` — {len(order)} items to annotate"
-        + (f" (skipped {skipped} already done)." if skipped else ".")
-    )
-    return state, video_html, meta, prompt, status, _global_stats_md()
+    state = {"annotator": annotator, "order": order, "idx": 0,
+             "current": None, "submitted_count": 0, "claimed_n": 0}
+    video_html, meta, prompt, state = _next_item_for(state)
+    status = f"✅ Welcome `{annotator}`. Good luck!"
+    return state, video_html, meta, prompt, status, _stats_md()
 
 
-def submit_and_next(state: dict, score: float, note: str):
-    if not state or "order" not in state:
+def submit_and_next(state: dict, verdict: str, note: str):
+    """Record current claim as submitted, then advance."""
+    if not state or "annotator" not in state:
         return (
-            state, "", "⚠️ Please log in first.", "", 3, "",
-            "⚠️ Not logged in.", _global_stats_md(),
+            state, PLACEHOLDER_VIDEO, "", "", "No", "",
+            "⚠️ Please log in first.", _stats_md(),
         )
-    order = state["order"]
-    idx = state["idx"]
-    if idx >= len(order):
+    current = state.get("current")
+    if current is None:
+        # No active claim — nothing to submit.
         return (
-            state, "", "**All done!**", "", 3, "",
-            "No more items.", _global_stats_md(),
+            state, ALL_DONE_VIDEO, "**All done.**", "", "No", "",
+            "No active item to submit.", _stats_md(),
         )
-    model, task_id = POOL[order[idx]]
+    model, task_id = current
     record = {
         "timestamp": time.time(),
         "timestamp_iso": time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime()),
@@ -309,111 +362,114 @@ def submit_and_next(state: dict, score: float, note: str):
         "process_id": PROCESS_ID,
         "model": model,
         "task_id": task_id,
-        "score": int(score),
+        "memory_issue": verdict == "Yes",   # boolean
+        "verdict": verdict,                  # "Yes" / "No" raw
         "note": (note or "").strip(),
     }
     _append_annotation(record)
-    state["idx"] = idx + 1
-    video_html, meta, prompt = _load_item(state["order"], state["idx"])
+    _record_submit(state["annotator"], current)
+    state["submitted_count"] = state.get("submitted_count", 0) + 1
+    state["idx"] = state["idx"] + 1
+    state["current"] = None
+
+    video_html, meta, prompt, state = _next_item_for(state)
     return (
-        state, video_html, meta, prompt, 3, "",
-        f"✅ Submitted ({state['idx']}). Next →", _global_stats_md(),
+        state, video_html, meta, prompt,
+        "No",            # reset verdict
+        "",              # reset note
+        f"✅ Submitted ({state['submitted_count']}) → next",
+        _stats_md(),
     )
 
 
 def skip_and_next(state: dict):
-    if not state or "order" not in state:
+    """Release the current claim back to the pool and advance."""
+    if not state or "annotator" not in state:
         return (
-            state, "", "⚠️ Please log in first.", "", 3, "",
-            "⚠️ Not logged in.", _global_stats_md(),
+            state, PLACEHOLDER_VIDEO, "", "", "No", "",
+            "⚠️ Please log in first.", _stats_md(),
         )
-    state["idx"] = state["idx"] + 1
-    video_html, meta, prompt = _load_item(state["order"], state["idx"])
+    current = state.get("current")
+    if current is not None:
+        _release_pending(state["annotator"], current, reason="skip")
+    state["idx"] = state.get("idx", 0) + 1
+    state["current"] = None
+
+    video_html, meta, prompt, state = _next_item_for(state)
     return (
-        state, video_html, meta, prompt, 3, "",
-        f"⏭️ Skipped. Position: {state['idx']}", _global_stats_md(),
+        state, video_html, meta, prompt,
+        "No", "",
+        f"⏭️ Skipped. Your submissions: {state.get('submitted_count', 0)}",
+        _stats_md(),
     )
 
 
 # ---------------------------------------------------------------------------
-# Gradio UI — single page (no visibility toggling)
+# UI
 # ---------------------------------------------------------------------------
 
-with gr.Blocks(title="MBench-V Annotation", theme=gr.themes.Soft()) as demo:
+CUSTOM_CSS = """
+#prompt_box textarea { height: 480px !important; overflow-y: auto !important; }
+"""
+
+with gr.Blocks(title="MBench-V Annotation", theme=gr.themes.Soft(),
+               css=CUSTOM_CSS) as demo:
     gr.Markdown(
         """
-        # 🎬 MBench-V Annotation
-
-        1. Enter a short name (any string — it tags your submissions).
-        2. Click **Start** — a video will appear below.
-        3. Give a score (1–5, 5 = best) and optional note; click **Submit & Next**.
-        4. Submissions auto-sync to the dataset repo every 5 minutes.
+        # 🎬 MBench-V Annotation — *Does this video exhibit a memory issue?*
 
-        _Tip_: items you've already annotated are automatically skipped.
+        Watch the video (left) against its intended 5-segment prompt (right) and
+        answer **Yes** or **No**.
         """
     )
 
-    stats_md = gr.Markdown(_global_stats_md())
+    stats_md = gr.Markdown(_stats_md())
 
     state = gr.State()
 
     with gr.Row():
         annotator_in = gr.Textbox(
-            label="Annotator name",
-            placeholder="e.g. alice",
-            scale=4,
+            label="Annotator name", placeholder="e.g. alice", scale=4, autofocus=True,
         )
         login_btn = gr.Button("Start", variant="primary", scale=1)
 
     status_md = gr.Markdown("_Not started yet._")
 
-    with gr.Row():
+    # ========= Top row: video ↔ prompt =========
+    with gr.Row(equal_height=True):
         with gr.Column(scale=3):
-            video = gr.HTML(
-                value="<div style='padding:24px;color:#888;text-align:center'>"
-                      "Enter your name above and click <b>Start</b> to load the first video."
-                      "</div>",
-                label="Generated video",
-            )
+            video = gr.HTML(value=PLACEHOLDER_VIDEO, label="Generated video")
         with gr.Column(scale=2):
-            meta_md = gr.Markdown()
             prompt_tb = gr.Textbox(
                 label="Generation prompt (5 segments)",
-                lines=20,
-                max_lines=40,
-                interactive=False,
+                lines=22, max_lines=22,
+                interactive=False, show_copy_button=True,
+                elem_id="prompt_box",
             )
-        with gr.Column(scale=1):
-            score = gr.Slider(1, 5, value=3, step=1, label="Score")
-            note = gr.Textbox(label="Note (optional)", lines=4)
-            submit_btn = gr.Button("✅ Submit & Next", variant="primary")
-            skip_btn = gr.Button("⏭️ Skip")
-
-    login_btn.click(
-        start_session,
-        inputs=[annotator_in, state],
-        outputs=[state, video, meta_md, prompt_tb, status_md, stats_md],
-        api_name=False,
-    )
-    annotator_in.submit(
-        start_session,
-        inputs=[annotator_in, state],
-        outputs=[state, video, meta_md, prompt_tb, status_md, stats_md],
-        api_name=False,
-    )
-    submit_btn.click(
-        submit_and_next,
-        inputs=[state, score, note],
-        outputs=[state, video, meta_md, prompt_tb, score, note, status_md, stats_md],
-        api_name=False,
-    )
-    skip_btn.click(
-        skip_and_next,
-        inputs=[state],
-        outputs=[state, video, meta_md, prompt_tb, score, note, status_md, stats_md],
-        api_name=False,
-    )
+
+    # ========= Bottom row: meta ↔ verdict =========
+    with gr.Row():
+        with gr.Column(scale=3):
+            meta_md = gr.Markdown("_No task loaded yet._")
+        with gr.Column(scale=2):
+            verdict = gr.Radio(
+                choices=["No", "Yes"], value="No",
+                label="Does this video exhibit a memory issue?",
+            )
+            note = gr.Textbox(label="Note (optional)", lines=2)
+            with gr.Row():
+                submit_btn = gr.Button("✅ Submit & Next", variant="primary")
+                skip_btn = gr.Button("⏭️ Skip")
+
+    # ========= Wiring =========
+    login_outputs = [state, video, meta_md, prompt_tb, status_md, stats_md]
+    step_outputs = [state, video, meta_md, prompt_tb, verdict, note, status_md, stats_md]
+
+    login_btn.click(start_session, inputs=[annotator_in, state], outputs=login_outputs, api_name=False)
+    annotator_in.submit(start_session, inputs=[annotator_in, state], outputs=login_outputs, api_name=False)
+    submit_btn.click(submit_and_next, inputs=[state, verdict, note], outputs=step_outputs, api_name=False)
+    skip_btn.click(skip_and_next, inputs=[state], outputs=step_outputs, api_name=False)
 
 
 if __name__ == "__main__":
-    demo.queue(default_concurrency_limit=8).launch()
+    demo.queue(default_concurrency_limit=16).launch()