Initial anonymous release: phyground-code

README.md

@@ -0,0 +1,71 @@
+---
+language:
+  - en
+tags:
+  - code
+  - video-evaluation
+  - benchmark
+  - judge
+  - anonymous-release
+---
+
+# Anonymous Release — Code
+
+Source code for the benchmark, evaluation, and judge-training pipeline that
+accompanies the companion data release
+[`phyground`](../datasets/) and the LoRA judge adapter under
+[`../model/`](../model/).
+
+This drop contains 43 Python source files plus the HTML/CSS/JS assets needed
+by the human-annotation app. Shell scripts, configuration YAMLs,
+prompts/answers JSONs, generated dashboards, databases, and binary assets are
+intentionally excluded — see the dataset and model cards for the artifacts and
+prompts those scripts consume.
+
+## Layout
+
+```
+dataprocessing/
+  common/              # Vertex AI / OpenAI client helpers, video-id utilities
+  refine/              # Prompt-set construction: enhance, dedup, hard-subset,
+                       # humaneval-set assembly, removal sync
+  analysis/            # Ablation: prompt-enhancement effect on judges
+
+evals/
+  eval_types.py        # Typed result containers for VLM-as-judge runs
+  physics_criteria.py  # Physical-law sub-rubric definitions
+  sub_questions.py     # Sub-question rendering for CoT/SubQ prompts
+  prompts/             # Prompt-template loaders (YAMLs withheld; see model card)
+  human_eval/          # Flask-based human-annotation app + tests + templates
+
+judge_training/
+  data/                # Build SFT data for ms-swift from raw judgement logs
+                       # (schema, sampling, naming, Claude-CoT/DB builders)
+```
+
+## Companion artifacts
+
+- **Dataset** (250 prompts × 8 video models = 2 000 videos, sub-rubric
+  ground truth): `../datasets/` — see its `README.md`.
+- **Model** (LoRA judge adapter, prompt template, inference script):
+  `../model/` — see its `README.md` and `infer.py`.
+
+## Dependencies (top-level)
+
+The pipeline relies on the following open-source components. Versions match
+those reported in the paper.
+
+| Component | Used for |
+| --- | --- |
+| `transformers`, `peft`, `qwen-vl-utils[decord]` | Judge inference |
+| `ms-swift`, `deepspeed` | Judge LoRA training (ZeRO-2) |
+| `vllm` (OpenAI-compatible server) | Hosting the base VLM for evaluation |
+| `google-genai` / Vertex AI | Gemini family runs |
+| `anthropic` / Vertex AI | Claude family runs |
+| `openai` Python SDK | OpenAI / GPT family runs |
+| `flask`, `sqlite3`, `selenium` | Human-annotation web app |
+
+## License
+
+Code is released under the same anonymous-review terms as the rest of this
+release. No identifying metadata is included.

dataprocessing/analysis/ablation_prompt_enhancement.py

@@ -0,0 +1,719 @@
+#!/usr/bin/env python3
+"""
+Ablation study: Effect of prompt enhancement (adding physical law/phenomenon descriptions)
+on VLM evaluation scores.
+
+Compares backup (pre-enhancement) eval files with current (post-enhancement) eval files,
+analyzing score deltas per video where the prompt actually changed.
+
+Run from the anonymous root dir:
+    python -m dataprocessing.analysis.ablation_prompt_enhancement
+"""
+
+import json
+import os
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+DATA_ROOT = "data"
+BACKUP_DIR = os.path.join(DATA_ROOT, "backup_before_laws_update")
+VIDEOS_DIR = os.path.join(DATA_ROOT, "videos")
+
+GENERAL_METRICS = ["SA", "PTV", "persistence"]
+SCORE_BINS = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
+
+# Law-to-domain mapping
+LAW_TO_DOMAIN = {
+    # collision
+    "collision": "collision",
+    "impenetrability": "collision",
+    "momentum_transfer": "collision",
+    "momentum": "collision",
+    "elastic_deformation": "collision",
+    # gravity
+    "gravity": "gravity",
+    "free_fall": "gravity",
+    "projectile_motion": "gravity",
+    "buoyancy": "gravity",
+    # fluid
+    "fluid_continuity": "fluid",
+    "flow_dynamics": "fluid",
+    "flow": "fluid",
+    "viscosity": "fluid",
+    "surface_tension": "fluid",
+    "pressure": "fluid",
+    "continuity": "fluid",
+    # temporal / motion
+    "inertia": "temporal",
+    "acceleration": "temporal",
+    "velocity": "temporal",
+    "displacement": "temporal",
+    # lighting
+    "reflection": "lighting",
+    "refraction": "lighting",
+    "light_absorption": "lighting",
+    "shadow": "lighting",
+    "illumination": "lighting",
+    # deformation
+    "deformation": "deformation",
+    "plastic_deformation": "deformation",
+    # material
+    "material": "material",
+    "rigidity": "material",
+    "elasticity": "material",
+    "phase_transition": "material",
+    "melting": "material",
+    "combustion": "material",
+}
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def parse_judge_key(judge_str: str) -> str:
+    """Extract a short judge key like 'gemini', 'qwen', 'gpt' from judge field."""
+    if not judge_str:
+        return "unknown"
+    return judge_str.split(":")[0]
+
+
+def parse_filename_judge(filename: str) -> str:
+    """Extract judge key from filename like eval_gemini_..., eval_qwen_permetric_..."""
+    m = re.match(r"eval_(gemini|qwen|gpt)", filename)
+    return m.group(1) if m else "unknown"
+
+
+def is_permetric(filename: str) -> bool:
+    return "permetric" in filename
+
+
+def get_physical_avg(result: dict) -> Optional[float]:
+    """Extract physical average from a result entry."""
+    phys = result.get("physical")
+    if phys is None:
+        return None
+    if isinstance(phys, (int, float)):
+        return float(phys)
+    if isinstance(phys, dict):
+        avg = phys.get("avg")
+        if avg is not None:
+            return float(avg)
+    return None
+
+
+def get_per_law_scores(result: dict) -> Dict[str, float]:
+    """Extract per-law scores from a result entry."""
+    phys = result.get("physical")
+    if not isinstance(phys, dict):
+        return {}
+    laws = phys.get("laws", {})
+    out = {}
+    for law_name, law_data in laws.items():
+        if isinstance(law_data, dict) and "score" in law_data and law_data["score"] is not None:
+            out[law_name] = float(law_data["score"])
+        elif isinstance(law_data, (int, float)) and law_data is not None:
+            out[law_name] = float(law_data)
+    return out
+
+
+def extract_dataset_from_video_dir(video_dir: str) -> str:
+    """Extract dataset name from video_dir field, e.g. 'data/videos/cosmos-predict2.5-2b-wmb/' -> 'wmb'."""
+    vd = video_dir.rstrip("/")
+    basename = os.path.basename(vd)
+    # Try to find the dataset suffix: wmb, video_phy_2, physics_iq, openvid, video_phy_2
+    for ds in ["wmb", "video_phy_2", "physics_iq", "openvid", "video_phy_2", "wmb"]:
+        if basename.endswith(f"-{ds}"):
+            return ds
+    return basename
+
+
+def extract_model_from_video_dir(video_dir: str) -> str:
+    """Extract model name from video_dir."""
+    vd = video_dir.rstrip("/")
+    basename = os.path.basename(vd)
+    for ds in ["wmb", "video_phy_2", "physics_iq", "openvid", "video_phy_2", "wmb"]:
+        suffix = f"-{ds}"
+        if basename.endswith(suffix):
+            return basename[: -len(suffix)]
+    return basename
+
+
+def load_eval_file(filepath: str) -> Optional[dict]:
+    """Load an eval JSON file, returning None on error."""
+    try:
+        with open(filepath, "r") as f:
+            data = json.load(f)
+        if not data.get("results"):
+            return None
+        return data
+    except (json.JSONDecodeError, FileNotFoundError, KeyError):
+        return None
+
+
+def get_timestamp_from_filename(filename: str) -> str:
+    """Extract timestamp from filename like eval_gemini_20260322_200226.json."""
+    m = re.search(r"(\d{8}_\d{6})", filename)
+    return m.group(1) if m else ""
+
+
+# ---------------------------------------------------------------------------
+# Core: find old/new pairs
+# ---------------------------------------------------------------------------
+
+
+def find_pairs() -> List[Dict[str, Any]]:
+    """
+    Find all (old_file, new_file) pairs for comparison.
+    Returns list of dicts with keys: old_path, new_path, model, dataset, judge, mode (batched/permetric).
+    """
+    pairs = []
+
+    if not os.path.isdir(BACKUP_DIR):
+        print(f"ERROR: Backup directory not found: {BACKUP_DIR}", file=sys.stderr)
+        return pairs
+
+    for backup_model in sorted(os.listdir(BACKUP_DIR)):
+        backup_model_dir = os.path.join(BACKUP_DIR, backup_model)
+        if not os.path.isdir(backup_model_dir):
+            continue
+
+        for fname in sorted(os.listdir(backup_model_dir)):
+            if not fname.startswith("eval_") or not fname.endswith(".json"):
+                continue
+
+            old_path = os.path.join(backup_model_dir, fname)
+            old_data = load_eval_file(old_path)
+            if old_data is None:
+                continue
+
+            video_dir = old_data.get("video_dir", "")
+            if not video_dir:
+                continue
+
+            dataset = extract_dataset_from_video_dir(video_dir)
+            model = extract_model_from_video_dir(video_dir)
+            judge = parse_judge_key(old_data.get("judge", ""))
+            mode = "permetric" if is_permetric(fname) else "batched"
+
+            # Find corresponding current directory
+            current_dir = os.path.join(VIDEOS_DIR, f"{model}-{dataset}")
+            if not os.path.isdir(current_dir):
+                continue
+
+            # Find newest matching eval file in current dir
+            old_timestamp = get_timestamp_from_filename(fname)
+            best_new_path = None
+            best_new_ts = ""
+
+            for cur_fname in os.listdir(current_dir):
+                if not cur_fname.startswith("eval_") or not cur_fname.endswith(".json"):
+                    continue
+                if ".old_pre_t26." in cur_fname:
+                    continue
+
+                cur_judge = parse_filename_judge(cur_fname)
+                cur_mode = "permetric" if is_permetric(cur_fname) else "batched"
+
+                if cur_judge != judge or cur_mode != mode:
+                    continue
+
+                cur_ts = get_timestamp_from_filename(cur_fname)
+
+                # Skip files with same timestamp as the old file (these are copies)
+                if cur_ts == old_timestamp:
+                    continue
+
+                # Must be newer than old
+                if cur_ts <= old_timestamp:
+                    continue
+
+                # Pick the newest one
+                if cur_ts > best_new_ts:
+                    best_new_ts = cur_ts
+                    best_new_path = os.path.join(current_dir, cur_fname)
+
+            if best_new_path:
+                pairs.append(
+                    {
+                        "old_path": old_path,
+                        "new_path": best_new_path,
+                        "model": model,
+                        "dataset": dataset,
+                        "judge": judge,
+                        "mode": mode,
+                    }
+                )
+
+    return pairs
+
+
+# ---------------------------------------------------------------------------
+# Core: compute deltas
+# ---------------------------------------------------------------------------
+
+
+def compute_deltas(
+    old_data: dict, new_data: dict
+) -> List[Dict[str, Any]]:
+    """
+    For each video present in both old and new where the prompt changed,
+    compute score deltas.
+    Returns list of per-video delta records.
+    """
+    old_by_video = {r["video"]: r for r in old_data["results"]}
+    new_by_video = {r["video"]: r for r in new_data["results"]}
+
+    deltas = []
+    common_videos = set(old_by_video.keys()) & set(new_by_video.keys())
+
+    for vid in sorted(common_videos):
+        old_r = old_by_video[vid]
+        new_r = new_by_video[vid]
+
+        # Only analyze videos where the prompt actually changed
+        if old_r.get("prompt", "") == new_r.get("prompt", ""):
+            continue
+
+        rec: Dict[str, Any] = {
+            "video": vid,
+            "old_prompt": old_r.get("prompt", ""),
+            "new_prompt": new_r.get("prompt", ""),
+            "physical_laws": new_r.get("physical_laws", old_r.get("physical_laws", [])),
+        }
+
+        # General metrics deltas
+        for m in GENERAL_METRICS:
+            old_val = old_r.get(m)
+            new_val = new_r.get(m)
+            if old_val is not None and new_val is not None:
+                rec[f"{m}_old"] = float(old_val)
+                rec[f"{m}_new"] = float(new_val)
+                rec[f"{m}_delta"] = float(new_val) - float(old_val)
+
+        # general_avg delta
+        old_ga = old_r.get("general_avg")
+        new_ga = new_r.get("general_avg")
+        if old_ga is not None and new_ga is not None:
+            rec["general_avg_old"] = float(old_ga)
+            rec["general_avg_new"] = float(new_ga)
+            rec["general_avg_delta"] = float(new_ga) - float(old_ga)
+
+        # physical_avg delta
+        old_pa = get_physical_avg(old_r)
+        new_pa = get_physical_avg(new_r)
+        if old_pa is not None and new_pa is not None:
+            rec["physical_avg_old"] = float(old_pa)
+            rec["physical_avg_new"] = float(new_pa)
+            rec["physical_avg_delta"] = float(new_pa) - float(old_pa)
+
+        # Per-law score deltas
+        old_laws = get_per_law_scores(old_r)
+        new_laws = get_per_law_scores(new_r)
+        law_deltas = {}
+        for law in set(old_laws.keys()) & set(new_laws.keys()):
+            law_deltas[law] = new_laws[law] - old_laws[law]
+        rec["per_law_deltas"] = law_deltas
+
+        deltas.append(rec)
+
+    return deltas
+
+
+# ---------------------------------------------------------------------------
+# Aggregation
+# ---------------------------------------------------------------------------
+
+
+def safe_mean(values: list) -> Optional[float]:
+    if not values:
+        return None
+    return sum(values) / len(values)
+
+
+def format_delta(val: Optional[float], decimals: int = 4) -> str:
+    if val is None:
+        return "N/A"
+    sign = "+" if val >= 0 else ""
+    return f"{sign}{val:.{decimals}f}"
+
+
+def format_float(val: Optional[float], decimals: int = 4) -> str:
+    if val is None:
+        return "N/A"
+    return f"{val:.{decimals}f}"
+
+
+class AblationAnalysis:
+    def __init__(self):
+        # Each entry: (model, dataset, judge, mode, delta_record)
+        self.all_records: List[Tuple[str, str, str, str, Dict[str, Any]]] = []
+
+    def add(self, model: str, dataset: str, judge: str, mode: str, deltas: List[Dict[str, Any]]):
+        for d in deltas:
+            self.all_records.append((model, dataset, judge, mode, d))
+
+    def _filter(
+        self,
+        model: Optional[str] = None,
+        dataset: Optional[str] = None,
+        judge: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        out = []
+        for m, ds, j, mode, rec in self.all_records:
+            if model and m != model:
+                continue
+            if dataset and ds != dataset:
+                continue
+            if judge and j != judge:
+                continue
+            out.append(rec)
+        return out
+
+    def _metric_deltas(self, records: List[Dict], metric_key: str) -> List[float]:
+        key = f"{metric_key}_delta"
+        return [r[key] for r in records if key in r]
+
+    def overall_summary(self) -> str:
+        lines = []
+        records = self._filter()
+        n = len(records)
+        lines.append(f"**Total video comparisons (prompt changed):** {n}")
+        lines.append("")
+
+        if n == 0:
+            lines.append("No data to analyze.")
+            return "\n".join(lines)
+
+        # Table header
+        metrics = GENERAL_METRICS + ["general_avg", "physical_avg"]
+        lines.append("| Metric | Mean Delta | Median Delta | Std Dev | N |")
+        lines.append("|--------|-----------|-------------|---------|---|")
+        for metric in metrics:
+            vals = self._metric_deltas(records, metric)
+            if not vals:
+                lines.append(f"| {metric} | N/A | N/A | N/A | 0 |")
+                continue
+            import statistics
+
+            mean = statistics.mean(vals)
+            median = statistics.median(vals)
+            stdev = statistics.stdev(vals) if len(vals) > 1 else 0.0
+            lines.append(
+                f"| {metric} | {format_delta(mean)} | {format_delta(median)} | {format_float(stdev)} | {len(vals)} |"
+            )
+        return "\n".join(lines)
+
+    def per_group_table(self, group_key: str) -> str:
+        """Group by model, dataset, or judge."""
+        groups: Dict[str, List[Dict]] = defaultdict(list)
+        for m, ds, j, mode, rec in self.all_records:
+            if group_key == "model":
+                key = m
+            elif group_key == "dataset":
+                key = ds
+            elif group_key == "judge":
+                key = j
+            else:
+                key = "all"
+            groups[key].append(rec)
+
+        metrics = GENERAL_METRICS + ["general_avg", "physical_avg"]
+        lines = []
+        header = f"| {group_key.capitalize()} | N |"
+        sep = "|---|---|"
+        for metric in metrics:
+            header += f" {metric} |"
+            sep += "---|"
+        lines.append(header)
+        lines.append(sep)
+
+        for gname in sorted(groups.keys()):
+            recs = groups[gname]
+            row = f"| {gname} | {len(recs)} |"
+            for metric in metrics:
+                vals = self._metric_deltas(recs, metric)
+                mean = safe_mean(vals)
+                row += f" {format_delta(mean)} |"
+            lines.append(row)
+
+        return "\n".join(lines)
+
+    def per_domain_table(self) -> str:
+        """Aggregate per-law deltas into domains."""
+        domain_deltas: Dict[str, List[float]] = defaultdict(list)
+        for _, _, _, _, rec in self.all_records:
+            for law, delta in rec.get("per_law_deltas", {}).items():
+                domain = LAW_TO_DOMAIN.get(law, "other")
+                domain_deltas[domain].append(delta)
+
+        lines = []
+        lines.append("| Domain | Mean Delta | N | Improved% | Degraded% | Unchanged% |")
+        lines.append("|--------|-----------|---|----------|----------|-----------|")
+
+        for domain in sorted(domain_deltas.keys()):
+            vals = domain_deltas[domain]
+            n = len(vals)
+            mean = safe_mean(vals)
+            improved = sum(1 for v in vals if v > 0) / n * 100 if n else 0
+            degraded = sum(1 for v in vals if v < 0) / n * 100 if n else 0
+            unchanged = sum(1 for v in vals if v == 0) / n * 100 if n else 0
+            lines.append(
+                f"| {domain} | {format_delta(mean)} | {n} | {improved:.1f}% | {degraded:.1f}% | {unchanged:.1f}% |"
+            )
+
+        return "\n".join(lines)
+
+    def per_law_table(self) -> str:
+        """Per-law breakdown."""
+        law_deltas: Dict[str, List[float]] = defaultdict(list)
+        for _, _, _, _, rec in self.all_records:
+            for law, delta in rec.get("per_law_deltas", {}).items():
+                law_deltas[law].append(delta)
+
+        lines = []
+        lines.append("| Law | Domain | Mean Delta | N | Improved% | Degraded% |")
+        lines.append("|-----|--------|-----------|---|----------|----------|")
+
+        # Sort by mean delta descending
+        sorted_laws = sorted(
+            law_deltas.keys(), key=lambda l: safe_mean(law_deltas[l]) or 0, reverse=True
+        )
+
+        for law in sorted_laws:
+            vals = law_deltas[law]
+            n = len(vals)
+            mean = safe_mean(vals)
+            domain = LAW_TO_DOMAIN.get(law, "other")
+            improved = sum(1 for v in vals if v > 0) / n * 100 if n else 0
+            degraded = sum(1 for v in vals if v < 0) / n * 100 if n else 0
+            lines.append(
+                f"| {law} | {domain} | {format_delta(mean)} | {n} | {improved:.1f}% | {degraded:.1f}% |"
+            )
+
+        return "\n".join(lines)
+
+    def score_bin_table(self) -> str:
+        """Effect on low-score vs high-score videos, binned by old general_avg."""
+        bin_deltas: Dict[str, Dict[str, List[float]]] = {}
+        for lo, hi in SCORE_BINS:
+            label = f"{lo}-{hi}"
+            bin_deltas[label] = defaultdict(list)
+
+        metrics = GENERAL_METRICS + ["general_avg", "physical_avg"]
+        for _, _, _, _, rec in self.all_records:
+            old_ga = rec.get("general_avg_old")
+            if old_ga is None:
+                continue
+            for lo, hi in SCORE_BINS:
+                if lo <= old_ga < hi or (hi == 5 and old_ga == 5):
+                    label = f"{lo}-{hi}"
+                    for metric in metrics:
+                        key = f"{metric}_delta"
+                        if key in rec:
+                            bin_deltas[label][metric].append(rec[key])
+                    break
+
+        lines = []
+        header = "| Old general_avg Bin | N |"
+        sep = "|---|---|"
+        for metric in metrics:
+            header += f" {metric} |"
+            sep += "---|"
+        lines.append(header)
+        lines.append(sep)
+
+        for lo, hi in SCORE_BINS:
+            label = f"{lo}-{hi}"
+            bd = bin_deltas[label]
+            # N = number of records in this bin
+            n_vals = bd.get("general_avg", [])
+            n = len(n_vals)
+            row = f"| {label} | {n} |"
+            for metric in metrics:
+                vals = bd.get(metric, [])
+                mean = safe_mean(vals)
+                row += f" {format_delta(mean)} |"
+            lines.append(row)
+
+        return "\n".join(lines)
+
+    def prompt_length_analysis(self) -> str:
+        """Analyze whether longer prompt additions correlate with bigger deltas."""
+        records_with_len = []
+        for _, _, _, _, rec in self.all_records:
+            old_len = len(rec.get("old_prompt", ""))
+            new_len = len(rec.get("new_prompt", ""))
+            delta_len = new_len - old_len
+            ga_delta = rec.get("general_avg_delta")
+            pa_delta = rec.get("physical_avg_delta")
+            if ga_delta is not None:
+                records_with_len.append((delta_len, ga_delta, pa_delta))
+
+        if not records_with_len:
+            return "No data for prompt length analysis."
+
+        lines = []
+        # Bin by prompt length increase
+        bins = [(0, 30), (30, 60), (60, 90), (90, 200)]
+        lines.append("| Prompt Length Increase | N | Mean general_avg Delta | Mean physical_avg Delta |")
+        lines.append("|----------------------|---|----------------------|----------------------|")
+
+        for lo, hi in bins:
+            subset = [(d, g, p) for d, g, p in records_with_len if lo <= d < hi]
+            n = len(subset)
+            ga_mean = safe_mean([g for _, g, _ in subset])
+            pa_mean = safe_mean([p for _, _, p in subset if p is not None])
+            lines.append(
+                f"| {lo}-{hi} chars | {n} | {format_delta(ga_mean)} | {format_delta(pa_mean)} |"
+            )
+
+        return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main():
+    # Ensure we're in anonymous root or adjust paths
+    if not os.path.isdir(DATA_ROOT):
+        # Try from the script's location
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        anonymous_root = os.path.abspath(os.path.join(script_dir, "..", ".."))
+        os.chdir(anonymous_root)
+        if not os.path.isdir(DATA_ROOT):
+            print(f"ERROR: Cannot find {DATA_ROOT}. Run from the anonymous root directory.", file=sys.stderr)
+            sys.exit(1)
+
+    print("# Ablation Study: Effect of Prompt Enhancement on VLM Evaluation Scores")
+    print()
+    print("Comparing backup (pre-enhancement) vs current (post-enhancement) evaluation files.")
+    print("Only videos where the prompt actually changed between versions are included.")
+    print()
+
+    # Step 1: Find all old/new pairs
+    pairs = find_pairs()
+    print(f"Found **{len(pairs)}** old/new eval file pairs.")
+    print()
+
+    if not pairs:
+        print("No pairs found. Exiting.")
+        return
+
+    # Print pairs summary
+    print("## File Pairs Found")
+    print()
+    print("| # | Model | Dataset | Judge | Mode | Old File | New File |")
+    print("|---|-------|---------|-------|------|----------|----------|")
+    for i, p in enumerate(pairs, 1):
+        old_base = os.path.basename(p["old_path"])
+        new_base = os.path.basename(p["new_path"])
+        print(
+            f"| {i} | {p['model']} | {p['dataset']} | {p['judge']} | {p['mode']} | {old_base} | {new_base} |"
+        )
+    print()
+
+    # Step 2: Compute deltas for each pair
+    analysis = AblationAnalysis()
+    total_videos = 0
+    total_changed = 0
+    skipped_pairs = 0
+
+    for p in pairs:
+        old_data = load_eval_file(p["old_path"])
+        new_data = load_eval_file(p["new_path"])
+        if old_data is None or new_data is None:
+            skipped_pairs += 1
+            continue
+
+        old_by_video = {r["video"]: r for r in old_data["results"]}
+        new_by_video = {r["video"]: r for r in new_data["results"]}
+        common = set(old_by_video.keys()) & set(new_by_video.keys())
+        total_videos += len(common)
+
+        deltas = compute_deltas(old_data, new_data)
+        total_changed += len(deltas)
+
+        analysis.add(p["model"], p["dataset"], p["judge"], p["mode"], deltas)
+
+    print(f"**Total matched videos across all pairs:** {total_videos}")
+    print(f"**Videos with prompt changes:** {total_changed}")
+    if skipped_pairs:
+        print(f"**Skipped pairs (load errors):** {skipped_pairs}")
+    print()
+
+    if total_changed == 0:
+        print("No videos with prompt changes found. Exiting.")
+        return
+
+    # Step 3: Reports
+    print("---")
+    print()
+    print("## 1. Overall Score Deltas (All Models, Datasets, Judges)")
+    print()
+    print(analysis.overall_summary())
+    print()
+
+    print("---")
+    print()
+    print("## 2. Per-Model Breakdown")
+    print()
+    print(analysis.per_group_table("model"))
+    print()
+
+    print("---")
+    print()
+    print("## 3. Per-Dataset Breakdown")
+    print()
+    print(analysis.per_group_table("dataset"))
+    print()
+
+    print("---")
+    print()
+    print("## 4. Per-Judge Breakdown")
+    print()
+    print(analysis.per_group_table("judge"))
+    print()
+
+    print("---")
+    print()
+    print("## 5. Per-Domain Breakdown (Physical Laws)")
+    print()
+    print(analysis.per_domain_table())
+    print()
+
+    print("---")
+    print()
+    print("## 6. Per-Law Breakdown (sorted by mean delta, descending)")
+    print()
+    print(analysis.per_law_table())
+    print()
+
+    print("---")
+    print()
+    print("## 7. Effect by Old Score Bin")
+    print()
+    print("Videos binned by their old general_avg score:")
+    print()
+    print(analysis.score_bin_table())
+    print()
+
+    print("---")
+    print()
+    print("## 8. Prompt Length Increase Analysis")
+    print()
+    print(analysis.prompt_length_analysis())
+    print()
+
+
+if __name__ == "__main__":
+    main()

dataprocessing/common/gemini.py

@@ -0,0 +1,51 @@
+"""Shared Gemini API client and argument utilities."""
+
+import json
+import logging
+import os
+import re
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+GEMINI_MODEL = "gemini-3.1-pro-preview"
+
+
+def add_gemini_args(parser):
+    """Add standard Gemini CLI arguments to an argparse parser."""
+    parser.add_argument("--api_key_file", type=str,
+                        default=None,
+                        help="Path to a Gemini API key file. If omitted, GEMINI_API_KEY is used.")
+    parser.add_argument("--vertexai", action="store_true")
+    parser.add_argument("--project", type=str, default="your-gcp-project")
+    parser.add_argument("--location", type=str, default="global")
+
+
+def make_client(args):
+    """Create a google.genai.Client from parsed CLI arguments."""
+    from google import genai
+    if args.vertexai:
+        client = genai.Client(vertexai=True, project=args.project,
+                              location=args.location)
+        logger.info("Using Vertex AI (project=%s, location=%s)",
+                    args.project, args.location)
+    else:
+        if args.api_key_file:
+            api_key = Path(args.api_key_file).read_text().strip()
+        else:
+            api_key = os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            raise ValueError("Set GEMINI_API_KEY or pass --api_key_file.")
+        client = genai.Client(api_key=api_key)
+    return client
+
+
+def extract_json_array(text):
+    """Extract and parse a JSON array from LLM response text."""
+    match = re.search(r"\[.*?\]", text, re.DOTALL)
+    if match:
+        try:
+            return json.loads(match.group())
+        except json.JSONDecodeError:
+            pass
+    return None

dataprocessing/common/pipeline.py

@@ -0,0 +1,153 @@
+"""Pipeline quality checks: staleness, missing data, empty laws.
+
+Default behavior is warn-and-continue.  Pass ``--strict`` to fail on
+issues that would otherwise only warn (for CI / batch runs).
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Datasets where every prompt is expected to have physical_laws.
+# Edge cases (empty perspectives, removed status) are the only exceptions.
+LAWS_REQUIRED_DATASETS = frozenset([
+    "wmb", "video_phy_2", "physics_iq", "video_phy_2", "openvid",
+])
+
+
+class PipelineCheck:
+    """Collect warnings and errors during a pipeline run, report at the end.
+
+    Usage::
+
+        checker = PipelineCheck(strict=args.strict)
+        # ... pipeline logic ...
+        checker.check_staleness(source_path, eval_path)
+        checker.check_missing_ratio(missing=5, total=279)
+        checker.check_empty_laws("wmb_195", [], "wmb")
+        # ... at the end ...
+        score = checker.report()
+        checker.finalize()   # raises if any FAIL-level issues
+    """
+
+    def __init__(self, strict: bool = False) -> None:
+        self.strict = strict
+        self._warnings: list[str] = []
+        self._errors: list[str] = []
+        self._missing_count = 0
+        self._total_count = 0
+        self._empty_laws_count = 0
+        self._stale_count = 0
+
+    # ------------------------------------------------------------------
+    # Individual checks
+    # ------------------------------------------------------------------
+
+    def check_staleness(self, source_path: Path, eval_path: Path) -> None:
+        """Warn/fail if source JSON is older than eval JSON."""
+        try:
+            src_mtime = os.path.getmtime(source_path)
+            eval_mtime = os.path.getmtime(eval_path)
+        except OSError:
+            return
+
+        if src_mtime < eval_mtime:
+            self._stale_count += 1
+            msg = (f"Source {source_path.name} (mtime {src_mtime:.0f}) "
+                   f"is older than eval {eval_path.name} (mtime {eval_mtime:.0f})")
+            if self.strict:
+                self._errors.append(msg)
+            else:
+                self._warnings.append(msg)
+
+    def check_missing_ratio(self, missing: int, total: int) -> None:
+        """Check ratio of unmatched vids.  >10% always fails."""
+        self._missing_count = missing
+        self._total_count = total
+
+        if total == 0:
+            return
+
+        ratio = missing / total
+        if ratio > 0.10:
+            self._errors.append(
+                f"Vid mismatch too high: {missing}/{total} ({ratio:.1%})")
+        elif ratio > 0.01:
+            msg = f"Moderate vid mismatch: {missing}/{total} ({ratio:.1%})"
+            if self.strict:
+                self._errors.append(msg)
+            else:
+                self._warnings.append(msg)
+        elif missing > 0:
+            self._warnings.append(
+                f"Minor vid mismatch: {missing}/{total} ({ratio:.1%})")
+
+    def check_empty_laws(self, vid: str, laws: list, dataset: str,
+                         resolved: bool = True) -> None:
+        """Check if a prompt is missing physical_laws that it should have.
+
+        Args:
+            resolved: Whether this vid was successfully matched to a source
+                entry.  Unresolved vids get a warn (already counted by
+                check_missing_ratio); only resolved-but-empty is an error.
+        """
+        if laws:
+            return
+        self._empty_laws_count += 1
+
+        if not resolved:
+            # Already captured by check_missing_ratio — just warn here
+            self._warnings.append(
+                f"No laws for {vid} (unresolved, dataset={dataset})")
+        elif dataset in LAWS_REQUIRED_DATASETS:
+            self._errors.append(f"Missing laws for {vid} (dataset={dataset})")
+        else:
+            self._warnings.append(
+                f"No laws for {vid} (dataset={dataset}, allowed)")
+
+    # ------------------------------------------------------------------
+    # Reporting
+    # ------------------------------------------------------------------
+
+    def report(self) -> float:
+        """Log summary and return quality score (0.0 - 1.0)."""
+        total = self._total_count or 1
+        missing_ratio = self._missing_count / total
+        empty_ratio = self._empty_laws_count / total
+
+        score = 1.0 - (
+            0.5 * missing_ratio          # unmatched vids are most critical
+            + 0.3 * empty_ratio           # missing laws degrade downstream use
+            + 0.2 * min(self._stale_count / max(total, 1), 1.0)  # stale sources
+        )
+        score = max(0.0, min(1.0, score))
+
+        logger.info("Pipeline Quality Score: %.2f", score)
+        if self._warnings:
+            logger.info("Warnings (%d):", len(self._warnings))
+            # Show first 10, summarize rest
+            for w in self._warnings[:10]:
+                logger.warning("  %s", w)
+            if len(self._warnings) > 10:
+                logger.warning("  ... and %d more",
+                               len(self._warnings) - 10)
+        if self._errors:
+            logger.error("Errors (%d):", len(self._errors))
+            for e in self._errors[:10]:
+                logger.error("  %s", e)
+            if len(self._errors) > 10:
+                logger.error("  ... and %d more", len(self._errors) - 10)
+
+        return score
+
+    def finalize(self) -> None:
+        """Raise if any FAIL-level issues were recorded."""
+        if self._errors:
+            raise RuntimeError(
+                f"Pipeline failed with {len(self._errors)} error(s). "
+                f"First: {self._errors[0]}"
+            )

dataprocessing/common/video_id.py

@@ -0,0 +1,221 @@
+"""Canonical video ID normalization and source-law loading.
+
+Every prompt in the pipeline gets a single canonical vid of the form
+``{dataset}_{original_key}`` (no domain prefix, no file extension).
+This module is the single source of truth for that mapping.
+
+The canonical vid is computed at runtime — it is NOT stored in source JSONs.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TypedDict
+
+logger = logging.getLogger(__name__)
+
+ROOT = Path(__file__).resolve().parents[2]
+
+# Ordered: first match wins for overlapping prompts (video_phy_2 before video_phy_2).
+PROMPT_SOURCES: list[tuple[str, Path]] = [
+    ("wmb", ROOT / "data/prompts/wmb/wmb.json"),
+    ("physics_iq", ROOT / "data/prompts/physics_iq/physics_iq.json"),
+    ("video_phy_2", ROOT / "data/prompts/video_phy_2/video_phy_2.json"),
+    ("openvid", ROOT / "data/prompts/openvid/openvid.json"),
+]
+
+
+class SourceEntry(TypedDict):
+    laws: list[str]
+    dataset: str
+    prompt: str
+    source_key: str
+
+
+# ---------------------------------------------------------------------------
+# normalize_vid: the single rule for canonical IDs
+# ---------------------------------------------------------------------------
+
+def normalize_vid(dataset: str, key: str) -> str:
+    """Pure function.  ``(dataset, key) -> canonical vid``.
+
+    Rules:
+    - Strip ``.mp4`` suffix from key
+    - Prefix with ``{dataset}_``
+    - For physics_iq perspectives, key is the full generated_video_name (without .mp4)
+
+    Examples::
+
+        normalize_vid("wmb", "195")                          -> "wmb_195"
+        normalize_vid("video_phy_2", "119")                       -> "video_phy_2_119"
+        normalize_vid("openvid", "abc.mp4")                  -> "openvid_abc"
+        normalize_vid("physics_iq", "0052_...-double-cradle") -> "physics_iq_0052_...-double-cradle"
+    """
+    key = key.removesuffix(".mp4")
+    return f"{dataset}_{key}"
+
+
+# ---------------------------------------------------------------------------
+# resolve_eval_vid: map eval-side video names back to canonical vids
+# ---------------------------------------------------------------------------
+
+def resolve_eval_vid(
+    eval_video: str,
+    eval_dataset_suffix: str,
+    reverse_map: dict[str, str],
+) -> str | None:
+    """Map an eval-side video name to its canonical vid.
+
+    ``reverse_map`` is built by :func:`load_source_laws` — it maps every
+    legacy identifier (first_frame_image stem, generated_video_name, numeric
+    key) to the canonical vid.
+
+    Falls back to numeric-suffix extraction for video_phy_2/video_phy_2 domain-prefix
+    mismatches (e.g. ``buoyancy_119`` -> key ``119``).
+    """
+    # Direct hit (covers physics_iq perspective names, openvid, exact wmb stems)
+    if eval_video in reverse_map:
+        return reverse_map[eval_video]
+
+    # Fallback: strip domain prefix, try numeric key
+    if "_" in eval_video:
+        numeric = eval_video.rsplit("_", 1)[-1]
+        if numeric in reverse_map:
+            return reverse_map[numeric]
+
+    return None
+
+
+# ---------------------------------------------------------------------------
+# load_source_laws: single loader for all source datasets
+# ---------------------------------------------------------------------------
+
+@dataclass
+class SourceLawsResult:
+    """Result of loading all source prompt JSONs."""
+    entries: dict[str, SourceEntry]           # canonical_vid -> SourceEntry
+    reverse_map: dict[str, str]               # legacy_id -> canonical_vid
+    stats: dict[str, int] = field(default_factory=dict)
+
+    def get(self, canonical_vid: str) -> SourceEntry | None:
+        return self.entries.get(canonical_vid)
+
+    def resolve_eval(self, eval_video: str, eval_ds_suffix: str) -> tuple[str, SourceEntry] | None:
+        """Resolve eval-side video name -> (canonical_vid, entry)."""
+        cvid = resolve_eval_vid(eval_video, eval_ds_suffix, self.reverse_map)
+        if cvid and cvid in self.entries:
+            return cvid, self.entries[cvid]
+        return None
+
+    @property
+    def cvid_to_legacies(self) -> dict[str, set[str]]:
+        """Inverse of reverse_map: canonical_vid -> set of legacy IDs."""
+        if not hasattr(self, "_cvid_to_legacies"):
+            inv: dict[str, set[str]] = {}
+            for lid, cvid in self.reverse_map.items():
+                inv.setdefault(cvid, set()).add(lid)
+            self._cvid_to_legacies = inv
+        return self._cvid_to_legacies
+
+
+def load_source_laws(
+    sources: list[tuple[str, Path]] | None = None,
+) -> SourceLawsResult:
+    """Load physical_laws from all canonical prompt JSONs.
+
+    Returns a :class:`SourceLawsResult` with:
+    - ``entries``: canonical_vid -> SourceEntry
+    - ``reverse_map``: legacy identifiers -> canonical_vid (for eval matching)
+    """
+    if sources is None:
+        sources = PROMPT_SOURCES
+
+    entries: dict[str, SourceEntry] = {}
+    reverse_map: dict[str, str] = {}
+    stats: dict[str, int] = {}
+
+    def _register(cvid: str, legacy_ids: list[str],
+                  laws: list[str], dataset: str,
+                  prompt: str, source_key: str) -> None:
+        """Register a canonical vid + its legacy aliases (first-match-wins)."""
+        if cvid in entries:
+            return
+        entries[cvid] = SourceEntry(
+            laws=laws, dataset=dataset, prompt=prompt, source_key=source_key,
+        )
+        # Register all legacy identifiers for reverse lookup
+        for lid in legacy_ids:
+            if lid and lid not in reverse_map:
+                reverse_map[lid] = cvid
+
+    for ds_name, path in sources:
+        if not path.exists():
+            logger.warning("Source not found: %s", path)
+            continue
+        with open(path) as f:
+            data = json.load(f)
+
+        prompts = data.get("prompts", data)
+        if not isinstance(prompts, dict):
+            continue
+
+        count = 0
+        for key, item in prompts.items():
+            if not isinstance(item, dict):
+                continue
+            if item.get("status") != "kept":
+                continue
+
+            laws = item.get("physical_laws", [])
+            if not laws:
+                continue
+
+            prompt_text = item.get("prompt", item.get("description", ""))
+
+            if ds_name == "physics_iq":
+                # Each perspective is a separate vid
+                for persp in item.get("perspectives", []):
+                    gvn = persp.get("generated_video_name", "")
+                    gvn_bare = gvn.removesuffix(".mp4")
+                    if not gvn_bare:
+                        continue
+                    cvid = normalize_vid(ds_name, gvn_bare)
+                    _register(
+                        cvid,
+                        legacy_ids=[gvn_bare],
+                        laws=laws, dataset=ds_name,
+                        prompt=prompt_text, source_key=key,
+                    )
+                    count += 1
+            elif ds_name == "openvid":
+                key_bare = key.removesuffix(".mp4")
+                cvid = normalize_vid(ds_name, key_bare)
+                _register(
+                    cvid,
+                    legacy_ids=[key_bare],
+                    laws=laws, dataset=ds_name,
+                    prompt=prompt_text, source_key=key,
+                )
+                count += 1
+            else:
+                # wmb, video_phy_2: first_frame_image stem is the legacy ID
+                # video_phy_2 entries with subset=video_phy_2 get dataset="video_phy_2"
+                effective_ds = item.get("subset", ds_name)
+                ff = item.get("first_frame_image", "")
+                ff_stem = Path(ff).stem if ff else key
+                cvid = normalize_vid(effective_ds, key)
+                _register(
+                    cvid,
+                    legacy_ids=[ff_stem, key],  # both stem and numeric key
+                    laws=laws, dataset=effective_ds,
+                    prompt=prompt_text, source_key=key,
+                )
+                count += 1
+
+        stats[ds_name] = count
+        logger.info("Loaded %d prompts from %s", count, path.name)
+
+    return SourceLawsResult(entries=entries, reverse_map=reverse_map, stats=stats)

dataprocessing/refine/enhance_prompts_physics.py

@@ -0,0 +1,237 @@
+"""Enhance prompts by adding expected physical phenomena using Gemini.
+
+Many prompts only describe the initial scene setup and action, but don't describe
+the expected physical outcome (e.g., liquid overflowing, dominoes falling in
+sequence, ball bouncing). This script uses Gemini to append a concise description
+of the expected physical phenomenon to each prompt.
+
+Usage:
+    # Dry run (preview changes without writing)
+    python -m dataprocessing.refine.enhance_prompts_physics --dry_run
+
+    # Run on all datasets
+    python -m dataprocessing.refine.enhance_prompts_physics
+
+    # Run on specific dataset
+    python -m dataprocessing.refine.enhance_prompts_physics --dataset physics_iq
+
+    # Vertex AI mode
+    python -m dataprocessing.refine.enhance_prompts_physics --vertexai
+"""
+
+import argparse
+import csv
+import json
+import logging
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+from dataprocessing.common.gemini import add_gemini_args, make_client
+
+logger = logging.getLogger(__name__)
+
+GEMINI_MODEL = "gemini-2.5-flash"
+
+SYSTEM_PROMPT = """\
+You are a physics expert helping improve text prompts for a video generation benchmark.
+
+Your task: given a prompt that describes a physical scene, check whether it explicitly
+describes the **expected physical outcome/phenomenon**. If the prompt only describes
+the setup and initial action but NOT the resulting physics, add a concise sentence
+describing the expected physical phenomenon.
+
+Rules:
+1. If the prompt ALREADY describes the physical outcome adequately, return it unchanged.
+2. If the prompt is MISSING the physical outcome, insert ONE concise sentence describing
+   what physically happens as a result of the described action.
+3. Keep the addition natural and concise (1 sentence, ~10-20 words).
+4. Do NOT change the existing text — only append/insert the new physics description.
+5. Keep any "Static shot with no camera movement." or similar camera notes at the END.
+6. Return ONLY the enhanced prompt text, no explanation, no quotes.
+
+Examples:
+
+Input: "A bright red liquid being poured from a dispenser into a glass which is placed on a dark baking tray on a wooden table. Static shot with no camera movement."
+Output: "A bright red liquid being poured from a dispenser into a glass which is placed on a dark baking tray on a wooden table. The liquid overflows from the glass and spills onto the baking tray. Static shot with no camera movement."
+
+Input: "A row of colorful wooden blocks lined up on a wooden table with a wooden stick attached to a black rotating platform. The platform rotates clockwise and the wooden stick hits the first block as it rotates. Static shot with no camera movement."
+Output: "A row of colorful wooden blocks lined up on a wooden table with a wooden stick attached to a black rotating platform. The platform rotates clockwise and the wooden stick hits the first block as it rotates. The blocks topple over one by one in a domino chain reaction. Static shot with no camera movement."
+
+Input: "A basketball is dropped from a rooftop and bounces on the pavement, each bounce lower than the last."
+Output: "A basketball is dropped from a rooftop and bounces on the pavement, each bounce lower than the last."
+(Already describes the physics — returned unchanged.)
+"""
+
+USER_TEMPLATE = """\
+Category: {category}
+Prompt: {prompt}"""
+
+
+def enhance_prompt(client, prompt: str, category: str, max_retries: int = 3) -> str | None:
+    """Call Gemini to enhance one prompt with physical phenomenon description."""
+    user_msg = USER_TEMPLATE.format(prompt=prompt, category=category)
+
+    for attempt in range(max_retries):
+        try:
+            resp = client.models.generate_content(
+                model=GEMINI_MODEL,
+                contents=[user_msg],
+                config={"system_instruction": SYSTEM_PROMPT},
+            )
+            text = resp.text.strip().strip('"').strip("'")
+            if text:
+                return text
+            logger.warning("Empty response (attempt %d)", attempt + 1)
+        except Exception as e:
+            logger.warning("API error (attempt %d/%d): %s", attempt + 1, max_retries, e)
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)
+    return None
+
+
+def process_physics_iq(client, dry_run: bool = False):
+    """Enhance Physics-IQ descriptions.csv prompts."""
+    csv_path = Path("data/prompts/physics_iq/descriptions.csv")
+    logger.info("=== Physics-IQ: %s ===", csv_path)
+
+    with open(csv_path, newline="") as f:
+        reader = csv.DictReader(f)
+        rows = [r for r in reader if "take-2" not in r.get("scenario", "")]
+
+    unique_descs: dict[str, list[int]] = {}
+    for i, row in enumerate(rows):
+        desc = row["description"]
+        unique_descs.setdefault(desc, []).append(i)
+
+    logger.info("Total rows: %d, unique descriptions: %d", len(rows), len(unique_descs))
+
+    enhanced_map: dict[str, str] = {}
+    changed = 0
+    for j, (desc, indices) in enumerate(unique_descs.items()):
+        category = rows[indices[0]]["category"]
+        logger.info("[%d/%d] %s — %s", j + 1, len(unique_descs), category, desc[:80])
+
+        if dry_run:
+            continue
+
+        result = enhance_prompt(client, desc, category)
+        if result and result != desc:
+            enhanced_map[desc] = result
+            changed += 1
+            logger.info("  CHANGED → %s", result[:100])
+        else:
+            logger.info("  unchanged")
+        time.sleep(0.3)
+
+    if dry_run:
+        logger.info("DRY RUN — no changes written")
+        return
+
+    if changed > 0:
+        backup = csv_path.with_suffix(f".csv.bak_{datetime.now():%Y%m%d_%H%M%S}")
+        backup.write_text(csv_path.read_text())
+        logger.info("Backup → %s", backup)
+
+        for row in rows:
+            if row["description"] in enhanced_map:
+                row["description"] = enhanced_map[row["description"]]
+
+        with open(csv_path, "w", newline="") as f:
+            writer = csv.DictWriter(f, fieldnames=["scenario", "description", "category", "generated_video_name"])
+            writer.writeheader()
+            writer.writerows(rows)
+
+        logger.info("Physics-IQ: %d/%d unique descriptions enhanced", changed, len(unique_descs))
+    else:
+        logger.info("Physics-IQ: no changes needed")
+
+
+_JSON_DATASETS = {
+    "video_phy_2": (Path("data/prompts/video_phy_2/video_phy_2.json"), "VideoPhy-2", ("_domain",)),
+    "wmb": (Path("data/prompts/wmb/wmb.json"), "WorldModelBench", ("_domain", "wmb_domain")),
+    "openvid": (Path("data/prompts/openvid/openvid.json"), "OpenVid", ("domain",)),
+}
+
+
+def _process_json_dataset(client, json_path: Path, name: str,
+                          domain_keys: tuple[str, ...],
+                          dry_run: bool = False):
+    """Enhance prompts in a JSON dataset file."""
+    logger.info("=== %s: %s ===", name, json_path)
+
+    with open(json_path) as f:
+        data = json.load(f)
+
+    changed = 0
+    total = 0
+    for pid, p in data["prompts"].items():
+        if p.get("status") != "kept":
+            continue
+        total += 1
+        prompt = p["prompt"]
+        domain = next((p[k] for k in domain_keys if p.get(k)), "")
+        logger.info("[%s %s] %s", domain, pid, prompt[:80])
+
+        if dry_run:
+            continue
+
+        result = enhance_prompt(client, prompt, domain)
+        if result and result != prompt:
+            p["prompt"] = result
+            changed += 1
+            logger.info("  CHANGED → %s", result[:100])
+        else:
+            logger.info("  unchanged")
+        time.sleep(0.3)
+
+    if dry_run:
+        logger.info("DRY RUN — no changes written")
+        return
+
+    if changed > 0:
+        backup = json_path.with_suffix(f".json.bak_{datetime.now():%Y%m%d_%H%M%S}")
+        backup.write_text(json_path.read_text())
+        logger.info("Backup → %s", backup)
+
+        with open(json_path, "w") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+
+        logger.info("%s: %d/%d prompts enhanced", name, changed, total)
+    else:
+        logger.info("%s: no changes needed", name)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Enhance prompts with physical phenomena via Gemini")
+    parser.add_argument("--dataset", choices=["physics_iq", "video_phy_2", "wmb", "openvid", "all"], default="all")
+    add_gemini_args(parser)
+    parser.add_argument("--dry_run", action="store_true", help="Preview without making changes")
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="[%(asctime)s] %(message)s",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+
+    client = make_client(args) if not args.dry_run else None
+
+    if args.dataset in ("all", "physics_iq"):
+        process_physics_iq(client, dry_run=args.dry_run)
+        logger.info("")
+
+    datasets = list(_JSON_DATASETS) if args.dataset == "all" else (
+        [args.dataset] if args.dataset in _JSON_DATASETS else []
+    )
+    for ds in datasets:
+        path, name, dk = _JSON_DATASETS[ds]
+        _process_json_dataset(client, path, name, dk, dry_run=args.dry_run)
+        logger.info("")
+
+    logger.info("Done.")
+
+
+if __name__ == "__main__":
+    main()

dataprocessing/refine/gen_hard_subset.py

@@ -0,0 +1,294 @@
+"""Generate Anonymous-Hard subset from Qwen per-law eval results.
+
+For each prompt, computes a physics micro-avg from per-law scores
+(all 13 laws), averaged across all models.
+Keeps prompts with cross-model avg < threshold.
+
+Physical laws are sourced from the canonical prompt JSONs (not from eval
+JSONs, which may contain stale vocabulary).
+
+Usage:
+    # Default: threshold 1.75, overwrite existing hard subset
+    python -m dataprocessing.refine.gen_hard_subset
+
+    # Custom threshold, write to a different file
+    python -m dataprocessing.refine.gen_hard_subset --threshold 1.50 \
+        --output data/prompts/anonymous_hard_subset_150.json
+
+    # Dry run: print stats without writing
+    python -m dataprocessing.refine.gen_hard_subset --dry-run
+
+    # Strict mode: fail on data quality issues
+    python -m dataprocessing.refine.gen_hard_subset --strict
+"""
+
+import argparse
+import json
+import logging
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+
+from dataprocessing.common.pipeline import PipelineCheck
+from dataprocessing.common.video_id import PROMPT_SOURCES, load_source_laws
+
+logger = logging.getLogger(__name__)
+
+ROOT = Path(__file__).resolve().parents[2]
+VIDEOS_DIR = ROOT / "data/videos"
+OUTPUT_PATH = ROOT / "data/prompts/anonymous_hard_subset.json"
+
+# Dataset suffixes that appear in video dir names.
+DATASET_SUFFIXES = ["video_phy_2", "physics_iq", "openvid", "wmb"]
+
+
+def parse_model_dataset(dirname: str) -> tuple[str, str] | None:
+    """Extract (model, dataset) from a directory name like 'ltx-2-video_phy_2'."""
+    for ds in DATASET_SUFFIXES:
+        if dirname.endswith(f"-{ds}"):
+            model = dirname[:-(len(ds) + 1)]
+            return model, ds
+    return None
+
+
+def find_latest_eval(dirpath: Path, evaluator: str = "qwen") -> Path | None:
+    """Find the latest batched eval JSON for the given evaluator, fallback to gemini."""
+    evals = sorted(dirpath.glob(f"eval_{evaluator}_2*.json"))
+    if evals:
+        return evals[-1]
+    if evaluator != "gemini":
+        gemini = sorted(dirpath.glob("eval_gemini*_2*.json"))
+        if gemini:
+            return gemini[-1]
+    return None
+
+
+def load_eval_scores(eval_path: Path) -> list[dict]:
+    """Load eval JSON and extract per-video physics micro-avg.
+
+    Computes micro-avg from per-law scores (all laws).
+    Follows the same scoring approach as score_histogram / rank.md.
+
+    Returns list of dicts with keys: video, prompt, phys_micro_avg, n_laws_scored.
+    """
+    with open(eval_path) as f:
+        data = json.load(f)
+
+    entries = []
+    for r in data.get("results", []):
+        video = r.get("video", "")
+        prompt = r.get("prompt", "")
+        if not video:
+            continue
+
+        # Per-law physical scores (null-aware, supports v1 and v2 formats)
+        phys = r.get("physical", {})
+        if not isinstance(phys, dict):
+            continue
+        laws = phys.get("laws", {})
+
+        scored_vals = []
+        for law_name, law_data in laws.items():
+            if not isinstance(law_data, dict):
+                continue
+            score = law_data.get("score")
+            is_scored = (law_data.get("status") == "scored"
+                         or law_data.get("valid", False))
+            if is_scored and score is not None:
+                scored_vals.append(score)
+
+        if not scored_vals:
+            continue
+
+        entries.append({
+            "video": video,
+            "prompt": prompt,
+            "phys_micro_avg": sum(scored_vals) / len(scored_vals),
+            "n_laws_scored": len(scored_vals),
+        })
+    return entries
+
+
+def main(argv: list[str] | None = None):
+    parser = argparse.ArgumentParser(
+        description="Generate Anonymous-Hard subset from Gemini eval scores")
+    parser.add_argument("--threshold", type=float, default=3.00,
+                        help="Physics micro-avg threshold (default: 3.00)")
+    parser.add_argument("--output", type=str, default=None,
+                        help="Output path (default: data/prompts/anonymous_hard_subset.json)")
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Print stats without writing")
+    parser.add_argument("--strict", action="store_true",
+                        help="Fail on data quality issues (for CI)")
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="[%(asctime)s] %(message)s",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+
+    checker = PipelineCheck(strict=args.strict)
+
+    # ---- Step 1: Collect per-model physics micro-avg for every video ----
+    # {eval_video: {model: phys_micro_avg}}
+    video_scores: dict[str, dict] = defaultdict(dict)
+    video_prompts: dict[str, str] = {}
+    video_eval_ds: dict[str, str] = {}   # eval-side dataset suffix
+    eval_paths_by_ds: dict[str, Path] = {}
+
+    for d in sorted(VIDEOS_DIR.iterdir()):
+        if not d.is_dir():
+            continue
+        parsed = parse_model_dataset(d.name)
+        if parsed is None:
+            continue
+        model, dataset = parsed
+        if "real_world" in model:
+            continue
+
+        eval_path = find_latest_eval(d)
+        if eval_path is None:
+            continue
+
+        eval_paths_by_ds[dataset] = eval_path
+        entries = load_eval_scores(eval_path)
+        logger.info("Loaded %d entries from %s", len(entries), eval_path.name)
+
+        for e in entries:
+            vid = e["video"]
+            video_scores[vid][model] = e["phys_micro_avg"]
+            video_prompts[vid] = e["prompt"]
+            video_eval_ds[vid] = dataset
+
+    logger.info("Total unique videos with scores: %d", len(video_scores))
+
+    # ---- Step 2: Compute cross-model average ----
+    video_difficulty = {}
+    for vid, model_scores in video_scores.items():
+        vals = list(model_scores.values())
+        avg = sum(vals) / len(vals)
+        video_difficulty[vid] = {
+            "phys_micro_avg": round(avg, 3),
+            "n_models": len(model_scores),
+        }
+
+    # ---- Step 3: Filter by threshold ----
+    hard_vids = [
+        vid for vid, diff in video_difficulty.items()
+        if diff["phys_micro_avg"] < args.threshold
+    ]
+    hard_vids.sort(key=lambda v: video_difficulty[v]["phys_micro_avg"])
+
+    logger.info("Threshold < %.2f: %d / %d videos",
+                args.threshold, len(hard_vids), len(video_difficulty))
+
+    # ---- Step 4: Look up physical_laws via canonical vid matching ----
+    source = load_source_laws()
+
+    # Check staleness: only compare each source JSON against its matching eval
+    DS_TO_EVAL_SUFFIX = {
+        "wmb": "wmb", "video_phy_2": "video_phy_2", "physics_iq": "physics_iq",
+        "openvid": "openvid",
+    }
+    for ds_name, src_path in PROMPT_SOURCES:
+        eval_suffix = DS_TO_EVAL_SUFFIX.get(ds_name)
+        if eval_suffix and eval_suffix in eval_paths_by_ds:
+            checker.check_staleness(src_path, eval_paths_by_ds[eval_suffix])
+
+    missing = 0
+    prompts_out = []
+    seen_disk_vids: dict[str, int] = {}  # disk_vid -> index in prompts_out
+    for eval_vid in hard_vids:
+        eval_ds = video_eval_ds.get(eval_vid, "")
+        matched = source.resolve_eval(eval_vid, eval_ds)
+
+        if matched:
+            cvid, entry = matched
+            laws = entry["laws"]
+            dataset = entry["dataset"]
+            prompt = entry["prompt"] or video_prompts.get(eval_vid, "")
+            legacy_ids = source.cvid_to_legacies.get(cvid, set())
+            disk_vid = max(legacy_ids, key=len) if legacy_ids else eval_vid
+        else:
+            # Not in kept source — skip (removed, safety-blocked, etc.)
+            missing += 1
+            continue
+
+        # Deduplicate: different eval_vid values can resolve to the same
+        # disk_vid via legacy aliases.  Keep the entry with more models.
+        if disk_vid in seen_disk_vids:
+            idx = seen_disk_vids[disk_vid]
+            existing = prompts_out[idx]
+            if video_difficulty[eval_vid]["n_models"] > existing["difficulty"]["n_models"]:
+                prompts_out[idx] = {
+                    "video": disk_vid,
+                    "dataset": dataset,
+                    "prompt": prompt,
+                    "physical_laws": laws,
+                    "difficulty": video_difficulty[eval_vid],
+                    "per_model_scores": dict(video_scores[eval_vid]),
+                }
+            continue
+
+        checker.check_empty_laws(disk_vid, laws, dataset,
+                                 resolved=matched is not None)
+
+        seen_disk_vids[disk_vid] = len(prompts_out)
+        prompts_out.append({
+            "video": disk_vid,
+            "dataset": dataset,
+            "prompt": prompt,
+            "physical_laws": laws,
+            "difficulty": video_difficulty[eval_vid],
+            "per_model_scores": dict(video_scores[eval_vid]),
+        })
+
+    checker.check_missing_ratio(missing, len(hard_vids))
+
+    # ---- Step 5: Compute stats and report ----
+    by_dataset = Counter(p["dataset"] for p in prompts_out)
+    law_counts = Counter()
+    for p in prompts_out:
+        for law in p["physical_laws"]:
+            law_counts[law] += 1
+
+    output = {
+        "description": (
+            f"Anonymous-Hard: prompts where cross-model physics micro-avg < {args.threshold} "
+            f"(Qwen, per-law scores, all 13 laws)"
+        ),
+        "threshold": args.threshold,
+        "scoring_mode": "phys_micro_avg",
+        "judge": "qwen",
+        "num_prompts": len(prompts_out),
+        "by_dataset": dict(by_dataset.most_common()),
+        "prompts": prompts_out,
+    }
+
+    logger.info("=" * 60)
+    logger.info("Hard subset: %d prompts", len(prompts_out))
+    logger.info("By dataset:")
+    for ds, cnt in by_dataset.most_common():
+        logger.info("  %s: %d", ds, cnt)
+    logger.info("Physical law counts:")
+    for law, cnt in law_counts.most_common():
+        logger.info("  %s: %d", law, cnt)
+
+    score = checker.report()
+
+    if args.dry_run:
+        logger.info("(dry-run — no file written)")
+        checker.finalize()
+        return
+
+    out_path = Path(args.output) if args.output else OUTPUT_PATH
+    with open(out_path, "w") as f:
+        json.dump(output, f, indent=2, ensure_ascii=False)
+    logger.info("Saved → %s", out_path)
+
+    checker.finalize()
+
+
+if __name__ == "__main__":
+    main()

dataprocessing/refine/gen_humaneval_set.py

@@ -0,0 +1,16 @@
+"""Disabled human-eval prompt-set generator for the anonymous release.
+
+The original generator writes prompt-selection JSON artifacts that are not part
+of this code release.
+"""
+
+
+def main(argv=None):
+    raise RuntimeError(
+        "gen_humaneval_set is not included in this release because it writes "
+        "prompt-selection JSON artifacts that are omitted."
+    )
+
+
+if __name__ == "__main__":
+    main()

evals/eval_types.py

@@ -0,0 +1,154 @@
+"""Typed data structures for VLM evaluation pipeline — parse, don't validate.
+
+Every constructor enforces types and invariants.  Once you have a PromptEntry
+or LawScore, the data is guaranteed clean.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# PromptEntry — parsed from prompts JSON at the boundary
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class PromptEntry:
+    """A parsed, validated prompt entry for evaluation.
+
+    Required: prompt must be non-empty.
+    physical_laws: None means the field was absent (skip physical eval),
+                   [] means explicitly empty.
+    """
+    prompt: str
+    physical_laws: list[str] | None = None
+    domain: str = ""
+    first_frame_image: str = ""
+    dataset: str = ""
+    video: str = ""
+
+    def __post_init__(self):
+        if not isinstance(self.prompt, str) or not self.prompt:
+            raise ValueError(f"PromptEntry.prompt must be non-empty str, got {self.prompt!r}")
+
+    @property
+    def has_physical_laws(self) -> bool:
+        return self.physical_laws is not None
+
+
+def parse_prompt_entry(raw: dict, *, key: str = "") -> PromptEntry | None:
+    """Parse a raw JSON dict into PromptEntry.
+
+    Returns None on bad data (tolerant — logs warning instead of raising).
+    """
+    prompt = raw.get("prompt") or raw.get("description") or ""
+    if not isinstance(prompt, str) or not prompt.strip():
+        logger.warning("Skipping entry %r: missing or empty prompt", key)
+        return None
+
+    physical_laws = raw.get("physical_laws")
+    if physical_laws is not None and not isinstance(physical_laws, list):
+        logger.warning("Entry %r: physical_laws is not a list, ignoring", key)
+        physical_laws = None
+
+    domain = raw.get("_domain") or raw.get("domain") or raw.get("our_domain") or ""
+
+    try:
+        return PromptEntry(
+            prompt=prompt.strip().strip('"'),
+            physical_laws=physical_laws,
+            domain=str(domain),
+            first_frame_image=str(raw.get("first_frame_image") or ""),
+            dataset=str(raw.get("dataset") or ""),
+            video=str(raw.get("video") or ""),
+        )
+    except (ValueError, TypeError) as e:
+        logger.warning("Skipping entry %r: %s", key, e)
+        return None
+
+
+# ---------------------------------------------------------------------------
+# LawScore — per-law evaluation result
+# ---------------------------------------------------------------------------
+
+SCORED = "scored"
+NOT_OBSERVED = "not_observed"
+FAILED = "failed"
+_VALID_STATUSES = frozenset({SCORED, NOT_OBSERVED, FAILED})
+
+
+@dataclass(frozen=True)
+class LawScore:
+    """Result of scoring one physical law on one video."""
+    law: str
+    score: int | None
+    status: str  # SCORED | NOT_OBSERVED | FAILED
+    sub_answers: dict[str, str] | None = None  # raw yes/no/na per sub-question
+
+    def __post_init__(self):
+        if self.status not in _VALID_STATUSES:
+            raise ValueError(
+                f"LawScore.status must be one of {_VALID_STATUSES}, got {self.status!r}"
+            )
+        if self.status == SCORED and self.score is None:
+            raise ValueError(f"LawScore({self.law!r}): status='scored' but score is None")
+
+    @classmethod
+    def scored(cls, law: str, score: int, sub_answers: dict[str, str] | None = None) -> LawScore:
+        return cls(law=law, score=score, status=SCORED, sub_answers=sub_answers)
+
+    @classmethod
+    def not_observed(cls, law: str, sub_answers: dict[str, str] | None = None) -> LawScore:
+        return cls(law=law, score=None, status=NOT_OBSERVED, sub_answers=sub_answers)
+
+    @classmethod
+    def failed(cls, law: str) -> LawScore:
+        return cls(law=law, score=None, status=FAILED)
+
+    def to_dict(self) -> dict:
+        d: dict = {"score": self.score, "status": self.status}
+        if self.sub_answers is not None:
+            d["sub_answers"] = self.sub_answers
+        return d
+
+
+# ---------------------------------------------------------------------------
+# PhysicalSummary — aggregated physical results for one video
+# ---------------------------------------------------------------------------
+
+@dataclass
+class PhysicalSummary:
+    """Aggregated physical evaluation for one video."""
+    laws: dict[str, LawScore]
+    missing_laws: list[str]
+    coverage: float
+    avg: float | None
+
+    @classmethod
+    def from_law_scores(
+        cls, law_scores: dict[str, LawScore], total_laws: int,
+    ) -> PhysicalSummary:
+        scored_values = [
+            ls.score for ls in law_scores.values() if ls.status == SCORED
+        ]
+        missing = [name for name, ls in law_scores.items() if ls.status == FAILED]
+        coverage = len(scored_values) / total_laws if total_laws else 0
+        avg = sum(scored_values) / len(scored_values) if scored_values else None
+        return cls(
+            laws=law_scores,
+            missing_laws=missing,
+            coverage=round(coverage, 4),
+            avg=round(avg, 4) if avg is not None else None,
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "laws": {name: ls.to_dict() for name, ls in self.laws.items()},
+            "missing_laws": self.missing_laws,
+            "coverage": self.coverage,
+            "avg": self.avg,
+        }

evals/human_eval/app.py

@@ -0,0 +1,869 @@
+"""Human evaluation annotation app."""
+import hashlib
+import json
+import random
+import sqlite3
+from functools import wraps
+from pathlib import Path
+
+from flask import (
+    Flask,
+    g,
+    redirect,
+    render_template,
+    request,
+    send_from_directory,
+    session,
+    url_for,
+    jsonify,
+    abort,
+)
+
+from human_eval.config import (
+    N_ANNOTATORS_PER_VIDEO,
+    ASSIGNMENT_TTL_HOURS,
+    VIDEO_DATA_DIR,
+    DB_PATH,
+    SECRET_KEY,
+    DISAGREEMENT_TOP_K,
+    STATUS_ASSIGNED,
+    STATUS_COMPLETED,
+    STATUS_PARTIAL,
+    STATUS_SKIPPED,
+    COMPARISON_MODELS,
+    MODELS_PER_GROUP,
+    COMPLETION_SURVEY_URL,
+    extract_model,
+    get_batch_size,
+    VALID_COHORTS,
+    TEST_COHORTS,
+    COHORT_COMPLETION_CODE,
+)
+from human_eval.db import init_db, get_db, pending_assignment_sql
+from human_eval.assign import assign_comparison_batch
+
+# ---------------------------------------------------------------------------
+# Import CRITERIA & DOMAIN_SUBSCORES from physics_criteria (single source of truth)
+# ---------------------------------------------------------------------------
+import sys
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+from evals.physics_criteria import (
+    CRITERIA, CRITERIA_EN, CRITERIA_ZH, DOMAIN_SUBSCORES,
+    HUMAN_CRITERIA, HUMAN_CRITERIA_BY_KEY, HUMAN_DOMAINS,
+)
+
+def _all_criteria_for_lang(lang: str) -> list[tuple[str, str]]:
+    """Return a flat, deduplicated list of (law_key, description) for display."""
+    src = CRITERIA_ZH if lang == "zh" else CRITERIA_EN
+    return [(k, src[k]) for k in src]
+
+def _get_physical_dims(assignment) -> list[tuple[str, str]]:
+    """Parse physical_laws JSON from a video/assignment row and return (law, description) pairs."""
+    laws = json.loads(assignment["physical_laws"])
+    return [(law, CRITERIA.get(law, law)) for law in laws]
+
+
+# ---------------------------------------------------------------------------
+# General dimensions — derived from HumanCriterion (General domain)
+# ---------------------------------------------------------------------------
+_SCORE_LABELS = {1: "Completely implausible", 2: "Largely implausible", 3: "Partially plausible", 4: "Mostly plausible", 5: "Fully plausible"}
+_SCORE_LABELS_ZH = {1: "完全不合理", 2: "大部分不合理", 3: "部分合理", 4: "大部分合理", 5: "完全合理"}
+
+GENERAL_DIMS = [
+    (
+        c.key, c.name, list(range(1, 6)),
+        f"{c.question} ({c.note})" if c.note else c.question,
+        _SCORE_LABELS,
+    )
+    for c in HUMAN_DOMAINS["General"]
+]
+
+GENERAL_DIMS_ZH = [
+    (
+        c.key, c.name_zh, list(range(1, 6)),
+        f"{c.question_zh}（{c.note_zh}）" if c.note_zh else c.question_zh,
+        _SCORE_LABELS_ZH,
+    )
+    for c in HUMAN_DOMAINS["General"]
+]
+
+
+def _save_annotation(db, assignment_id, general_scores, physical_scores, physical_dims, meta_ver, note="", play_count=0, stay_seconds=0.0, na_laws=None):
+    """Upsert annotation + annotation_items for a single assignment."""
+    if na_laws is None:
+        na_laws = []
+    law_keys = [key for key, _ in physical_dims]
+    scores_json = json.dumps({
+        "general": general_scores,
+        "physical": physical_scores,
+        "physical_laws": law_keys,
+    })
+    na_laws_json = json.dumps(na_laws)
+
+    existing = db.execute(
+        "SELECT id FROM annotations WHERE assignment_id = ?", (assignment_id,)
+    ).fetchone()
+
+    if existing:
+        annotation_id = existing["id"]
+        db.execute(
+            "UPDATE annotations SET scores_json = ?, metadata_version = ?, note = ?, play_count = ?, stay_seconds = ?, na_laws = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?",
+            (scores_json, meta_ver, note, play_count, stay_seconds, na_laws_json, annotation_id),
+        )
+        db.execute("DELETE FROM annotation_items WHERE annotation_id = ?", (annotation_id,))
+    else:
+        cur = db.execute(
+            "INSERT INTO annotations (assignment_id, scores_json, metadata_version, note, play_count, stay_seconds, na_laws) VALUES (?, ?, ?, ?, ?, ?, ?)",
+            (assignment_id, scores_json, meta_ver, note, play_count, stay_seconds, na_laws_json),
+        )
+        annotation_id = cur.lastrowid
+
+    items = [(annotation_id, key, None, general_scores[key]) for key in general_scores]
+    items += [(annotation_id, key, key, physical_scores[key]) for key in physical_scores if physical_scores[key] is not None]
+    db.executemany(
+        "INSERT INTO annotation_items (annotation_id, dimension, law, score) VALUES (?, ?, ?, ?)",
+        items,
+    )
+
+
+
+def _extract_scores(prefix, physical_dims):
+    """Parse general + physical scores and NA laws from the current request form."""
+    general = {}
+    for key, _, _, _, _ in GENERAL_DIMS:
+        val = request.form.get(f"{prefix}{key}")
+        if val:
+            general[key] = int(val)
+    physical = {}
+    for key, _ in physical_dims:
+        val = request.form.get(f"{prefix}{key}")
+        if val and val != "null":
+            physical[key] = int(val)
+    # NA laws come from a separate comma-separated hidden input
+    na_raw = request.form.get(f"{prefix}na_laws", "")
+    na_laws = [k for k in na_raw.split(",") if k]
+    return general, physical, na_laws
+
+
+# ---------------------------------------------------------------------------
+# Demo data (hardcoded, editable)
+# ---------------------------------------------------------------------------
+
+DEMO_ENTRIES = [
+    {
+        "video_url": "/video/wan2.2-i2v-a14b/collision_283.mp4",
+        "prompt": "A water balloon is thrown at a large target made of cardboard; it bursts cleanly.",
+        "prompt_zh": "一个水气球被投向一个纸板做的大靶子，干脆地炸裂开来。",
+        "scores": {"SA": 4, "PTV": 3, "persistence": 2},
+        "physical_dims": [
+            ("collision", "After impact, is there reasonable bounce/shatter/deformation? Does response match impact force?"),
+            ("material", "Do different materials respond according to their properties? Glass shatters? Rubber bounces?"),
+            ("momentum", "After collision, is the direction of motion reasonable? Ignore speed magnitude."),
+            ("impenetrability", "Do objects maintain impenetrability — no passing through each other?"),
+        ],
+        "physical_dims_zh": [
+            ("collision", "碰撞后是否有合理的弹跳/破碎/变形？响应是否与撞击力匹配？"),
+            ("material", "不同材质是否按其属性反应？玻璃碎裂？橡胶弹跳？"),
+            ("momentum", "碰撞后运动方向是否合理？忽略速度大小。"),
+            ("impenetrability", "物体是否保持不可穿透性——没有互相穿过？"),
+        ],
+        "physical_scores": {"collision": 4, "material": 3, "momentum": 2, "impenetrability": 1},
+        "rationale_general": {
+            "SA": "The video shows a water balloon being thrown at a target and bursting. The overall scene matches the prompt well.",
+            "PTV": "The balloon approaches and bursts on contact, but because the target behaves like an inflatable object rather than cardboard, the physical interaction sequence is only partially correct.",
+            "persistence": "The large target morphs from cardboard into an inflatable object mid-video — a major material/shape inconsistency.",
+        },
+        "rationale_general_zh": {
+            "SA": "视频展示了一个水气球被投向靶子并炸裂的过程，整体场景与提示词匹配良好。",
+            "PTV": "气球接近并在接触时炸裂，但由于靶子表现得像充气物体而非纸板，物理交互序列仅部分正确。",
+            "persistence": "大靶子在视频中途从纸板变形为充气物体——存在严重的材质/形状不一致。",
+        },
+        "rationale_physical": {
+            "collision": "The balloon deforms and shatters on impact, which is a reasonable response to the collision force.",
+            "material": "The water balloon bursts correctly on impact, but the cardboard target expands/inflates unnaturally — real cardboard would not swell like that.",
+            "momentum": "After the balloon bursts, the water and debris should stop and fall downward, but they continue moving unnaturally.",
+            "impenetrability": "The balloon passes through the target instead of bouncing off or bursting on the surface — objects should not penetrate each other.",
+        },
+        "rationale_physical_zh": {
+            "collision": "气球在撞击时变形并破裂，这是对碰撞力的合理响应。",
+            "material": "水气球在撞击时正确地破裂，但纸板靶子不自然地膨胀——真实的纸板不会像那样膨胀。",
+            "momentum": "气球破裂后，水和碎片应该停下并向下掉落，但它们继续不自然地移动。",
+            "impenetrability": "气球穿过了靶子，而不是在表面弹开或破裂——物体不应互相穿透。",
+        },
+    },
+    {
+        "video_url": "/video/cosmos-predict2.5-14b/88H1BBqFzXQ_1_118to222.mp4",
+        "prompt": "A heavy car tire rolls over a green bottle on concrete, crushing it flat. The trapped liquid bursts from the broken bottle and rapidly flows outward, spreading across the ground in an expanding puddle.",
+        "prompt_zh": "一个沉重的汽车轮胎在混凝土地面上碾过一个绿色瓶子，将其压扁。瓶中的液体从破碎的瓶子中喷出，迅速向外流动，在地面上形成一个不断扩大的水洼。",
+        "scores": {"SA": 3, "PTV": 1, "persistence": 3},
+        "physical_dims": [
+            ("flow_dynamics", "Does the liquid's overall motion behave realistically over time — flowing along surfaces, spreading, draining naturally?"),
+            ("material", "Does each material respond according to its properties? (glass shatters, rubber bounces, metal is rigid, cloth deforms softly, etc.)"),
+            ("collision", "After impact, is there reasonable bounce/shatter/deformation? Does response match impact force?"),
+            ("fluid_continuity", "Does the liquid maintain physical continuity and mass conservation? Brief splash separation is acceptable."),
+        ],
+        "physical_dims_zh": [
+            ("flow_dynamics", "液体整体流动是否符合物理——沿表面流动、铺展、排出是否自然？"),
+            ("material", "每种材料的响应是否符合其属性？玻璃碎裂、橡胶弹回、金属坚硬、布料柔软变形。"),
+            ("collision", "物体撞击后是否有合理的反弹/碎裂/变形？撞击力度与响应程度是否匹配？"),
+            ("fluid_continuity", "液体是否保持物理连续性与质量守恒——无不合理的断裂、消失或凭空生成？短暂飞溅分离可接受。"),
+        ],
+        "physical_scores": {"flow_dynamics": 4, "material": 1, "collision": 1, "fluid_continuity": 4},
+        "rationale_general": {
+            "SA": "The liquid bursting from the broken bottle and spreading into a puddle is present, but the first part — a heavy tire rolling over and crushing the bottle flat — is missing.",
+            "PTV": "The bottle breaks without any logical cause — there is no visible impact or force that triggers the rupture.",
+            "persistence": "The tire and ground maintain consistent appearance, but the text on the bottle label changes mid-video.",
+        },
+        "rationale_general_zh": {
+            "SA": "被困的液体从破碎的瓶子中爆裂而出并在地面形成水洼，这部分有体现；但前半部分——沉重的汽车轮胎碾过绿色瓶子并将其压扁——缺失。",
+            "PTV": "瓶子没有任何逻辑原因就破裂了——没有可见的撞击或外力触发破裂。",
+            "persistence": "轮胎和地面保持一致，但瓶子的贴纸文字在视频中途发生了变化。",
+        },
+        "rationale_physical": {
+            "flow_dynamics": "The liquid bursts out and rapidly flows outward, forming an expanding puddle on the ground — largely consistent with realistic flow behavior.",
+            "material": "The glass bottle does not shatter convincingly; it deforms like a soft object rather than breaking into sharp fragments as real glass would.",
+            "collision": "The bottle ruptures without any visible force or impact — it just bursts on its own.",
+            "fluid_continuity": "No obvious disappearance, or unexpectedly appear of liquid throughout the video.",
+        },
+        "rationale_physical_zh": {
+            "flow_dynamics": "液体爆裂而出，迅速向外流淌，在地面上形成不断扩大的水洼——基本符合真实的流动行为。",
+            "material": "玻璃瓶的碎裂不够逼真，像软物体一样变形，而不是像真正的玻璃那样碎成锋利的碎片。",
+            "collision": "瓶子没有受到任何可见的外力或撞击就爆裂了——完全是自行破裂。",
+            "fluid_continuity": "整个视频中液体没有明显的碎裂、消失或凭空生成现象。",
+        },
+    },
+    {
+        "video_url": "/video/cosmos-predict2.5-2b/collision_144.mp4",
+        "prompt": "A baseball is struck by a bat, causing a visible scuff mark on the ball\u2019s surface.",
+        "prompt_zh": "一根球棒击中一个棒球，在球的表面留下一个明显的擦痕。",
+        "scores": {"SA": 3, "PTV": 1, "persistence": 3},
+        "physical_dims": [
+            ("collision", "After impact, is there reasonable bounce/shatter/deformation? Does response match impact force?"),
+            ("material", "Do different materials respond according to their properties? Glass shatters? Rubber bounces?"),
+            ("momentum", "After collision, is the direction of motion reasonable? Ignore speed magnitude."),
+        ],
+        "physical_dims_zh": [
+            ("collision", "碰撞后是否有合理的弹跳/破碎/变形？响应是否与撞击力匹配？"),
+            ("material", "不同材质是否按其属性反应？玻璃碎裂？橡胶弹跳？"),
+            ("momentum", "碰撞后运动方向是否合理？忽略速度大小。"),
+        ],
+        "physical_scores": {"collision": 1, "material": 1, "momentum": 1},
+        "rationale_general": {
+            "SA": "A visible scuff mark appears on the ball, but the bat never clearly strikes the baseball — the striking action is missing.",
+            "PTV": "The bat never strikes the ball, yet a scuff mark appears — the temporal sequence is highly inconsistent and misordered.",
+            "persistence": "The ball maintains mostly consistent appearance, but the bat only appears for a brief moment before disappearing.",
+        },
+        "rationale_general_zh": {
+            "SA": "球上出现了明显的擦痕，但球棒从未清晰地击中棒球——缺少击球动作。",
+            "PTV": "球棒没有击中球，就出现了擦痕，时间顺序极其不一致且顺序错误。",
+            "persistence": "球基本保持一致的外观，但球棒只出现了���瞬间就消失了。",
+        },
+        "rationale_physical": {
+            "collision": "No real collision occurs — the bat never makes clear contact with the ball, so there is no physically plausible impact response.",
+            "material": "The baseball does not fly away when struck. Instead, a massive, unrealistic brown chunk appears on its surface, resembling mud rather than a scuff mark. The bat also exhibits morphing and clipping issues.",
+            "momentum": "The direction of motion is implausible because no real collision occurs — the bat never makes clear contact with the ball.",
+        },
+        "rationale_physical_zh": {
+            "collision": "没有发生真正的碰撞——球棒从未清晰地接触到棒球，因此不存在物理上合理的撞击响应。",
+            "material": "棒球被击中后没有飞走。相反，其表面出现了一个巨大的、不真实的棕色块状物，看起来像泥巴而不是擦痕。球棒也表现出变形和穿模问题。",
+            "momentum": "运动方向不合理，因为根本没有发生真正的碰撞——球棒从未清晰地接触到棒球。",
+        },
+    },
+]
+
+
+# ---------------------------------------------------------------------------
+# login_required decorator
+# ---------------------------------------------------------------------------
+def login_required(f):
+    @wraps(f)
+    def decorated(*args, **kwargs):
+        if "annotator_id" not in session:
+            return redirect(url_for("login_page"))
+        return f(*args, **kwargs)
+    return decorated
+
+
+def verify_ownership(assignment):
+    if assignment is None:
+        abort(404)
+    if assignment["annotator_id"] != session["annotator_id"]:
+        abort(403)
+
+
+# ---------------------------------------------------------------------------
+# App-level DB helper (stores conn on g, tied to app context)
+# ---------------------------------------------------------------------------
+def get_app_db() -> sqlite3.Connection:
+    from flask import current_app
+    # For in-memory databases, use the shared connection stored on the app
+    if hasattr(current_app, '_mem_conn'):
+        return current_app._mem_conn
+    if "db" not in g:
+        g.db = get_db(g.db_path)
+    return g.db
+
+
+def close_app_db(exc=None):
+    db = g.pop("db", None)
+    if db is not None:
+        db.close()
+
+
+# ---------------------------------------------------------------------------
+# Factory
+# ---------------------------------------------------------------------------
+def create_app(
+    db_path=None,
+    video_data_dir=None,
+    skip_import=True,
+):
+    app = Flask(__name__, template_folder=str(Path(__file__).resolve().parent / "templates"))
+    app.secret_key = SECRET_KEY
+
+    resolved_db_path = db_path or str(DB_PATH)
+    resolved_video_dir = str(video_data_dir) if video_data_dir else str(VIDEO_DATA_DIR)
+
+    # Initialise schema (for :memory: or first run)
+    if resolved_db_path == ":memory:":
+        # Keep a single in-memory connection for the lifetime of the app
+        mem_conn = sqlite3.connect(":memory:")
+        mem_conn.row_factory = sqlite3.Row
+        init_db(mem_conn)
+        app._mem_conn = mem_conn
+
+        # Don't close the shared in-memory connection on teardown
+    else:
+        conn = get_db(Path(resolved_db_path))
+        init_db(conn)
+        if not skip_import:
+            from human_eval.import_videos import import_videos
+            import_videos(conn, Path(resolved_video_dir))
+        conn.close()
+
+        @app.before_request
+        def _inject_db_path():
+            g.db_path = resolved_db_path
+
+        app.teardown_appcontext(close_app_db)
+
+    # Expose constants to all templates (avoids passing on every render_template call)
+    app.jinja_env.globals.update(
+        STATUS_ASSIGNED=STATUS_ASSIGNED,
+        STATUS_COMPLETED=STATUS_COMPLETED,
+        STATUS_PARTIAL=STATUS_PARTIAL,
+        STATUS_SKIPPED=STATUS_SKIPPED,
+        general_dims=GENERAL_DIMS,
+        criteria=CRITERIA,
+        domain_subscores=DOMAIN_SUBSCORES,
+        human_criteria_by_key=HUMAN_CRITERIA_BY_KEY,
+        human_criteria=HUMAN_CRITERIA,
+        human_domains=HUMAN_DOMAINS,
+    )
+
+    # ------------------------------------------------------------------
+    # Routes
+    # ------------------------------------------------------------------
+
+    @app.route("/")
+    def login_page():
+        if request.args.get("return_url"):
+            session["return_url"] = request.args["return_url"]
+        cohort = request.args.get("cohort", "others")
+        if cohort not in VALID_COHORTS:
+            cohort = "others"
+        session["cohort"] = cohort
+        return render_template("login.html", cohort=cohort)
+
+    @app.route("/guide")
+    def guide():
+        lang = request.args.get("lang", "en")
+        if lang not in ("en", "zh"):
+            lang = "en"
+        return render_template(
+            "guide.html",
+            lang=lang,
+            general_dims_display=GENERAL_DIMS_ZH if lang == "zh" else GENERAL_DIMS,
+            all_criteria=_all_criteria_for_lang(lang),
+        )
+
+    @app.route("/demo")
+    @login_required
+    def demo():
+        if request.args.get("return_url"):
+            session["return_url"] = request.args["return_url"]
+        lang = request.args.get("lang", "en")
+        if lang not in ("en", "zh"):
+            lang = "en"
+        dims = GENERAL_DIMS_ZH if lang == "zh" else GENERAL_DIMS
+
+        # ---- task-list data (merged from /tasks) ----
+        db = get_app_db()
+        annotator_id = session["annotator_id"]
+        user_batch_size = get_batch_size(_get_user_cohort(db, annotator_id))
+
+        rows = db.execute(
+            "SELECT a.id, a.status, a.expires_at, a.group_id, "
+            "v.filename, v.dataset, v.prompt, v.physical_laws, "
+            "cg.prompt AS group_prompt "
+            "FROM assignments a "
+            "JOIN videos v ON a.video_id = v.id "
+            "LEFT JOIN comparison_groups cg ON a.group_id = cg.id "
+            "WHERE a.annotator_id = ? AND a.group_id IS NOT NULL "
+            "ORDER BY a.group_id, a.id",
+            (annotator_id,),
+        ).fetchall()
+
+        groups = {}
+        for r in rows:
+            gid = r["group_id"]
+            if gid not in groups:
+                groups[gid] = {
+                    "group_id": gid,
+                    "prompt": r["group_prompt"] or r["prompt"],
+                    "assignments": [],
+                    "models": [],
+                    "status": STATUS_COMPLETED,
+                }
+            groups[gid]["assignments"].append(r)
+            groups[gid]["models"].append(extract_model(r["dataset"]))
+            if r["status"] not in (STATUS_COMPLETED, STATUS_PARTIAL, STATUS_SKIPPED):
+                groups[gid]["status"] = STATUS_ASSIGNED
+            elif r["status"] == STATUS_PARTIAL and groups[gid]["status"] == STATUS_COMPLETED:
+                groups[gid]["status"] = STATUS_PARTIAL
+
+        group_list = list(groups.values())
+        _done_statuses = (STATUS_COMPLETED, STATUS_PARTIAL)
+        user_done_groups = len([g for g in group_list if g["status"] in _done_statuses])
+
+        # Reached quota — redirect to thanks page
+        if user_done_groups >= user_batch_size:
+            return redirect(url_for("thanks"))
+
+        pending_groups = [g for g in group_list if g["status"] not in _done_statuses]
+        if len(group_list) > 0 and len(pending_groups) == 0:
+            new_gids = _auto_assign(db, annotator_id)
+            if new_gids:
+                return redirect(url_for("demo"))
+
+        total_prompts = db.execute(
+            "SELECT COUNT(DISTINCT prompt) AS c FROM comparison_groups"
+        ).fetchone()["c"]
+
+        group_list.sort(key=lambda g: (g["status"] in (STATUS_COMPLETED, STATUS_PARTIAL), g["group_id"]))
+
+        return render_template(
+            "demo.html",
+            lang=lang,
+            demos=DEMO_ENTRIES,
+            general_dims=dims,
+            human_criteria_by_key=HUMAN_CRITERIA_BY_KEY,
+            groups=group_list,
+            annotator_name=session.get("annotator_name"),
+            total_prompts=total_prompts,
+            user_completed_groups=user_done_groups,
+            user_quota=user_batch_size,
+        )
+
+    @app.route("/thanks")
+    @login_required
+    def thanks():
+        db = get_app_db()
+        cohort = _get_user_cohort(db, session["annotator_id"])
+        code = COHORT_COMPLETION_CODE.get(cohort, f"{random.randint(0, 999999):06d}")
+        return render_template("thanks.html", code=code, survey_url=COMPLETION_SURVEY_URL)
+
+    @app.route("/login", methods=["POST"])
+    def login():
+        username = (request.form.get("username") or "").strip()
+        if not username:
+            return render_template("login.html")
+
+        cohort = (request.form.get("cohort") or session.get("cohort") or "others").strip()
+        if cohort not in VALID_COHORTS:
+            cohort = "others"
+
+        db = get_app_db()
+        row = db.execute("SELECT * FROM annotators WHERE name = ?", (username,)).fetchone()
+        if row is None:
+            cur = db.execute("INSERT INTO annotators (name, cohort) VALUES (?, ?)", (username, cohort))
+            db.commit()
+            row = db.execute("SELECT * FROM annotators WHERE id = ?", (cur.lastrowid,)).fetchone()
+        elif not row["cohort"] or row["cohort"] != cohort:
+            # Update cohort if user re-registers via a different link
+            db.execute("UPDATE annotators SET cohort = ? WHERE id = ?", (cohort, row["id"]))
+            db.commit()
+
+        session["annotator_id"] = row["id"]
+        session["annotator_name"] = row["name"]
+        session["cohort"] = cohort
+
+        # Auto-assign comparison groups
+        _auto_assign(db, row["id"])
+
+        return redirect(url_for("demographics"))
+
+    @app.route("/demographics", methods=["GET", "POST"])
+    @login_required
+    def demographics():
+        db = get_app_db()
+
+        if request.method == "POST":
+            gender = (request.form.get("gender") or "").strip()
+            age = (request.form.get("age") or "").strip()
+            major = (request.form.get("major") or "").strip()
+            education = (request.form.get("education") or "").strip()
+            if major == "other":
+                major = (request.form.get("major_other") or "").strip() or "other"
+            if not gender or not age or not major or not education:
+                return redirect(url_for("demographics"))
+            db.execute(
+                "UPDATE annotators SET gender = ?, age = ?, major = ?, education = ? WHERE id = ?",
+                (gender, age, major, education, session["annotator_id"]),
+            )
+            db.commit()
+            return redirect(url_for("demo"))
+
+        # GET — redirect to demo if already filled
+        ann_row = db.execute(
+            "SELECT gender, age, major, education FROM annotators WHERE id = ?",
+            (session["annotator_id"],),
+        ).fetchone()
+        if ann_row["gender"] and ann_row["age"] and ann_row["major"] and ann_row["education"]:
+            return redirect(url_for("demo"))
+        return render_template("demographics.html")
+
+    def _get_user_cohort(db, annotator_id) -> str:
+        row = db.execute("SELECT cohort FROM annotators WHERE id = ?", (annotator_id,)).fetchone()
+        return (row["cohort"] if row and row["cohort"] else "others")
+
+    def _auto_assign(db, annotator_id):
+        """Assign a comparison batch with cohort-specific config."""
+        cohort = _get_user_cohort(db, annotator_id)
+        return assign_comparison_batch(
+            db,
+            annotator_id,
+            n_annotators=N_ANNOTATORS_PER_VIDEO,
+            batch_size=get_batch_size(cohort),
+            ttl_hours=ASSIGNMENT_TTL_HOURS,
+        )
+
+    @app.route("/tasks")
+    @login_required
+    def task_list():
+        return redirect(url_for("demo"))
+
+    def _next_group_url(db, annotator_id, current_group_id=None):
+        """Return URL for the next unfinished group, skipping current_group_id."""
+        pending_sql = pending_assignment_sql("a")
+        row = db.execute(
+            "SELECT a.group_id FROM assignments a "
+            "WHERE a.annotator_id = ? AND a.group_id IS NOT NULL "
+            "AND a.group_id != ? "
+            f"AND {pending_sql} "
+            "ORDER BY a.group_id LIMIT 1",
+            (annotator_id, current_group_id or ""),
+        ).fetchone()
+        if row:
+            return f"/rate_group/{row['group_id']}"
+        return None
+
+    @app.route("/tasks/start", methods=["POST"])
+    @login_required
+    def start_next():
+        """Redirect to the first unfinished comparison group."""
+        db = get_app_db()
+        annotator_id = session["annotator_id"]
+        nxt = _next_group_url(db, annotator_id)
+        if nxt:
+            return redirect(nxt)
+        _auto_assign(db, annotator_id)
+        nxt = _next_group_url(db, annotator_id)
+        if nxt:
+            return redirect(nxt)
+        return redirect(url_for("task_list"))
+
+    @app.route("/tasks/more", methods=["POST"])
+    @login_required
+    def request_more():
+        db = get_app_db()
+        _auto_assign(db, session["annotator_id"])
+        return redirect(url_for("task_list"))
+
+    # ------------------------------------------------------------------
+    # Comparison group routes
+    # ------------------------------------------------------------------
+
+    def _load_group_assignments(db, group_id, annotator_id):
+        """Load and verify all assignments in a comparison group."""
+        rows = db.execute(
+            "SELECT a.*, v.filename, v.dataset, v.prompt, v.physical_laws, v.metadata_version AS v_meta_ver "
+            "FROM assignments a JOIN videos v ON a.video_id = v.id "
+            "WHERE a.group_id = ? AND a.annotator_id = ? "
+            "ORDER BY a.id",
+            (group_id, annotator_id),
+        ).fetchall()
+        if not rows:
+            abort(404)
+        return rows
+
+    def _shuffle_for_group(items, group_id):
+        """Deterministic shuffle based on group_id (same order on page refresh)."""
+        seed = int(hashlib.md5(group_id.encode()).hexdigest(), 16) % (2**32)
+        rng = random.Random(seed)
+        result = list(items)
+        rng.shuffle(result)
+        return result
+
+    @app.route("/rate_group/<group_id>")
+    @login_required
+    def rate_group_page(group_id):
+        # Persist return_url in session so it survives across group pages
+        if request.args.get("return_url"):
+            session["return_url"] = request.args["return_url"]
+        db = get_app_db()
+        annotator_id = session["annotator_id"]
+        assignments = _load_group_assignments(db, group_id, annotator_id)
+
+        # Shuffle order (blind evaluation — same model not always in same position)
+        assignments = _shuffle_for_group(assignments, group_id)
+
+        # Get physical dims from first assignment (same prompt = same laws)
+        physical_dims = _get_physical_dims(assignments[0])
+
+        # Load existing scores for all assignments in one query
+        aid_list = [a["id"] for a in assignments]
+        placeholders = ",".join("?" * len(aid_list))
+        existing_rows = db.execute(
+            f"SELECT assignment_id, scores_json, note, na_laws FROM annotations WHERE assignment_id IN ({placeholders})",
+            aid_list,
+        ).fetchall()
+        existing_scores_map = {}
+        for r in existing_rows:
+            entry = json.loads(r["scores_json"])
+            entry["note"] = r["note"] or ""
+            entry["na_laws"] = json.loads(r["na_laws"]) if r["na_laws"] else []
+            existing_scores_map[r["assignment_id"]] = entry
+
+        # Assign blind labels: Model A, Model B, ...
+        labels = [chr(65 + i) for i in range(len(assignments))]  # A, B, C, D, ...
+
+        prompt = assignments[0]["prompt"]
+
+        # Build status map for per-video state display
+        status_map = {a["id"]: a["status"] for a in assignments}
+
+        # User progress: completed groups / quota
+        user_completed_groups = db.execute(
+            "SELECT COUNT(DISTINCT a.group_id) AS c FROM assignments a "
+            "WHERE a.annotator_id = ? AND a.group_id IS NOT NULL "
+            "AND NOT EXISTS (SELECT 1 FROM assignments a2 WHERE a2.group_id = a.group_id "
+            "AND a2.annotator_id = a.annotator_id AND a2.status NOT IN (?, ?, ?))",
+            (annotator_id, STATUS_COMPLETED, STATUS_PARTIAL, STATUS_SKIPPED),
+        ).fetchone()["c"]
+
+        return render_template(
+            "rate_compare.html",
+            group_id=group_id,
+            prompt=prompt,
+            physical_dims=physical_dims,
+            video_entries=list(zip(labels, assignments)),
+            existing_scores_map=existing_scores_map,
+            status_map=status_map,
+            user_completed_groups=user_completed_groups,
+            user_quota=get_batch_size(_get_user_cohort(db, annotator_id)),
+            annotator_name=session.get("annotator_name"),
+        )
+
+    @app.route("/rate_group/<group_id>", methods=["POST"])
+    @login_required
+    def rate_group_submit(group_id):
+        db = get_app_db()
+        annotator_id = session["annotator_id"]
+        assignments = _load_group_assignments(db, group_id, annotator_id)
+
+        physical_dims = _get_physical_dims(assignments[0])
+
+        general_keys = {key for key, _, _, _, _ in GENERAL_DIMS}
+        physical_keys = {key for key, _ in physical_dims}
+
+        completed_aids = []
+        partial_aids = []
+        for a in assignments:
+            aid = a["id"]
+            general_scores, physical_scores, na_laws = _extract_scores(f"v{aid}_", physical_dims)
+            if not general_scores:
+                continue
+            note = request.form.get(f"v{aid}_note", "").strip()
+            play_count = int(request.form.get(f"v{aid}_play_count", 0) or 0)
+            stay_seconds = float(request.form.get(f"v{aid}_stay_seconds", 0) or 0)
+            _save_annotation(db, aid, general_scores, physical_scores, physical_dims, a["v_meta_ver"], note=note, play_count=play_count, stay_seconds=stay_seconds, na_laws=na_laws)
+            covered_physical = set(physical_scores.keys()) | set(na_laws)
+            if general_scores.keys() >= general_keys and covered_physical >= physical_keys:
+                completed_aids.append(aid)
+            else:
+                partial_aids.append(aid)
+
+        db.commit()
+
+        action = request.form.get("action", "save")
+
+        if action == "save":
+            return jsonify({"ok": True})
+
+        # "Next" — mark assignments by completeness
+        all_aids = [a["id"] for a in assignments]
+        saved_aids = completed_aids + partial_aids
+        if completed_aids:
+            db.execute(
+                "UPDATE assignments SET status = ?, completed_at = CURRENT_TIMESTAMP "
+                "WHERE id IN ({}) AND status NOT IN (?, ?)".format(
+                    ",".join("?" * len(completed_aids))),
+                [STATUS_COMPLETED, *completed_aids, STATUS_COMPLETED, STATUS_SKIPPED],
+            )
+        if partial_aids:
+            db.execute(
+                "UPDATE assignments SET status = ?, completed_at = CURRENT_TIMESTAMP "
+                "WHERE id IN ({}) AND status NOT IN (?, ?, ?)".format(
+                    ",".join("?" * len(partial_aids))),
+                [STATUS_PARTIAL, *partial_aids, STATUS_COMPLETED, STATUS_PARTIAL, STATUS_SKIPPED],
+            )
+        # Mark remaining (unannotated) assignments as skipped so progress advances
+        unsaved_aids = [aid for aid in all_aids if aid not in saved_aids]
+        if unsaved_aids:
+            db.execute(
+                "UPDATE assignments SET status = ?, completed_at = CURRENT_TIMESTAMP "
+                "WHERE id IN ({}) AND status NOT IN (?, ?, ?)".format(
+                    ",".join("?" * len(unsaved_aids))),
+                [STATUS_SKIPPED, *unsaved_aids, STATUS_COMPLETED, STATUS_PARTIAL, STATUS_SKIPPED],
+            )
+        db.commit()
+        return_url = session.pop("return_url", "")
+        nxt = _next_group_url(db, annotator_id, current_group_id=group_id)
+        if nxt:
+            # Keep return_url in session for subsequent groups (re-set it)
+            if return_url:
+                session["return_url"] = return_url
+            return jsonify({"ok": True, "redirect": nxt})
+        return jsonify({"ok": True, "redirect": return_url or url_for("task_list")})
+
+    @app.route("/rate_group/<group_id>/skip_video/<int:assignment_id>", methods=["POST"])
+    @login_required
+    def skip_video(group_id, assignment_id):
+        db = get_app_db()
+        assignment = db.execute(
+            "SELECT * FROM assignments WHERE id = ? AND group_id = ?",
+            (assignment_id, group_id),
+        ).fetchone()
+        verify_ownership(assignment)
+
+        reason = request.form.get("skip_reason", "")
+        db.execute(
+            "UPDATE assignments SET status = ?, skip_reason = ? WHERE id = ?",
+            (STATUS_SKIPPED, reason, assignment_id),
+        )
+        db.commit()
+
+        # Auto-advance if group is fully done
+        pending = db.execute(
+            "SELECT COUNT(*) AS c FROM assignments "
+            "WHERE group_id = ? AND annotator_id = ? AND status NOT IN (?, ?, ?)",
+            (group_id, session["annotator_id"], STATUS_COMPLETED, STATUS_PARTIAL, STATUS_SKIPPED),
+        ).fetchone()["c"]
+        if pending == 0:
+            nxt = _next_group_url(db, session["annotator_id"])
+            if nxt:
+                return redirect(nxt)
+            return redirect(url_for("task_list"))
+
+        return redirect(url_for("rate_group_page", group_id=group_id))
+
+    @app.route("/video/<dataset>/<filename>")
+    def serve_video(dataset, filename):
+        video_dir = Path(resolved_video_dir) / dataset
+        return send_from_directory(str(video_dir), filename)
+
+    @app.route("/api/stats")
+    @login_required
+    def stats():
+        db = get_app_db()
+
+        total_videos = db.execute("SELECT COUNT(*) AS c FROM videos").fetchone()["c"]
+
+        target_n = N_ANNOTATORS_PER_VIDEO
+
+        # Coverage: aggregate in SQL
+        coverage = db.execute(
+            "SELECT "
+            "SUM(CASE WHEN cnt >= ? THEN 1 ELSE 0 END) AS fully, "
+            "SUM(CASE WHEN cnt > 0 AND cnt < ? THEN 1 ELSE 0 END) AS partially, "
+            "SUM(CASE WHEN cnt = 0 THEN 1 ELSE 0 END) AS uncovered "
+            "FROM ("
+            "  SELECT COUNT(a.id) AS cnt "
+            "  FROM videos v "
+            "  LEFT JOIN assignments a ON v.id = a.video_id AND a.status IN (?, ?) "
+            "  GROUP BY v.id"
+            ")",
+            (target_n, target_n, STATUS_COMPLETED, STATUS_PARTIAL),
+        ).fetchone()
+        fully = coverage["fully"] or 0
+        partially = coverage["partially"] or 0
+        uncovered = coverage["uncovered"] or 0
+
+        # Per annotator
+        per_annotator = db.execute(
+            "SELECT an.name, "
+            "SUM(CASE WHEN a.status = ? THEN 1 ELSE 0 END) AS completed, "
+            "SUM(CASE WHEN a.status = ? THEN 1 ELSE 0 END) AS partial, "
+            "SUM(CASE WHEN a.status = ? THEN 1 ELSE 0 END) AS assigned "
+            "FROM annotators an "
+            "LEFT JOIN assignments a ON an.id = a.annotator_id "
+            "GROUP BY an.id",
+            (STATUS_COMPLETED, STATUS_PARTIAL, STATUS_ASSIGNED),
+        ).fetchall()
+
+        per_annotator_list = [
+            {"name": r["name"], "completed": r["completed"] or 0, "partial": r["partial"] or 0, "assigned": r["assigned"] or 0}
+            for r in per_annotator
+        ]
+
+        # Disagreement top-k
+        disagreement_rows = db.execute(
+            "SELECT ai.dimension, ai.law, "
+            "GROUP_CONCAT(ai.score) AS scores, "
+            "MAX(ai.score) - MIN(ai.score) AS max_min_diff, "
+            "a2.video_id "
+            "FROM annotation_items ai "
+            "JOIN annotations ann ON ai.annotation_id = ann.id "
+            "JOIN assignments a2 ON ann.assignment_id = a2.id "
+            "GROUP BY a2.video_id, ai.dimension, ai.law "
+            "HAVING COUNT(ai.score) > 1 "
+            "ORDER BY max_min_diff DESC "
+            "LIMIT ?",
+            (DISAGREEMENT_TOP_K,),
+        ).fetchall()
+
+        disagreement_list = [
+            {
+                "video_id": r["video_id"],
+                "dimension": r["dimension"],
+                "law": r["law"],
+                "scores": [int(s) for s in r["scores"].split(",")],
+                "max_min_diff": r["max_min_diff"],
+            }
+            for r in disagreement_rows
+        ]
+
+        return jsonify({
+            "total_videos": total_videos,
+            "coverage": {
+                "fully_covered": fully,
+                "partially_covered": partially,
+                "uncovered": uncovered,
+                "target_n": target_n,
+            },
+            "per_annotator": per_annotator_list,
+            "disagreement_top_k": disagreement_list,
+        })
+
+    return app

evals/human_eval/assign.py

@@ -0,0 +1,252 @@
+import random
+import sqlite3
+import uuid
+
+from human_eval.config import (
+    STATUS_ASSIGNED, STATUS_COMPLETED, STATUS_PARTIAL, STATUS_SKIPPED,
+    COMPARISON_MODELS, MODELS_PER_GROUP, extract_model,
+)
+from human_eval.db import pending_assignment_sql
+
+
+def _delete_assignments_with_annotations(
+    conn: sqlite3.Connection,
+    where_sql: str,
+    params: tuple,
+) -> list[int]:
+    """Delete assignments plus any saved draft rows that reference them.
+
+    Also cleans up comparison_groups left with no remaining assignments.
+    """
+    rows = conn.execute(
+        f"SELECT id, group_id FROM assignments WHERE {where_sql}",
+        params,
+    ).fetchall()
+    assignment_ids = [row["id"] for row in rows]
+    if not assignment_ids:
+        return []
+
+    affected_group_ids = list({
+        row["group_id"] for row in rows if row["group_id"] is not None
+    })
+
+    placeholders = ",".join("?" * len(assignment_ids))
+    conn.execute(
+        f"""
+        DELETE FROM annotation_items
+        WHERE annotation_id IN (
+            SELECT id FROM annotations WHERE assignment_id IN ({placeholders})
+        )
+        """,
+        assignment_ids,
+    )
+    conn.execute(
+        f"DELETE FROM annotations WHERE assignment_id IN ({placeholders})",
+        assignment_ids,
+    )
+    conn.execute(
+        f"DELETE FROM assignments WHERE id IN ({placeholders})",
+        assignment_ids,
+    )
+
+    # Clean up comparison_groups that lost all their assignments
+    if affected_group_ids:
+        gph = ",".join("?" * len(affected_group_ids))
+        conn.execute(
+            f"""
+            DELETE FROM comparison_groups
+            WHERE id IN ({gph})
+              AND NOT EXISTS (
+                  SELECT 1 FROM assignments WHERE group_id = comparison_groups.id
+              )
+            """,
+            affected_group_ids,
+        )
+
+    return assignment_ids
+
+
+def _select_group_videos(
+    model_videos: dict[str, dict],
+    models: list[str],
+    video_coverage: dict[int, int],
+    k: int,
+    n_annotators: int,
+) -> tuple[list[dict], tuple[int, ...]] | None:
+    """Pick the least-covered videos for a prompt, randomizing only on ties."""
+    ranked = []
+    for model in models:
+        row = model_videos.get(model)
+        if row is None:
+            continue
+        ranked.append((video_coverage.get(row["id"], 0), row))
+
+    if len(ranked) < 2:
+        return None
+    if all(coverage >= n_annotators for coverage, _ in ranked):
+        return None
+
+    random.shuffle(ranked)
+    ranked.sort(key=lambda item: item[0])
+    picked = ranked[: min(k, len(ranked))]
+    return [row for _, row in picked], tuple(coverage for coverage, _ in picked)
+
+
+
+def _build_prompt_video_map(conn, models: list[str]) -> dict:
+    """Build {prompt_text: {model: video_row}} mapping for comparison models.
+
+    Only includes prompts that have at least 2 models available.
+    """
+    rows = conn.execute(
+        "SELECT id, filename, dataset, prompt, physical_laws FROM videos"
+    ).fetchall()
+
+    model_set = set(models)
+    # prompt → {model → video_row}
+    prompt_map: dict[str, dict[str, dict]] = {}
+    for r in rows:
+        model = extract_model(r["dataset"])
+        if model not in model_set:
+            continue
+        prompt = r["prompt"]
+        if prompt not in prompt_map:
+            prompt_map[prompt] = {}
+        existing = prompt_map[prompt].get(model)
+        if existing is None:
+            prompt_map[prompt][model] = dict(r)
+        elif "perspective-center" in r["filename"]:
+            prompt_map[prompt][model] = dict(r)
+
+    # Filter: keep only prompts with >= 2 models
+    return {p: m for p, m in prompt_map.items() if len(m) >= 2}
+
+
+def assign_comparison_batch(
+    conn: sqlite3.Connection,
+    annotator_id: int,
+    n_annotators: int,
+    batch_size: int,
+    ttl_hours: int,
+    models: list[str] | None = None,
+    models_per_group: int | None = None,
+) -> list[str]:
+    """Assign comparison groups to an annotator.
+
+    Each group = 1 prompt × K randomly-sampled models.
+    Returns list of new group_ids.
+    """
+    models = models or COMPARISON_MODELS
+    k = models_per_group or MODELS_PER_GROUP
+
+    prompt_map = _build_prompt_video_map(conn, models)
+    if not prompt_map:
+        return []
+
+    # Find prompts with active (completed/skipped or pending) groups for this user
+    pending_sql = pending_assignment_sql("a")
+    active_groups = conn.execute(
+        f"""
+        SELECT DISTINCT cg.prompt
+        FROM comparison_groups cg
+        JOIN assignments a ON a.group_id = cg.id
+        WHERE a.annotator_id = ?
+          AND (a.status IN ('{STATUS_COMPLETED}', '{STATUS_PARTIAL}', '{STATUS_SKIPPED}')
+               OR {pending_sql})
+        """,
+        (annotator_id,),
+    ).fetchall()
+    active_prompts = {r["prompt"] for r in active_groups}
+
+    # Count how many non-excluded annotators have completed each video.
+    # excluded_annotators is populated by filter_db.py; if the table is
+    # empty or missing, all annotators count (original behavior).
+    has_exclusion_table = conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name='excluded_annotators'"
+    ).fetchone() is not None
+
+    if has_exclusion_table:
+        coverage = conn.execute(
+            f"""
+            SELECT a.video_id, COUNT(DISTINCT a.annotator_id) AS cnt
+            FROM assignments a
+            WHERE a.status IN ('{STATUS_COMPLETED}', '{STATUS_PARTIAL}')
+              AND a.annotator_id NOT IN (SELECT annotator_id FROM excluded_annotators)
+            GROUP BY a.video_id
+            """,
+        ).fetchall()
+    else:
+        coverage = conn.execute(
+            f"""
+            SELECT a.video_id, COUNT(DISTINCT a.annotator_id) AS cnt
+            FROM assignments a
+            WHERE a.status IN ('{STATUS_COMPLETED}', '{STATUS_PARTIAL}')
+            GROUP BY a.video_id
+            """,
+        ).fetchall()
+    video_coverage = {r["video_id"]: r["cnt"] for r in coverage}
+
+    # Filter to assignable prompts: not already active for this user and still
+    # containing at least one under-covered video.
+    candidates = []
+    for prompt, model_videos in prompt_map.items():
+        if prompt in active_prompts:
+            continue
+
+        selected = _select_group_videos(
+            model_videos,
+            models,
+            video_coverage,
+            k,
+            n_annotators,
+        )
+        if selected is None:
+            continue
+        video_rows, coverage_signature = selected
+        candidates.append((coverage_signature, random.random(), prompt, video_rows))
+
+    # Sort: prompts with the lowest-covered selected videos first.
+    candidates.sort(key=lambda x: (x[0], x[1]))
+
+    conn.execute("BEGIN IMMEDIATE")
+    try:
+        # Clean up non-completed, non-skipped group assignments (expired/abandoned)
+        # and their orphaned comparison_groups
+        deleted_ids = _delete_assignments_with_annotations(
+            conn,
+            (
+                "annotator_id = ? AND group_id IS NOT NULL "
+                "AND status NOT IN (?, ?, ?) "
+                "AND expires_at <= datetime('now')"
+            ),
+            (annotator_id, STATUS_COMPLETED, STATUS_PARTIAL, STATUS_SKIPPED),
+        )
+        new_group_ids = []
+        for _, _, prompt, video_rows in candidates[:batch_size]:
+
+            # Get physical_laws from the first video (same prompt = same laws)
+            physical_laws = video_rows[0]["physical_laws"]
+
+            # Create comparison group
+            group_id = str(uuid.uuid4())
+            conn.execute(
+                "INSERT INTO comparison_groups (id, prompt, physical_laws) VALUES (?, ?, ?)",
+                (group_id, prompt, physical_laws),
+            )
+
+            # Create assignments for each video in the group
+            for vr in video_rows:
+                conn.execute(
+                    "INSERT OR IGNORE INTO assignments (video_id, annotator_id, status, expires_at, group_id) "
+                    f"VALUES (?, ?, '{STATUS_ASSIGNED}', datetime('now', '+' || ? || ' hours'), ?)",
+                    (vr["id"], annotator_id, ttl_hours, group_id),
+                )
+
+            new_group_ids.append(group_id)
+
+        conn.commit()
+        return new_group_ids
+
+    except Exception:
+        conn.rollback()
+        raise

evals/human_eval/check_db_json_alignment.py

@@ -0,0 +1,95 @@
+"""Check internal alignment for a human-eval DB.
+
+The original source-JSON comparison depends on prompt-selection artifacts that
+are omitted from this release. This release version only checks consistency
+between DB videos and comparison groups.
+
+Usage:
+  python -m human_eval.check_db_json_alignment
+"""
+
+import json
+import sqlite3
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent.parent.parent
+DB_PATH = ROOT / "eval" / "human_eval" / "human_eval_filtered.db"
+
+
+def _norm_laws(laws_str: str) -> list[str]:
+    try:
+        return sorted(json.loads(laws_str))
+    except (json.JSONDecodeError, TypeError):
+        return []
+
+
+def main():
+    print("=" * 60)
+    print("DB Internal Alignment Check")
+    print("=" * 60)
+
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    groups = [dict(r) for r in conn.execute(
+        "SELECT id, prompt, physical_laws FROM comparison_groups"
+    ).fetchall()]
+
+    issues = []
+
+    print(f"\n[1] comparison_groups ({len(groups)}) internal consistency with videos")
+    rows = conn.execute(
+        "SELECT DISTINCT cg.id as gid, cg.prompt as cg_prompt, cg.physical_laws as cg_laws, "
+        "v.id as vid, v.prompt as v_prompt, v.physical_laws as v_laws "
+        "FROM comparison_groups cg "
+        "JOIN assignments a ON a.group_id = cg.id "
+        "JOIN videos v ON a.video_id = v.id"
+    ).fetchall()
+    conn.close()
+
+    cg_mismatches = 0
+    for r in rows:
+        if r["cg_prompt"] != r["v_prompt"]:
+            cg_mismatches += 1
+            if cg_mismatches <= 5:
+                issues.append({"type": "prompt_mismatch", "layer": "group_vs_video",
+                               "group_id": r["gid"][:12], "video_id": r["vid"],
+                               "cg_prompt": r["cg_prompt"][:80], "v_prompt": r["v_prompt"][:80]})
+        if _norm_laws(r["cg_laws"]) != _norm_laws(r["v_laws"]):
+            cg_mismatches += 1
+            if cg_mismatches <= 5:
+                issues.append({"type": "laws_mismatch", "layer": "group_vs_video",
+                               "group_id": r["gid"][:12], "video_id": r["vid"],
+                               "cg_laws": _norm_laws(r["cg_laws"]), "v_laws": _norm_laws(r["v_laws"])})
+    print(f"  checked {len(rows)} (group, video) pairs, {cg_mismatches} mismatches")
+
+    print("\n" + "=" * 60)
+    if not issues:
+        print("ALL ALIGNED")
+        return 0
+
+    grouped = defaultdict(list)
+    for iss in issues:
+        key = (iss["layer"], iss["type"], iss.get("group_id", "?"))
+        grouped[key].append(iss)
+
+    print(f"FOUND {len(grouped)} unique issue(s) ({len(issues)} total across models):\n")
+    display_keys = {
+        "prompt_mismatch": ("cg_prompt", "v_prompt"),
+        "laws_mismatch": ("cg_laws", "v_laws"),
+    }
+    for i, ((layer, typ, stem), group) in enumerate(sorted(grouped.items()), 1):
+        iss = group[0]
+        print(f"--- #{i} [{typ}] {layer} | stem={stem} | x{len(group)} models ---")
+        for key in display_keys.get(typ, ()):
+            if key in iss:
+                print(f"  {key}: {iss[key]}")
+        print()
+
+    return len(grouped)
+
+
+if __name__ == "__main__":
+    sys.exit(0 if main() == 0 else 1)

evals/human_eval/config.py

@@ -0,0 +1,84 @@
+import os
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent
+
+N_ANNOTATORS_PER_VIDEO = 3
+BATCH_SIZE_PER_USER = 4  # default fallback
+
+# Per-cohort batch size (number of comparison pages per user)
+COHORT_BATCH_SIZE: dict[str, int] = {
+    "cohort_a":      4,
+    "cohort_b":     11,
+    "cohort_c":      4,
+    "cohort_d":      4,
+    "test":          2,   # Test cohort — excluded from dashboard/stats
+    "others":      100,   # Default for unspecified cohort
+}
+
+# Expected headcount per cohort (for dashboard display)
+COHORT_EXPECTED: dict[str, int] = {
+    "cohort_a": 285,
+    "cohort_b":  35,
+    "cohort_d":  80,
+}
+
+# Fixed completion codes per cohort (not randomly generated)
+COHORT_COMPLETION_CODE: dict[str, str] = {
+    "cohort_c": "COMPLETION",
+    "cohort_d": "COMPLETION",
+}
+
+# Cohorts to exclude from dashboard statistics and exports
+TEST_COHORTS = {"test"}
+
+VALID_COHORTS = set(COHORT_BATCH_SIZE.keys())
+
+def get_batch_size(cohort: str | None) -> int:
+    """Return batch size for a given cohort, falling back to default."""
+    return COHORT_BATCH_SIZE.get(cohort or "others", BATCH_SIZE_PER_USER)
+ASSIGNMENT_TTL_HOURS = 24
+VIDEO_DATA_DIR = BASE_DIR / "../../data/videos"
+DB_PATH = BASE_DIR / "human_eval.db"
+TEST_DB_PATH = BASE_DIR / "human_eval_test.db"
+DISAGREEMENT_TOP_K = 20
+SECRET_KEY = os.environ.get("HUMAN_EVAL_SECRET_KEY", "human-eval-local-dev-key")
+
+# Assignment status constants
+STATUS_ASSIGNED = "assigned"
+STATUS_COMPLETED = "completed"
+STATUS_PARTIAL = "partial"
+STATUS_SKIPPED = "skipped"
+
+# ---------------------------------------------------------------------------
+# Comparison mode: multi-model side-by-side evaluation
+# ---------------------------------------------------------------------------
+# Model prefixes — must match the prefix part of dataset directory names
+# e.g. "ltx-2-19b-distilled-fp8" matches "ltx-2-19b-distilled-fp8-openvid", etc.
+COMPARISON_MODELS = [
+    "wan2.2-ti2v-5b",
+    "ltx-2-19b-dev",
+    "cosmos-predict2.5-2b",
+    "cosmos-predict2.5-14b",
+    "veo-3.1",
+    "wan2.2-i2v-a14b",
+    "omniweaving",
+    "ltx-2.3-22b-dev",
+]
+
+# How many models to show per comparison group (randomly sampled from COMPARISON_MODELS)
+MODELS_PER_GROUP = 3
+
+SOURCE_DATASETS = {"wmb", "openvid", "physics_iq", "video_phy_2"}
+
+# Redirect URL shown after user completes all assigned groups
+COMPLETION_SURVEY_URL = "https://example.com/survey"
+
+
+def extract_model(dataset_name: str) -> str:
+    """Extract model prefix from a dataset directory name like 'ltx-2-19b-distilled-fp8-openvid' → 'ltx-2-19b-distilled-fp8'."""
+    for src in sorted(SOURCE_DATASETS, key=len, reverse=True):
+        suffix = f"-{src}"
+        if dataset_name.endswith(suffix):
+            return dataset_name[: -len(suffix)]
+    return dataset_name

evals/human_eval/coverage_report.py

@@ -0,0 +1,88 @@
+"""Report video coverage and how many people are needed to reach 3x.
+
+Usage:
+  python -m evals.human_eval.coverage_report
+  python -m evals.human_eval.coverage_report --batch-size 11
+"""
+
+from __future__ import annotations
+
+import argparse
+import sqlite3
+import sys
+from collections import Counter
+
+from evals.human_eval.config import (
+    COMPARISON_MODELS,
+    DB_PATH,
+    N_ANNOTATORS_PER_VIDEO,
+)
+
+
+def _active_video_sql() -> str:
+    likes = " OR ".join(f"v.dataset LIKE '{m}%'" for m in COMPARISON_MODELS)
+    return f"({likes})"
+
+
+def _query_coverage(conn: sqlite3.Connection, exclude_bad: bool) -> list[tuple[int, int]]:
+    vf = _active_video_sql()
+    ea = ""
+    if exclude_bad:
+        has_table = conn.execute(
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name='excluded_annotators'"
+        ).fetchone()
+        if has_table:
+            ea = "AND a.annotator_id NOT IN (SELECT annotator_id FROM excluded_annotators)"
+
+    return conn.execute(f"""
+        SELECT v.id, COUNT(a.id) AS cnt
+        FROM videos v
+        LEFT JOIN assignments a ON v.id = a.video_id AND a.status IN ('completed', 'partial')
+            AND a.annotator_id NOT IN (
+                SELECT id FROM annotators WHERE COALESCE(cohort, 'others') IN ('test')
+            )
+            {ea}
+        WHERE {vf}
+        GROUP BY v.id
+    """).fetchall()
+
+
+def _print_report(label: str, rows: list[tuple[int, int]], target: int, batch_size: int) -> None:
+    total = len(rows)
+    dist: Counter[int] = Counter()
+    deficit = 0
+    for _, cnt in rows:
+        bucket = min(cnt, target)
+        dist[bucket] += 1
+        if cnt < target:
+            deficit += target - cnt
+
+    print(f"=== {label} ({total} active videos) ===")
+    for k in sorted(dist.keys()):
+        print(f"  {k}x: {dist[k]} videos ({dist[k] / total * 100:.1f}%)")
+    print(f"  缺少 annotations: {deficit}")
+    print(f"  需要补人 (batch={batch_size}): {-(-deficit // batch_size)}")
+    print()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Video coverage report")
+    parser.add_argument("--db", default=str(DB_PATH), help="Path to human_eval.db")
+    parser.add_argument("--batch-size", type=int, default=12, help="Videos per person (default: 4 groups × 3 models)")
+    parser.add_argument("--target", type=int, default=N_ANNOTATORS_PER_VIDEO, help="Target annotations per video")
+    args = parser.parse_args(argv)
+
+    conn = sqlite3.connect(args.db, timeout=30)
+
+    rows_all = _query_coverage(conn, exclude_bad=False)
+    rows_filt = _query_coverage(conn, exclude_bad=True)
+    conn.close()
+
+    _print_report("不 filter", rows_all, args.target, args.batch_size)
+    _print_report("Filter 后", rows_filt, args.target, args.batch_size)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

evals/human_eval/db.py

@@ -0,0 +1,124 @@
+import sqlite3
+from pathlib import Path
+
+from human_eval.config import STATUS_ASSIGNED, STATUS_COMPLETED, STATUS_PARTIAL, STATUS_SKIPPED
+
+SCHEMA_SQL = """
+CREATE TABLE IF NOT EXISTS annotators (
+    id INTEGER PRIMARY KEY,
+    name TEXT UNIQUE NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS videos (
+    id INTEGER PRIMARY KEY,
+    filename TEXT NOT NULL,
+    dataset TEXT NOT NULL,
+    prompt TEXT NOT NULL,
+    physical_laws TEXT NOT NULL,
+    difficulty_score REAL,
+    metadata_version INTEGER NOT NULL DEFAULT 1,
+    imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    import_hash TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS assignments (
+    id INTEGER PRIMARY KEY,
+    video_id INTEGER NOT NULL REFERENCES videos(id),
+    annotator_id INTEGER NOT NULL REFERENCES annotators(id),
+    status TEXT NOT NULL DEFAULT 'assigned',
+    assigned_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    completed_at TIMESTAMP,
+    expires_at TIMESTAMP NOT NULL,
+    skip_reason TEXT,
+    group_id TEXT REFERENCES comparison_groups(id),
+    UNIQUE(video_id, annotator_id)
+);
+
+CREATE TABLE IF NOT EXISTS annotations (
+    id INTEGER PRIMARY KEY,
+    assignment_id INTEGER NOT NULL UNIQUE REFERENCES assignments(id),
+    scores_json TEXT NOT NULL,
+    metadata_version INTEGER,
+    note TEXT,
+    play_count INTEGER DEFAULT 0,
+    stay_seconds REAL DEFAULT 0,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS annotation_items (
+    id INTEGER PRIMARY KEY,
+    annotation_id INTEGER NOT NULL REFERENCES annotations(id),
+    dimension TEXT NOT NULL,
+    law TEXT,
+    score INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS comparison_groups (
+    id TEXT PRIMARY KEY,
+    prompt TEXT NOT NULL,
+    physical_laws TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS excluded_annotators (
+    annotator_id INTEGER PRIMARY KEY REFERENCES annotators(id),
+    reason TEXT NOT NULL,
+    generated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+"""
+
+
+_MIGRATIONS = [
+    "ALTER TABLE videos ADD COLUMN metadata_version INTEGER NOT NULL DEFAULT 1",
+    "ALTER TABLE annotations ADD COLUMN metadata_version INTEGER",
+    "ALTER TABLE assignments ADD COLUMN group_id TEXT",
+    # comparison_groups table is created in SCHEMA_SQL above; this migration
+    # is a no-op for new DBs but needed for existing ones.
+    ("CREATE TABLE IF NOT EXISTS comparison_groups ("
+     "id TEXT PRIMARY KEY, prompt TEXT NOT NULL, physical_laws TEXT NOT NULL, "
+     "created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)"),
+    "ALTER TABLE annotations ADD COLUMN play_count INTEGER DEFAULT 0",
+    "ALTER TABLE annotations ADD COLUMN stay_seconds REAL DEFAULT 0",
+    "ALTER TABLE annotations ADD COLUMN na_laws TEXT",
+    "ALTER TABLE annotators ADD COLUMN gender TEXT",
+    "ALTER TABLE annotators ADD COLUMN age TEXT",
+    "ALTER TABLE annotators ADD COLUMN major TEXT",
+    "ALTER TABLE annotators ADD COLUMN education TEXT",
+    "ALTER TABLE annotators ADD COLUMN cohort TEXT DEFAULT 'others'",
+    ("CREATE TABLE IF NOT EXISTS excluded_annotators ("
+     "annotator_id INTEGER PRIMARY KEY REFERENCES annotators(id), "
+     "reason TEXT NOT NULL, "
+     "generated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)"),
+]
+
+
+def init_db(conn: sqlite3.Connection):
+    conn.executescript(SCHEMA_SQL)
+    conn.execute("PRAGMA foreign_keys = ON")
+    # Apply migrations for existing DBs (silently skip if column already exists)
+    for sql in _MIGRATIONS:
+        try:
+            conn.execute(sql)
+            conn.commit()
+        except sqlite3.OperationalError:
+            pass
+
+
+def get_db(db_path: Path) -> sqlite3.Connection:
+    conn = sqlite3.connect(str(db_path), timeout=30)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA busy_timeout = 30000")
+    return conn
+
+
+
+def pending_assignment_sql(alias: str = "a") -> str:
+    """Assignment is still actionable: not finished AND not expired."""
+    return (
+        f"({alias}.status NOT IN ('{STATUS_COMPLETED}', '{STATUS_PARTIAL}', '{STATUS_SKIPPED}') "
+        f"AND {alias}.expires_at > datetime('now'))"
+    )

evals/human_eval/filter_db.py

@@ -0,0 +1,366 @@
+"""Filter human_eval.db → human_eval_filtered.db by removing low-quality annotators.
+
+Implements the cleaning rules documented in:
+  docs/exp-results/eval/humaneval/cleandata.md
+
+Rules (require multiple signals to converge):
+  1. Constant scores (std=0): all dimensions get the same score regardless of video
+  2. Near-constant (std<0.3): almost all scores identical
+  3. 100% copy-paste: every video has all dimensions scored identically
+  4. High copy-paste (≥75%) + behavioral anomaly (median stay <30s or never plays)
+  5. Tiny volume: <5 annotation items or median stay <10s
+  6. Extreme Peer MAE (>1.8) + behavioral anomaly (median stay <30s or never plays
+     or copy-paste ≥50%)
+
+Usage:
+  python -m eval.human_eval.filter_db
+  python -m eval.human_eval.filter_db --dry-run
+  python -m eval.human_eval.filter_db --input evals/human_eval/human_eval.db \
+      --output evals/human_eval/human_eval_filtered.db
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import math
+import shutil
+import sqlite3
+import statistics
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_INPUT = "evals/human_eval/human_eval.db"
+DEFAULT_OUTPUT = "evals/human_eval/human_eval_filtered.db"
+
+
+def _compute_annotator_metrics(conn: sqlite3.Connection) -> dict[int, dict]:
+    """Compute per-annotator quality metrics."""
+    rows = conn.execute("""
+        SELECT
+            a.annotator_id,
+            ann.id AS annotation_id,
+            ann.play_count,
+            ann.stay_seconds,
+            ai.dimension,
+            ai.law,
+            ai.score,
+            a.video_id
+        FROM assignments a
+        JOIN annotations ann ON ann.assignment_id = a.id
+        JOIN annotation_items ai ON ai.annotation_id = ann.id
+        WHERE a.status = 'completed'
+        ORDER BY a.annotator_id, a.video_id
+    """).fetchall()
+
+    # Group by annotator
+    annotators: dict[int, dict] = {}
+    for row in rows:
+        aid = row[0]
+        if aid not in annotators:
+            annotators[aid] = {
+                "all_scores": [],
+                "videos": defaultdict(list),  # video_id -> [scores]
+                "stay_seconds": [],
+                "play_counts": [],
+                "annotation_ids": set(),
+                "item_count": 0,
+            }
+        m = annotators[aid]
+        m["all_scores"].append(row[6])
+        m["videos"][row[7]].append(row[6])
+        m["item_count"] += 1
+        ann_id = row[1]
+        if ann_id not in m["annotation_ids"]:
+            m["annotation_ids"].add(ann_id)
+            if row[2] is not None:
+                m["play_counts"].append(row[2])
+            if row[3] is not None:
+                m["stay_seconds"].append(row[3])
+
+    # Compute metrics
+    for aid, m in annotators.items():
+        scores = m["all_scores"]
+        m["overall_std"] = statistics.pstdev(scores) if len(scores) > 1 else 0.0
+
+        # Copy-paste rate: fraction of videos where all dims got the same score
+        cp_count = 0
+        total_videos = 0
+        for vid, vscores in m["videos"].items():
+            if len(vscores) > 1:
+                total_videos += 1
+                if len(set(vscores)) == 1:
+                    cp_count += 1
+        m["copy_paste_rate"] = cp_count / total_videos if total_videos > 0 else 0.0
+        m["video_count"] = total_videos
+
+        m["median_stay"] = statistics.median(m["stay_seconds"]) if m["stay_seconds"] else 0.0
+        m["median_play"] = statistics.median(m["play_counts"]) if m["play_counts"] else 0.0
+        m["max_play"] = max(m["play_counts"]) if m["play_counts"] else 0
+        n_annotations = len(m["annotation_ids"])
+        zero_play = sum(1 for p in m["play_counts"] if p == 0)
+        m["zero_play_rate"] = zero_play / n_annotations if n_annotations > 0 else 0.0
+
+    return annotators
+
+
+def _compute_peer_mae(conn: sqlite3.Connection, annotator_ids: set[int]) -> dict[int, float]:
+    """Compute per-annotator Peer MAE: mean |score - peer_score| on shared video-dimensions."""
+    rows = conn.execute("""
+        SELECT
+            a.annotator_id,
+            a.video_id,
+            ai.dimension,
+            ai.law,
+            ai.score
+        FROM assignments a
+        JOIN annotations ann ON ann.assignment_id = a.id
+        JOIN annotation_items ai ON ai.annotation_id = ann.id
+        WHERE a.status = 'completed'
+        ORDER BY a.video_id, ai.dimension, ai.law
+    """).fetchall()
+
+    # Group scores by (video_id, dimension, law)
+    dim_groups: dict[tuple, list[tuple[int, int]]] = defaultdict(list)
+    for row in rows:
+        aid, vid, dim, law, score = row
+        if aid not in annotator_ids:
+            continue
+        key = (vid, dim, law)
+        dim_groups[key].append((aid, score))
+
+    # Compute pairwise MAE per annotator
+    annotator_diffs: dict[int, list[int]] = defaultdict(list)
+    for key, entries in dim_groups.items():
+        if len(entries) < 2:
+            continue
+        for i, (aid_i, score_i) in enumerate(entries):
+            for j, (aid_j, score_j) in enumerate(entries):
+                if i < j:
+                    diff = abs(score_i - score_j)
+                    annotator_diffs[aid_i].append(diff)
+                    annotator_diffs[aid_j].append(diff)
+
+    return {
+        aid: statistics.mean(diffs) if diffs else 0.0
+        for aid, diffs in annotator_diffs.items()
+    }
+
+
+def identify_removals(
+    metrics: dict[int, dict],
+    peer_mae: dict[int, float],
+) -> dict[int, str]:
+    """Return {annotator_id: reason} for annotators to remove."""
+    removals: dict[int, str] = {}
+
+    for aid, m in metrics.items():
+        # Rule 1: constant scores (std=0)
+        if m["item_count"] >= 5 and m["overall_std"] == 0.0:
+            removals[aid] = "constant_scores (std=0)"
+            continue
+
+        # Rule 2: near-constant (std<0.3)
+        if m["item_count"] >= 5 and m["overall_std"] < 0.3:
+            removals[aid] = f"near_constant (std={m['overall_std']:.2f})"
+            continue
+
+        # Rule 5: tiny volume (<5 items or median stay <10s)
+        if m["item_count"] < 5:
+            removals[aid] = f"tiny_volume ({m['item_count']} items)"
+            continue
+        if m["median_stay"] < 10.0 and m["item_count"] < 10:
+            removals[aid] = f"tiny_volume (stay={m['median_stay']:.0f}s, {m['item_count']} items)"
+            continue
+
+        # Rule 3: 100% copy-paste (with enough videos)
+        if m["video_count"] >= 3 and m["copy_paste_rate"] >= 1.0:
+            removals[aid] = "100%_copy_paste"
+            continue
+
+        # Rule 4: high copy-paste + behavioral anomaly
+        behavioral_anomaly = m["median_stay"] < 30.0 or m["max_play"] == 0
+        if m["copy_paste_rate"] >= 0.75 and behavioral_anomaly:
+            removals[aid] = (
+                f"high_copy_paste ({m['copy_paste_rate']:.0%}) "
+                f"+ behavioral (stay={m['median_stay']:.0f}s, max_play={m['max_play']})"
+            )
+            continue
+
+        # Rule 6: extreme Peer MAE + behavioral anomaly
+        pmae = peer_mae.get(aid, 0.0)
+        if pmae > 1.8 and (behavioral_anomaly or m["copy_paste_rate"] >= 0.50):
+            removals[aid] = (
+                f"high_peer_mae ({pmae:.2f}) "
+                f"+ behavioral (stay={m['median_stay']:.0f}s, cp={m['copy_paste_rate']:.0%})"
+            )
+            continue
+
+        # Rule 7: never played video + short stay
+        if m["zero_play_rate"] >= 1.0 and m["median_stay"] < 30.0:
+            removals[aid] = (
+                f"never_played (zero_play=100%) "
+                f"+ short_stay (stay={m['median_stay']:.0f}s)"
+            )
+            continue
+
+    return removals
+
+
+def apply_filter(input_db: str, output_db: str, removals: dict[int, str]) -> dict:
+    """Copy input_db to output_db and delete data for removed annotators."""
+    shutil.copy2(input_db, output_db)
+    conn = sqlite3.connect(output_db)
+    conn.execute("PRAGMA foreign_keys = OFF")
+
+    removed_ids = list(removals.keys())
+    if not removed_ids:
+        conn.close()
+        return {"removed": 0}
+
+    placeholders = ",".join("?" * len(removed_ids))
+
+    # Get assignment IDs to remove
+    assignment_ids = [
+        r[0] for r in conn.execute(
+            f"SELECT id FROM assignments WHERE annotator_id IN ({placeholders})",
+            removed_ids,
+        ).fetchall()
+    ]
+
+    if assignment_ids:
+        a_ph = ",".join("?" * len(assignment_ids))
+
+        # Get annotation IDs
+        annotation_ids = [
+            r[0] for r in conn.execute(
+                f"SELECT id FROM annotations WHERE assignment_id IN ({a_ph})",
+                assignment_ids,
+            ).fetchall()
+        ]
+
+        if annotation_ids:
+            ann_ph = ",".join("?" * len(annotation_ids))
+            conn.execute(
+                f"DELETE FROM annotation_items WHERE annotation_id IN ({ann_ph})",
+                annotation_ids,
+            )
+            conn.execute(
+                f"DELETE FROM annotations WHERE id IN ({ann_ph})",
+                annotation_ids,
+            )
+
+        conn.execute(
+            f"DELETE FROM assignments WHERE id IN ({a_ph})",
+            assignment_ids,
+        )
+
+    conn.execute(
+        f"DELETE FROM annotators WHERE id IN ({placeholders})",
+        removed_ids,
+    )
+
+    # Clean up orphaned comparison_groups
+    conn.execute("""
+        DELETE FROM comparison_groups
+        WHERE id NOT IN (SELECT DISTINCT group_id FROM assignments WHERE group_id IS NOT NULL)
+    """)
+
+    conn.commit()
+
+    # Collect stats
+    stats = {}
+    for table in ["annotators", "videos", "assignments", "annotations", "annotation_items", "comparison_groups"]:
+        stats[table] = conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
+    conn.close()
+
+    return stats
+
+
+def _print_removal_summary(removals: dict[int, str], conn: sqlite3.Connection) -> None:
+    """Print summary of annotators to be removed."""
+    if not removals:
+        print("No annotators to remove.")
+        return
+
+    # Get names
+    ids = list(removals.keys())
+    ph = ",".join("?" * len(ids))
+    name_map = {
+        r[0]: r[1]
+        for r in conn.execute(
+            f"SELECT id, name FROM annotators WHERE id IN ({ph})", ids
+        ).fetchall()
+    }
+
+    # Group by reason category
+    by_category: dict[str, list[str]] = defaultdict(list)
+    for aid, reason in removals.items():
+        cat = reason.split("(")[0].strip().split("+")[0].strip()
+        by_category[cat].append(f"  {name_map.get(aid, '?')} (id={aid}): {reason}")
+
+    print(f"\n=== Annotators to remove: {len(removals)} ===")
+    for cat, entries in sorted(by_category.items()):
+        print(f"\n{cat} ({len(entries)}):")
+        for e in sorted(entries):
+            print(e)
+
+
+def main(argv: list[str] | None = None) -> int:
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+    parser = argparse.ArgumentParser(description="Filter human_eval.db")
+    parser.add_argument("--input", default=DEFAULT_INPUT, help="Input DB path")
+    parser.add_argument("--output", default=DEFAULT_OUTPUT, help="Output DB path")
+    parser.add_argument("--dry-run", action="store_true", help="Show removals without writing")
+    args = parser.parse_args(argv)
+
+    if not Path(args.input).exists():
+        logger.error("Input DB not found: %s", args.input)
+        return 1
+
+    conn = sqlite3.connect(args.input, timeout=30)
+
+    print("Computing annotator metrics...")
+    metrics = _compute_annotator_metrics(conn)
+    print(f"  {len(metrics)} annotators with completed annotations")
+
+    print("Computing Peer MAE...")
+    peer_mae = _compute_peer_mae(conn, set(metrics.keys()))
+
+    removals = identify_removals(metrics, peer_mae)
+    _print_removal_summary(removals, conn)
+
+    if args.dry_run:
+        conn.close()
+        print("\n[DRY RUN] No output written.")
+        return 0
+
+    # Sync excluded_annotators table in the main DB so assignment can
+    # skip bad annotators without needing the filtered DB.
+    conn.execute("CREATE TABLE IF NOT EXISTS excluded_annotators ("
+                 "annotator_id INTEGER PRIMARY KEY, reason TEXT NOT NULL, "
+                 "generated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)")
+    conn.execute("DELETE FROM excluded_annotators")
+    for aid, reason in removals.items():
+        conn.execute(
+            "INSERT INTO excluded_annotators (annotator_id, reason) VALUES (?, ?)",
+            (aid, reason),
+        )
+    conn.commit()
+    print(f"\nUpdated excluded_annotators in main DB: {len(removals)} entries")
+    conn.close()
+
+    print(f"Writing filtered DB to {args.output}...")
+    stats = apply_filter(args.input, args.output, removals)
+    print("Filtered DB stats:")
+    for table, count in stats.items():
+        print(f"  {table}: {count}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

evals/human_eval/import_videos.py

@@ -0,0 +1,96 @@
+import hashlib
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+from human_eval.config import COMPARISON_MODELS, STATUS_SKIPPED
+
+GENERAL_KEYS = ["SA", "PTV", "persistence"]
+
+
+def compute_import_hash(video_data_dir: Path) -> str:
+    """Global hash across all datasets (used by initial import guard)."""
+    paths = sorted(str(p.relative_to(video_data_dir)) for p in video_data_dir.rglob("*.mp4"))
+    return hashlib.md5("\n".join(paths).encode()).hexdigest()
+
+
+def compute_dataset_hash(dataset_dir: Path) -> str:
+    """Per-dataset hash — only includes mp4 filenames within one dataset."""
+    paths = sorted(p.name for p in dataset_dir.glob("*.mp4"))
+    return hashlib.md5("\n".join(paths).encode()).hexdigest()
+
+
+def compute_difficulty_score(gemini_scores: dict, qwen_scores: dict) -> float | None:
+    diffs = []
+    for key in GENERAL_KEYS:
+        g, q = gemini_scores.get(key), qwen_scores.get(key)
+        if g is None or q is None:
+            return None
+        diffs.append(abs(g - q))
+    return sum(diffs) / len(diffs) if diffs else None
+
+
+def _load_latest_eval(dataset_dir: Path, prefix: str) -> dict | None:
+    files = sorted(dataset_dir.glob(f"eval_{prefix}_*.json"))
+    if not files:
+        return None
+    with open(files[-1]) as f:
+        return json.load(f)
+
+
+def _build_scores_lookup(eval_data: dict | None) -> dict:
+    if not eval_data or "results" not in eval_data:
+        return {}
+    lookup = {}
+    for r in eval_data["results"]:
+        scores = {k: r[k] for k in GENERAL_KEYS if k in r}
+        lookup[r["video"]] = scores
+    return lookup
+
+
+
+
+_DATASET_SUFFIXES = ("openvid", "video_phy_2", "physics_iq", "wmb")
+
+
+def _ds_suffix(db_dataset: str) -> str:
+    """Extract source dataset suffix from DB dataset name, e.g. 'veo-3.1-video_phy_2' -> 'video_phy_2'."""
+    for suffix in _DATASET_SUFFIXES:
+        if db_dataset.endswith(suffix):
+            return suffix
+    return db_dataset
+
+
+class _EvalLookupCache:
+    """Caches per-dataset eval score lookups and dataset hashes."""
+
+    def __init__(self):
+        self._eval: dict[str, tuple[dict, dict]] = {}
+        self._hash: dict[str, str] = {}
+
+    def get_scores(self, ds_name: str, ds_dir: Path) -> tuple[dict, dict]:
+        if ds_name not in self._eval:
+            self._eval[ds_name] = (
+                _build_scores_lookup(_load_latest_eval(ds_dir, "gemini")),
+                _build_scores_lookup(_load_latest_eval(ds_dir, "qwen")),
+            )
+        return self._eval[ds_name]
+
+    def get_hash(self, ds_name: str, ds_dir: Path) -> str:
+        if ds_name not in self._hash:
+            self._hash[ds_name] = compute_dataset_hash(ds_dir) if ds_dir.exists() else ""
+        return self._hash[ds_name]
+
+
+def import_videos(conn, video_data_dir: Path):
+    """Import videos into the human-eval DB.
+
+    This release omits the prompt-selection JSON consumed by the original
+    importer, so the importer entry point is intentionally disabled.
+    """
+    raise RuntimeError(
+        "import_videos is not included in this release because the prompt-selection "
+        "JSON is omitted. Use the companion dataset metadata to build a DB import."
+    )
+

evals/human_eval/init_test_db.py

@@ -0,0 +1,66 @@
+"""Initialize test DB by copying videos & comparison_groups from production DB.
+
+Usage:
+    python -m human_eval.init_test_db          # default paths from config
+    python -m human_eval.init_test_db --reset   # drop & recreate test DB
+"""
+import argparse
+import sqlite3
+from pathlib import Path
+
+from human_eval.config import DB_PATH, TEST_DB_PATH
+from human_eval.db import init_db, get_db
+
+
+# Tables whose rows are copied verbatim from prod → test
+_COPY_TABLES = ["videos", "comparison_groups"]
+
+
+def init_test_db(*, reset: bool = False):
+    if reset and TEST_DB_PATH.exists():
+        TEST_DB_PATH.unlink()
+        print(f"removed old test DB: {TEST_DB_PATH}")
+
+    if not DB_PATH.exists():
+        raise FileNotFoundError(f"production DB not found: {DB_PATH}")
+
+    # Open production (read-only) and test DBs
+    prod = sqlite3.connect(str(DB_PATH))
+    prod.row_factory = sqlite3.Row
+    prod.execute("PRAGMA query_only = ON")
+
+    test = get_db(TEST_DB_PATH)
+    init_db(test)
+
+    for table in _COPY_TABLES:
+        existing = test.execute(f"SELECT COUNT(*) AS c FROM {table}").fetchone()["c"]
+        if existing > 0 and not reset:
+            print(f"  {table}: already has {existing} rows, skipping (use --reset to overwrite)")
+            continue
+
+        if reset:
+            test.execute(f"DELETE FROM {table}")
+
+        cols_info = prod.execute(f"PRAGMA table_info({table})").fetchall()
+        col_names = [c["name"] for c in cols_info]
+        cols_csv = ", ".join(col_names)
+        placeholders = ", ".join("?" for _ in col_names)
+
+        rows = prod.execute(f"SELECT {cols_csv} FROM {table}").fetchall()
+        test.executemany(
+            f"INSERT OR IGNORE INTO {table} ({cols_csv}) VALUES ({placeholders})",
+            [tuple(r) for r in rows],
+        )
+        test.commit()
+        print(f"  {table}: copied {len(rows)} rows")
+
+    prod.close()
+    test.close()
+    print(f"test DB ready: {TEST_DB_PATH}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--reset", action="store_true", help="drop & recreate test DB")
+    args = parser.parse_args()
+    init_test_db(reset=args.reset)

evals/human_eval/static/rate.js

@@ -0,0 +1,211 @@
+function confirmSkip(form) {
+  var reason = form.querySelector('.skip-reason-input').value.trim();
+  if (!reason) {
+    alert('Please enter a skip reason.');
+    return false;
+  }
+  return confirm('Are you sure you want to skip this video?\n\nReason: ' + reason);
+}
+
+var _scoreColors = {1: '#ef4444', 2: '#f97316', 3: '#eab308', 4: '#16a34a', 5: '#15803d'};
+
+function _applyScoreColor(btn) {
+  var v = parseInt(btn.dataset.value);
+  btn.style.background = _scoreColors[v] || '#888';
+  btn.style.borderColor = 'transparent';
+  btn.style.color = '#fff';
+}
+
+function _clearScoreColor(btn) {
+  btn.style.background = '';
+  btn.style.borderColor = '';
+  btn.style.color = '';
+}
+
+function selectScore(btn) {
+  const row = btn.closest('.dim-row');
+  row.querySelectorAll('.score-btn').forEach(b => { b.classList.remove('selected'); _clearScoreColor(b); });
+  btn.classList.add('selected');
+  _applyScoreColor(btn);
+  row.querySelector('input[type="hidden"]').value = btn.dataset.value;
+  checkFormComplete();
+}
+
+// Color pre-selected buttons on page load
+document.addEventListener('DOMContentLoaded', function() {
+  document.querySelectorAll('.score-btn.selected').forEach(_applyScoreColor);
+});
+
+function _updateSubmitBtn(form, selector) {
+  var allFilled = Array.from(form.querySelectorAll('.score-input')).every(function(i) {
+    if (i.closest('.physical-dim-row')) return true;  // physical dims are optional
+    return i.value;
+  });
+  var btn = form.querySelector(selector);
+  if (btn) btn.disabled = !allFilled;
+}
+
+function checkFormComplete() {
+  // Save button: always enabled (allow partial saves midway)
+  // Next button: always enabled (users can skip ahead)
+}
+
+// --- Play count & stay time tracking ---
+
+var _playCountMap = {};   // vid -> count
+var _stayStartMap = {};   // vid -> timestamp (ms)
+
+function _incPlayCount(vid, card) {
+  if (!vid || !card) return;
+  _playCountMap[vid] = (_playCountMap[vid] || 0) + 1;
+  var inp = card.querySelector('.play-count-input');
+  if (inp) inp.value = _playCountMap[vid];
+}
+
+function _updateStaySeconds(vid, card) {
+  if (!vid || !_stayStartMap[vid] || !card) return;
+  var elapsed = (Date.now() - _stayStartMap[vid]) / 1000;
+  var inp = card.querySelector('.stay-seconds-input');
+  if (inp) inp.value = elapsed.toFixed(1);
+}
+
+// --- Custom video controls (comparison mode: hide duration) ---
+
+var _progressRAF = null;
+var _videoWraps = [];
+
+function _startProgressLoop() {
+  if (_progressRAF) return;
+  function tick() {
+    _videoWraps.forEach(function(wrap) {
+      var video = wrap.querySelector('video');
+      var bar = wrap.querySelector('.vc-progress');
+      if (video && bar && video.duration) {
+        bar.style.width = (video.currentTime / video.duration * 100) + '%';
+      }
+    });
+    var anyPlaying = _videoWraps.some(function(wrap) {
+      var v = wrap.querySelector('video');
+      return v && !v.paused && !v.ended;
+    });
+    if (anyPlaying) {
+      _progressRAF = requestAnimationFrame(tick);
+    } else {
+      _progressRAF = null;
+    }
+  }
+  _progressRAF = requestAnimationFrame(tick);
+}
+
+function togglePlay(btn) {
+  var video = btn.closest('.compare-video-wrap').querySelector('video');
+  if (video.paused) {
+    var card = btn.closest('.compare-card');
+    _incPlayCount(card ? card.dataset.vid : null, card);
+    video.play();
+    btn.textContent = '\u23F8';
+    _startProgressLoop();
+  } else {
+    video.pause();
+    btn.textContent = '\u25B6';
+  }
+}
+
+function toggleMute(btn) {
+  var video = btn.closest('.compare-video-wrap').querySelector('video');
+  video.muted = !video.muted;
+  btn.textContent = video.muted ? '\uD83D\uDD07' : '\uD83D\uDD09';
+}
+
+function seekVideo(e, bar) {
+  var video = bar.closest('.compare-video-wrap').querySelector('video');
+  var rect = bar.getBoundingClientRect();
+  var pct = (e.clientX - rect.left) / rect.width;
+  video.currentTime = pct * video.duration;
+  var progressBar = bar.querySelector('.vc-progress');
+  if (progressBar) progressBar.style.width = (pct * 100) + '%';
+}
+
+document.addEventListener('DOMContentLoaded', function() {
+  checkFormComplete();
+
+  // Cache video wraps for rAF progress loop
+  _videoWraps = Array.from(document.querySelectorAll('.compare-video-wrap'));
+
+  // Reset play button when video ends & click-to-play on video itself
+  _videoWraps.forEach(function(wrap) {
+    var video = wrap.querySelector('video');
+    if (video) {
+      video.addEventListener('ended', function() {
+        var btn = wrap.querySelector('.vc-play');
+        if (btn) btn.textContent = '\u25B6';
+      });
+      video.style.cursor = 'pointer';
+      video.addEventListener('click', function() {
+        var btn = wrap.querySelector('.vc-play');
+        if (btn) togglePlay(btn);
+      });
+    }
+  });
+
+  // Start stay timer for each card
+  var now = Date.now();
+  document.querySelectorAll('.compare-card').forEach(function(card) {
+    var vid = card.dataset.vid;
+    if (vid) _stayStartMap[vid] = now;
+  });
+
+});
+
+function _showToast(msg) {
+  var toast = document.getElementById('save-toast');
+  if (!toast) {
+    toast = document.createElement('div');
+    toast.id = 'save-toast';
+    toast.style.cssText = 'position:fixed;top:50%;left:50%;transform:translate(-50%,-50%);background:rgba(0,0,0,0.8);color:#fff;padding:16px 32px;border-radius:8px;font-size:1.2rem;z-index:9999;pointer-events:none;opacity:0;transition:opacity 0.3s;';
+    document.body.appendChild(toast);
+  }
+  toast.textContent = msg;
+  toast.style.opacity = '1';
+  setTimeout(function() { toast.style.opacity = '0'; }, 1500);
+}
+
+function _collectFormData(action) {
+  var form = document.getElementById('submit-all-form');
+  if (!form) return null;
+  // Flush stay seconds
+  document.querySelectorAll('.compare-card').forEach(function(card) {
+    var vid = card.dataset.vid;
+    if (vid) _updateStaySeconds(vid, card);
+  });
+  var data = new FormData(form);
+  data.set('action', action);
+  return { url: form.action, data: data };
+}
+
+function doSave() {
+  var fd = _collectFormData('save');
+  if (!fd) return;
+  fetch(fd.url, { method: 'POST', body: fd.data })
+    .then(function(r) { if (r.ok) _showToast('Saved!'); else _showToast('Error'); })
+    .catch(function() { _showToast('Error'); });
+}
+
+function doNext() {
+  var fd = _collectFormData('next');
+  if (!fd) {
+    // Fallback: go to task list if form not found
+    window.location.href = '/tasks';
+    return;
+  }
+  fetch(fd.url, { method: 'POST', body: fd.data })
+    .then(function(r) { return r.json(); })
+    .then(function(data) {
+      if (data.redirect) window.location.href = data.redirect;
+      else window.location.href = '/tasks';
+    })
+    .catch(function() {
+      // On any error, still navigate to next
+      window.location.href = '/tasks';
+    });
+}

evals/human_eval/static/style.css

@@ -0,0 +1,1277 @@
+/* Light theme */
+:root {
+  --bg: #ffffff;
+  --card: #f7f7f8;
+  --input: #f0f0f2;
+  --accent: #e94560;
+  --text: #1a1a1a;
+  --label: #2563eb;
+  --border: #d1d5db;
+  --green-bg: #ecfdf5;
+  --green-border: #a7f3d0;
+  --green-text: #16a34a;
+  --muted: #6b7280;
+  --muted-dim: #9ca3af;
+  --warning: #f59e0b;
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  background: var(--bg);
+  color: var(--text);
+  font-family: 'Segoe UI', 'PingFang SC', 'Microsoft YaHei', sans-serif;
+  font-size: 17px;
+  line-height: 1.6;
+  min-height: 100vh;
+}
+
+a {
+  color: var(--label);
+  text-decoration: none;
+}
+
+a:hover {
+  color: var(--accent);
+}
+
+/* ---- Instruction Banner ---- */
+.instruction-banner {
+  background: var(--input);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 14px 20px;
+  margin-bottom: 16px;
+  font-size: 16px;
+  line-height: 1.6;
+  color: var(--text);
+}
+.instruction-banner strong {
+  color: var(--text);
+}
+.scoring-guide-inline {
+  margin-top: 8px;
+  display: flex;
+  gap: 16px;
+  flex-wrap: wrap;
+  font-size: 15px;
+  color: #2563eb;
+}
+.scoring-guide-inline span:first-child {
+  font-weight: bold;
+  color: #2563eb;
+}
+
+/* ---- Buttons ---- */
+.btn {
+  display: inline-block;
+  padding: 8px 16px;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--input);
+  color: var(--text);
+  cursor: pointer;
+  font-size: 14px;
+  transition: background 0.2s, border-color 0.2s;
+}
+
+.btn:hover {
+  background: #e5e7eb;
+  border-color: var(--label);
+}
+
+.btn-primary {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: #fff;
+}
+
+.btn-primary:hover {
+  background: #c73050;
+  border-color: #c73050;
+}
+
+.btn-danger {
+  background: #fef2f2;
+  border-color: #fca5a5;
+  color: #dc2626;
+}
+
+.btn-danger:hover {
+  background: var(--accent);
+  border-color: var(--accent);
+}
+
+.btn-sm {
+  padding: 5px 10px;
+  font-size: 12px;
+}
+
+.btn:disabled,
+.btn[disabled] {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+
+/* ---- Container ---- */
+.container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 20px;
+}
+
+/* ---- Login ---- */
+.login-container {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-height: 100vh;
+  gap: 20px;
+}
+
+.login-container h1 {
+  font-size: 2rem;
+  color: var(--label);
+  letter-spacing: 2px;
+}
+
+.welcome-msg {
+  color: var(--muted);
+  font-size: 15px;
+  text-align: center;
+  max-width: 420px;
+  line-height: 1.6;
+}
+
+.login-container form {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  width: 320px;
+}
+
+.login-container input[type="text"] {
+  padding: 10px 14px;
+  background: var(--input);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  color: var(--text);
+  font-size: 16px;
+  outline: none;
+}
+
+.login-container input[type="text"]:focus {
+  border-color: var(--label);
+}
+
+.login-hint {
+  color: var(--muted-dim);
+  font-size: 13px;
+  text-align: center;
+}
+
+.error-msg {
+  color: var(--accent);
+  background: #fef2f2;
+  border: 1px solid var(--accent);
+  border-radius: 4px;
+  padding: 8px 14px;
+  font-size: 14px;
+}
+
+/* ---- Topbar ---- */
+.topbar {
+  background: var(--card);
+  border-bottom: 1px solid var(--border);
+  padding: 12px 24px;
+  display: flex;
+  align-items: center;
+  gap: 16px;
+}
+
+.annotator-name {
+  font-weight: bold;
+  color: var(--text);
+  font-size: 16px;
+  margin-right: auto;
+}
+
+.progress-label {
+  color: var(--text);
+  font-size: 16px;
+}
+
+/* ---- Progress bar ---- */
+.progress-section {
+  background: var(--card);
+  border-bottom: 1px solid var(--border);
+  padding: 12px 24px;
+  display: flex;
+  align-items: center;
+  gap: 14px;
+}
+
+.progress-stats {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  min-width: 280px;
+}
+
+.progress-stat-main {
+  color: var(--text);
+  font-size: 15px;
+  font-weight: bold;
+}
+
+.progress-stat-user {
+  color: var(--text);
+  font-size: 14px;
+}
+
+.progress-bar-track {
+  flex: 1;
+  height: 14px;
+  background: var(--input);
+  border: 1px solid var(--border);
+  border-radius: 7px;
+  overflow: hidden;
+}
+
+.progress-bar-fill {
+  height: 100%;
+  background: linear-gradient(90deg, var(--green-border), var(--green-text));
+  border-radius: 7px;
+  transition: width 0.4s ease;
+}
+
+.progress-pct {
+  color: var(--text);
+  font-size: 15px;
+  font-weight: bold;
+  min-width: 48px;
+  text-align: right;
+}
+
+/* ---- Task list ---- */
+.task-list {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 20px 0;
+}
+
+.task-card {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 14px 18px;
+  color: var(--text);
+  transition: border-color 0.2s, background 0.2s;
+}
+
+.task-card:hover {
+  border-color: var(--label);
+  background: #eff6ff;
+}
+
+.task-card.completed {
+  opacity: 0.6;
+}
+
+.task-card-main {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  flex: 1;
+}
+
+.task-filename {
+  font-size: 16px;
+  color: var(--text);
+}
+
+.task-dataset {
+  font-size: 14px;
+  color: var(--text);
+}
+
+.domain-tag {
+  background: var(--input);
+  color: var(--text);
+  border-radius: 3px;
+  padding: 2px 8px;
+  font-size: 13px;
+  border: 1px solid var(--border);
+}
+
+.task-card-meta {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+/* ---- Status badges ---- */
+.status-badge {
+  display: inline-block;
+  padding: 3px 10px;
+  border-radius: 12px;
+  font-size: 12px;
+  font-weight: bold;
+}
+
+.status-badge.completed {
+  background: var(--green-bg);
+  color: var(--green-text);
+  border: 1px solid var(--green-border);
+}
+
+.status-badge.assigned {
+  background: #eff6ff;
+  color: var(--label);
+  border: 1px solid #bfdbfe;
+}
+
+.status-badge.skipped {
+  background: #f3f4f6;
+  color: var(--muted-dim);
+  border: 1px solid #d1d5db;
+}
+
+.empty-msg {
+  color: var(--muted-dim);
+  text-align: center;
+  padding: 40px;
+}
+
+/* ---- Rate layout ---- */
+.rate-layout {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 20px;
+  padding: 20px 0;
+}
+
+.rate-left {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+.video-player {
+  width: 100%;
+  border-radius: 6px;
+  background: #000;
+  border: 1px solid var(--border);
+}
+
+.prompt-box {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 14px 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.prompt-label {
+  color: var(--text);
+  font-size: 14px;
+  text-transform: uppercase;
+  letter-spacing: 1px;
+  font-weight: bold;
+}
+
+.prompt-text {
+  color: #1e90ff;
+  font-size: 20px;
+  line-height: 1.6;
+  font-weight: 600;
+}
+
+.rate-right {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+/* ---- Score sections ---- */
+.score-section {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 14px 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.section-title {
+  color: var(--text);
+  font-size: 15px;
+  text-transform: uppercase;
+  letter-spacing: 1px;
+  margin-bottom: 4px;
+  border-bottom: 1px solid var(--border);
+  padding-bottom: 6px;
+  font-weight: 600;
+}
+
+.dim-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+
+.dim-reasoning {
+  width: 100%;
+  font-size: 0.88em;
+  color: #555;
+  background: #f0f4f8;
+  border-left: 3px solid #6366f1;
+  padding: 6px 10px;
+  margin-top: 2px;
+  border-radius: 0 4px 4px 0;
+  line-height: 1.5;
+}
+
+.dim-info {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  flex: 1;
+  min-width: 0;
+}
+
+.dim-label {
+  color: var(--text);
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.dim-desc {
+  color: var(--text);
+  font-size: 13px;
+  line-height: 1.4;
+}
+
+.dim-key {
+  background: var(--input);
+  border-radius: 3px;
+  padding: 1px 5px;
+  font-size: 11px;
+  color: var(--accent);
+  margin-right: 4px;
+  font-family: monospace;
+}
+
+.score-btns {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+
+.score-btn {
+  width: 44px;
+  height: 44px;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  background: var(--input);
+  color: var(--text);
+  cursor: pointer;
+  font-size: 18px;
+  font-weight: 600;
+  transition: background 0.15s, border-color 0.15s;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.score-btn:hover {
+  border-color: var(--label);
+  background: #eff6ff;
+}
+
+.score-btn.selected {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: #fff;
+  font-weight: bold;
+}
+
+/* ---- Note input ---- */
+.note-input {
+  width: 100%;
+  min-height: 70px;
+  background: var(--input);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  color: var(--text);
+  font-size: 15px;
+  padding: 8px 10px;
+  resize: vertical;
+  outline: none;
+  font-family: inherit;
+}
+
+.note-input:focus {
+  border-color: var(--label);
+}
+
+/* ---- Form actions ---- */
+.form-actions {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+/* ---- Skip form ---- */
+.skip-form {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  margin-top: 4px;
+}
+
+.skip-reason-input {
+  flex: 1;
+  padding: 7px 10px;
+  background: var(--input);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  color: var(--text);
+  font-size: 13px;
+  outline: none;
+}
+
+.skip-reason-input:focus {
+  border-color: var(--accent);
+}
+
+.note-section { margin-top: 8px; }
+.note-input {
+  width: 100%;
+  min-height: 48px;
+  padding: 7px 10px;
+  background: var(--input);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  color: var(--text);
+  font-size: 13px;
+  resize: vertical;
+  outline: none;
+}
+.note-input:focus { border-color: var(--accent); }
+.note-input:disabled { opacity: .6; cursor: not-allowed; }
+
+/* ---- Scoring guide ---- */
+.scoring-guide {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 10px 16px;
+  display: flex;
+  gap: 20px;
+  align-items: center;
+  font-size: 14px;
+  color: var(--text);
+  margin-top: 10px;
+}
+
+.scoring-guide span:first-child {
+  color: var(--text);
+  font-weight: bold;
+}
+
+/* ---- Congrats screen ---- */
+.congrats-screen {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  min-height: 60vh;
+}
+.congrats-card {
+  text-align: center;
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: 48px 40px;
+  max-width: 500px;
+}
+.congrats-icon {
+  font-size: 64px;
+  margin-bottom: 16px;
+}
+.congrats-card h2 {
+  color: var(--accent);
+  margin: 0 0 12px;
+  font-size: 24px;
+}
+.congrats-card p {
+  color: var(--text);
+  font-size: 16px;
+  margin: 8px 0;
+}
+.congrats-sub {
+  color: var(--text) !important;
+  font-size: 15px !important;
+}
+
+/* ---- Guide button ---- */
+.btn-guide {
+  background: var(--green-bg);
+  border-color: var(--green-border);
+  color: var(--green-text);
+  font-size: 15px;
+  padding: 5px 14px;
+}
+.btn-guide:hover {
+  background: var(--green-border);
+  border-color: var(--green-text);
+  color: #fff;
+}
+.btn-guide-float {
+  float: right;
+  margin-top: -4px;
+}
+
+/* ---- Guide page ---- */
+.guide-container {
+  max-width: 900px;
+  padding-bottom: 60px;
+}
+
+.guide-topbar {
+  margin-bottom: 16px;
+}
+
+.guide-title {
+  color: var(--text);
+  font-size: 28px;
+  margin-bottom: 8px;
+}
+
+.guide-intro {
+  color: var(--text);
+  font-size: 16px;
+  line-height: 1.7;
+  margin-bottom: 28px;
+}
+
+.guide-section {
+  margin-bottom: 32px;
+}
+
+.guide-section h2 {
+  color: var(--text);
+  font-size: 20px;
+  border-bottom: 1px solid var(--border);
+  padding-bottom: 8px;
+  margin-bottom: 14px;
+}
+
+.guide-note {
+  color: var(--text);
+  font-size: 15px;
+  margin-bottom: 12px;
+  line-height: 1.6;
+}
+
+/* Guide table */
+.guide-table {
+  width: 100%;
+  border-collapse: collapse;
+  margin-bottom: 10px;
+}
+.guide-table th,
+.guide-table td {
+  padding: 10px 14px;
+  border: 1px solid var(--border);
+  text-align: left;
+  font-size: 14px;
+}
+.guide-table th {
+  background: var(--input);
+  color: var(--text);
+  font-size: 15px;
+}
+.score-cell {
+  font-weight: bold;
+  text-align: center;
+  width: 60px;
+}
+.score-cell.s5 { color: #15803d; }
+.score-cell.s4 { color: #16a34a; }
+.score-cell.s3 { color: #eab308; }
+.score-cell.s2 { color: #f97316; }
+.score-cell.s1 { color: #ef4444; }
+
+/* Dim cards */
+.dim-cards {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.guide-card {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 14px 18px;
+}
+
+.guide-card-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 6px;
+}
+
+.guide-card-label {
+  color: var(--text);
+  font-weight: bold;
+  font-size: 16px;
+}
+
+.guide-card-scale {
+  margin-left: auto;
+  color: var(--text);
+  font-size: 14px;
+  background: var(--input);
+  padding: 2px 8px;
+  border-radius: 3px;
+}
+
+.guide-card-desc {
+  color: var(--text);
+  font-size: 15px;
+  line-height: 1.5;
+  margin-bottom: 8px;
+}
+
+.guide-score-labels {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  font-size: 14px;
+  color: var(--text);
+}
+.guide-score-labels strong {
+  color: var(--text);
+}
+
+.guide-card-phys {
+  border-left: 3px solid var(--input);
+}
+
+.guide-card-warn {
+  border-left: 3px solid var(--accent);
+}
+.guide-card-warn h3 {
+  color: var(--accent);
+  font-size: 15px;
+  margin-bottom: 8px;
+}
+.guide-card-warn ul {
+  list-style: none;
+  padding: 0;
+}
+.guide-card-warn li {
+  padding: 6px 0;
+  border-bottom: 1px solid var(--border);
+  font-size: 15px;
+  line-height: 1.6;
+}
+.guide-card-warn li:last-child {
+  border-bottom: none;
+}
+.guide-card-warn p {
+  font-size: 15px;
+  line-height: 1.6;
+  color: var(--text);
+}
+
+.guide-domain-block {
+  margin-bottom: 16px;
+}
+.guide-domain-title {
+  color: var(--text);
+  font-size: 16px;
+  text-transform: capitalize;
+  margin-bottom: 8px;
+  padding-left: 4px;
+}
+
+.guide-list {
+  list-style: none;
+  padding: 0;
+}
+.guide-list li {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 10px 16px;
+  margin-bottom: 8px;
+  font-size: 13px;
+  line-height: 1.6;
+}
+
+.guide-footer {
+  text-align: center;
+  margin-top: 32px;
+}
+
+/* ---- Demo page ---- */
+.demo-example {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  padding: 20px 24px;
+  margin-bottom: 24px;
+}
+.demo-example .score-section {
+  margin-bottom: 12px;
+}
+.demo-video-wrap {
+  margin-bottom: 16px;
+  text-align: center;
+}
+.demo-video {
+  max-width: 560px;
+  width: 100%;
+  border-radius: 8px;
+  border: 1px solid var(--border);
+}
+.demo-judge {
+  font-weight: normal;
+  font-size: 12px;
+  color: var(--label);
+}
+/* Color-coded selected score buttons on demo page */
+.score-btn.demo-selected {
+  color: #fff !important;
+  border-color: transparent !important;
+  transform: scale(1.12);
+  box-shadow: 0 2px 6px rgba(0,0,0,0.15);
+}
+.demo-rationale {
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 12px 16px;
+  font-size: 14px;
+  line-height: 1.6;
+  margin-top: 12px;
+}
+.demo-rationale ul {
+  margin: 6px 0 0;
+  padding-left: 18px;
+}
+.demo-rationale li {
+  margin-bottom: 6px;
+}
+
+/* ---- Comparison mode ---- */
+.compare-container {
+  max-width: 1800px;
+}
+
+.compare-prompt {
+  margin-bottom: 16px;
+}
+
+.compare-grid {
+  display: grid;
+  gap: 16px;
+  margin-bottom: 20px;
+}
+.compare-grid-2 { grid-template-columns: repeat(2, 1fr); }
+.compare-grid-3 { grid-template-columns: repeat(3, 1fr); }
+.compare-grid-4 { grid-template-columns: repeat(4, 1fr); }
+
+.compare-card {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.compare-card-header {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding-bottom: 6px;
+  border-bottom: 1px solid var(--border);
+}
+
+.compare-label {
+  font-size: 16px;
+  font-weight: bold;
+  color: var(--accent);
+  letter-spacing: 1px;
+}
+
+.compare-video {
+  width: 100%;
+  aspect-ratio: 16 / 9;
+  object-fit: cover;
+  border-radius: 4px;
+  background: #000;
+  border: 1px solid var(--border);
+}
+
+.compare-card .score-section {
+  padding: 10px 12px;
+}
+
+.law-tag {
+  display: inline-block;
+  background: #e8f0fe;
+  color: #1a56db;
+  font-weight: 600;
+  font-size: 0.8em;
+  padding: 2px 8px;
+  border-radius: 4px;
+  box-shadow: 0 1px 3px rgba(0,0,0,0.15);
+  margin-right: 6px;
+  vertical-align: middle;
+}
+
+/* Domain header in physical sub-questions */
+.domain-header {
+  font-size: 12px;
+  font-weight: 700;
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+  margin: 10px 0 4px;
+  padding: 4px 0;
+  border-bottom: 1px solid var(--border);
+}
+
+/* Note text below criterion question */
+.dim-note {
+  display: block;
+  font-size: 0.82em;
+  color: var(--muted);
+  margin-top: 2px;
+  font-style: italic;
+}
+
+/* Guide page: note under question */
+.guide-card-note {
+  font-size: 13px;
+  color: var(--muted);
+  margin-top: 4px;
+  font-style: italic;
+}
+
+.compare-card .section-title {
+  font-size: 11px;
+  margin-bottom: 2px;
+  padding-bottom: 4px;
+}
+
+.compare-card .dim-row {
+  gap: 6px;
+}
+
+.compare-card .dim-info {
+  min-width: 0;
+}
+
+.compare-card .dim-label {
+  font-size: 14px;
+}
+
+.compare-card .dim-desc {
+  font-size: 12px;
+}
+
+.compare-card .score-btn {
+  width: 28px;
+  height: 28px;
+  font-size: 11px;
+}
+
+.compare-actions {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 10px;
+}
+
+/* Task list: prompt preview */
+.task-prompt-preview {
+  font-size: 15px;
+  color: var(--text);
+  flex: 1;
+  min-width: 0;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.task-model-count {
+  font-size: 13px;
+  color: var(--text);
+  background: var(--input);
+  padding: 2px 8px;
+  border-radius: 3px;
+  border: 1px solid var(--border);
+  white-space: nowrap;
+}
+
+/* ---- Custom video controls (hide duration) ---- */
+.compare-video-wrap {
+  position: relative;
+}
+
+.video-controls {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 8px;
+  background: rgba(0, 0, 0, 0.7);
+  border-radius: 0 0 4px 4px;
+  margin-top: -4px;
+}
+
+.vc-btn {
+  background: none;
+  border: none;
+  color: #fff;
+  cursor: pointer;
+  font-size: 14px;
+  padding: 2px 4px;
+  line-height: 1;
+}
+
+.vc-bar {
+  flex: 1;
+  height: 6px;
+  background: #444;
+  border-radius: 3px;
+  cursor: pointer;
+  position: relative;
+}
+
+.vc-progress {
+  height: 100%;
+  background: var(--accent);
+  border-radius: 3px;
+  width: 0%;
+  pointer-events: none;
+}
+
+/* ---- Per-video card states ---- */
+.compare-card.card-completed {
+  border-color: var(--green-border);
+  opacity: 0.6;
+}
+.compare-card.card-skipped {
+  border-color: #d1d5db;
+  opacity: 0.45;
+}
+.compare-card-header .status-badge {
+  margin-left: auto;
+  font-size: 11px;
+}
+.card-actions {
+  display: flex;
+  gap: 8px;
+  padding-top: 6px;
+}
+
+/* Instructions box on task list page */
+.instructions-box {
+  background: #f0f7ff;
+  border: 1px solid #b3d4fc;
+  border-radius: 10px;
+  padding: 20px 28px;
+  margin-bottom: 24px;
+}
+.instructions-box h2 {
+  margin: 0 0 10px;
+  font-size: 1.25rem;
+  color: #1a3a5c;
+}
+.instructions-box p {
+  margin: 6px 0;
+  color: #333;
+  line-height: 1.5;
+}
+
+/* Rating Scale Reference box on task list page */
+.scale-reference-box {
+  background: #fffbeb;
+  border: 1px solid #fcd34d;
+  border-radius: 10px;
+  padding: 20px 28px;
+  margin-bottom: 24px;
+}
+.scale-reference-box h2 {
+  margin: 0 0 10px;
+  font-size: 1.25rem;
+  color: #92400e;
+}
+.scale-reference-box p {
+  margin: 6px 0 14px;
+  color: #333;
+  line-height: 1.5;
+}
+.scale-table {
+  width: 100%;
+}
+.scale-table th {
+  text-align: left;
+}
+.scale-table td:first-child {
+  width: 60px;
+  text-align: center;
+}
+.scale-table td:nth-child(2) {
+  width: 180px;
+  white-space: nowrap;
+}
+
+.start-section {
+  text-align: center;
+  margin: 32px 0;
+}
+.btn-start {
+  display: inline-block;
+  padding: 16px 48px;
+  font-size: 1.2rem;
+  font-weight: 600;
+  color: #fff;
+  background: var(--accent);
+  border: none;
+  border-radius: 8px;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+.btn-start:hover {
+  background: #d63050;
+}
+
+/* Trial mode: all-models grid */
+.trial-container { max-width: 1800px; }
+.trial-grid {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: 14px;
+  margin-bottom: 20px;
+}
+.trial-grid .compare-card { font-size: 0.88rem; }
+.trial-grid .compare-video { max-height: 220px; }
+.trial-grid .section-title { font-size: 0.85rem; margin: 6px 0 4px; }
+.trial-grid .dim-label { font-size: 0.8rem; }
+.trial-grid .score-btn { min-width: 26px; padding: 3px 6px; font-size: 0.78rem; }
+.trial-grid .note-input { font-size: 0.8rem; padding: 4px 6px; min-height: 40px; }
+
+@media (max-width: 1600px) {
+  .trial-grid { grid-template-columns: repeat(3, 1fr); }
+}
+@media (max-width: 1100px) {
+  .trial-grid { grid-template-columns: repeat(2, 1fr); }
+}
+
+/* ---- Demographics form ---- */
+.demographics-box {
+  background: #f0f7ff;
+  border: 1px solid #b3d4fc;
+  border-radius: 10px;
+  padding: 24px 32px;
+  margin-bottom: 24px;
+  max-width: 560px;
+  margin-left: auto;
+  margin-right: auto;
+}
+.demographics-box h2 {
+  margin: 0 0 8px;
+  font-size: 1.25rem;
+  color: #1a3a5c;
+}
+.demographics-box > p {
+  color: #555;
+  margin-bottom: 20px;
+}
+.demographics-form {
+  display: flex;
+  flex-direction: column;
+  gap: 20px;
+}
+.demo-field {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.demo-label {
+  font-weight: 600;
+  font-size: 16px;
+  color: var(--text);
+}
+.demo-label .required {
+  color: var(--accent);
+}
+.demo-options {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 14px;
+}
+.demo-options label {
+  display: flex;
+  align-items: center;
+  gap: 5px;
+  font-size: 15px;
+  cursor: pointer;
+  color: var(--text);
+}
+.demo-input {
+  padding: 10px 14px;
+  background: var(--input);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  color: var(--text);
+  font-size: 15px;
+  outline: none;
+  width: 100%;
+}
+.demo-input:focus {
+  border-color: var(--label);
+}
+.demo-input-inline {
+  width: 160px;
+  padding: 6px 10px;
+  font-size: 14px;
+}
+.demo-input-inline:disabled {
+  opacity: 0.4;
+}
+
+/* Responsive: stack on narrow screens */
+@media (max-width: 1200px) {
+  .compare-grid-4 { grid-template-columns: repeat(2, 1fr); }
+}
+@media (max-width: 800px) {
+  .compare-grid-3,
+  .compare-grid-4,
+  .compare-grid-2 { grid-template-columns: 1fr; }
+  .trial-grid { grid-template-columns: 1fr; }
+}
+

evals/human_eval/supplement_laws.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+"""Disabled supplement script for the anonymous release.
+
+The original supplement flow depends on the prompt-selection JSON, which is not
+included in this release.
+"""
+
+
+def main():
+    raise RuntimeError(
+        "supplement_laws is not included in this release because it depends on "
+        "the omitted prompt-selection JSON."
+    )
+
+
+if __name__ == "__main__":
+    main()

evals/human_eval/templates/_progress_bar.html

@@ -0,0 +1,16 @@
+{# Progress bar partial — expects user_completed_groups, user_quota in context.
+   Set progress_compact = true before including to hide the stats text. #}
+<div class="progress-section">
+  {% if not progress_compact | default(false) %}
+  <div class="progress-stats">
+    <span class="progress-stat-main">
+      You: {{ user_completed_groups }} / {{ user_quota }} groups rated
+    </span>
+  </div>
+  {% endif %}
+  {% set pct = [user_completed_groups / user_quota * 100, 100] | min if user_quota > 0 else 0 %}
+  <div class="progress-bar-track">
+    <div class="progress-bar-fill" style="width: {{ pct | round(1) }}%"></div>
+  </div>
+  <span class="progress-pct">{{ pct | round(1) }}%</span>
+</div>

evals/human_eval/templates/_scale_table.html

@@ -0,0 +1,17 @@
+{# Rating scale reference table partial #}
+<div class="scale-reference-box">
+  <h2>Rating Scale Reference</h2>
+  <p>Before you begin rating, here is a summary of the scoring scale you will use. Keep these descriptions in mind as you rate each video.</p>
+  <table class="guide-table scale-table">
+    <thead>
+      <tr><th>Score</th><th>Label</th><th>What It Means</th></tr>
+    </thead>
+    <tbody>
+      <tr><td class="score-cell s5">5</td><td style="color:#15803d"><strong>Fully plausible</strong></td><td style="color:#15803d">You would not notice anything wrong if this were a real video. The physics looks exactly like the real world.</td></tr>
+      <tr><td class="score-cell s4">4</td><td style="color:#16a34a"><strong>Mostly plausible</strong></td><td style="color:#16a34a">The physics is mostly right, but you can spot a small oddity if you look carefully. It does not break your sense of realism.</td></tr>
+      <tr><td class="score-cell s3">3</td><td style="color:#eab308"><strong>Partially plausible</strong></td><td style="color:#eab308">You notice something clearly off about the physics. It is not right, but it is not wildly impossible either.</td></tr>
+      <tr><td class="score-cell s2">2</td><td style="color:#f97316"><strong>Largely implausible</strong></td><td style="color:#f97316">The physics is mostly wrong. You would immediately notice these errors in real life.</td></tr>
+      <tr><td class="score-cell s1">1</td><td style="color:#ef4444"><strong>Completely implausible</strong></td><td style="color:#ef4444">The physics is impossible. Objects do things that could never happen in the real world.</td></tr>
+    </tbody>
+  </table>
+</div>

evals/human_eval/templates/base.html

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{% block title %}Video Rating System{% endblock %}</title>
+  <link rel="stylesheet" href="/static/style.css">
+</head>
+<body>
+  <div id="mobile-block" style="display:none; position:fixed; inset:0; z-index:99999; background:#fff; justify-content:center; align-items:center; text-align:center; padding:2rem;">
+    <div>
+      <h2 style="font-size:1.5rem; margin-bottom:1rem;">Please use a computer</h2>
+      <p style="color:#666;">This requires a desktop or laptop browser for accurate video evaluation. Mobile devices are not supported.</p>
+    </div>
+  </div>
+  <script>
+    (function() {
+      var w = window.innerWidth;
+      if (w < 768 || /Android|iPhone|iPod/i.test(navigator.userAgent)) {
+        var b = document.getElementById('mobile-block');
+        b.style.display = 'flex';
+        document.body.style.overflow = 'hidden';
+      }
+    })();
+  </script>
+  {% block content %}{% endblock %}
+  {% block scripts %}{% endblock %}
+</body>
+</html>

evals/human_eval/templates/dashboard.html

@@ -0,0 +1,191 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Annotation Dashboard</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #f5f7fa; color: #333; padding: 2rem; }
+    h1 { font-size: 1.6rem; margin-bottom: 1.5rem; }
+    .cards { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
+    .card { background: #fff; border-radius: 10px; padding: 1.2rem; box-shadow: 0 1px 4px rgba(0,0,0,.08); text-align: center; }
+    .card .num { font-size: 2rem; font-weight: 700; }
+    .card .label { font-size: .85rem; color: #888; margin-top: .3rem; }
+    .card.green .num { color: #16a34a; }
+    .card.blue .num { color: #2563eb; }
+    .card.orange .num { color: #ea580c; }
+    .card.purple .num { color: #6366f1; }
+    .card.gray .num { color: #64748b; }
+
+    h2 { font-size: 1.2rem; margin: 1.5rem 0 .8rem; }
+    table { width: 100%; border-collapse: collapse; background: #fff; border-radius: 10px; overflow: hidden; box-shadow: 0 1px 4px rgba(0,0,0,.08); margin-bottom: 2rem; }
+    th, td { padding: .7rem 1rem; text-align: left; border-bottom: 1px solid #eee; }
+    th { background: #f8fafc; font-weight: 600; font-size: .85rem; color: #64748b; text-transform: uppercase; letter-spacing: .03em; }
+    td { font-size: .95rem; }
+    .bar-bg { background: #e5e7eb; border-radius: 4px; height: 8px; width: 100%; min-width: 120px; display: flex; overflow: hidden; }
+    .bar-fill { height: 8px; transition: width .3s; }
+    .bar-fill:first-child { border-radius: 4px 0 0 4px; }
+    .bar-fill:last-child { border-radius: 0 4px 4px 0; }
+    .bar-fill:only-child { border-radius: 4px; }
+    .bar-fill.done { background: #16a34a; }
+    .bar-fill.partial { background: #6366f1; }
+    .bar-fill.skipped { background: #fbbf24; }
+    .tag { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: .8rem; font-weight: 500; }
+    .tag-completed { background: #dcfce7; color: #166534; }
+    .tag-partial { background: #e0e7ff; color: #3730a3; }
+    .tag-assigned { background: #dbeafe; color: #1e40af; }
+    .tag-skipped { background: #fef3c7; color: #92400e; }
+    .ts { color: #94a3b8; font-size: .8rem; margin-top: 1.5rem; text-align: right; }
+    .refresh-btn { background: #2563eb; color: #fff; border: none; padding: .4rem 1rem; border-radius: 6px; cursor: pointer; font-size: .85rem; margin-left: 1rem; }
+    .refresh-btn:hover { background: #1d4ed8; }
+    .toggle-btn { background: #6366f1; color: #fff; border: none; padding: .4rem 1rem; border-radius: 6px; cursor: pointer; font-size: .85rem; margin-left: .5rem; }
+    .toggle-btn:hover { background: #4f46e5; }
+    .toggle-btn.active { background: #16a34a; }
+    .db-badge { display: inline-block; padding: 2px 10px; border-radius: 4px; font-size: .8rem; font-weight: 600; margin-left: .7rem; vertical-align: middle; }
+    .db-badge.raw { background: #fee2e2; color: #991b1b; }
+    .db-badge.filtered { background: #dcfce7; color: #166534; }
+    .card.red .num { color: #dc2626; }
+    .empty { color: #94a3b8; font-style: italic; padding: 1rem; }
+  </style>
+</head>
+<body>
+  <h1>Annotation Dashboard
+    <span class="db-badge {{ 'filtered' if filtered else 'raw' }}">{{ db_name }}</span>
+    {% if has_filtered_db %}
+    <a href="?filtered={{ '0' if filtered else '1' }}"><button class="toggle-btn {{ 'active' if filtered else '' }}">{{ 'Show Raw' if filtered else 'Show Filtered' }}</button></a>
+    {% endif %}
+    <button class="refresh-btn" onclick="location.reload()">Refresh</button>
+  </h1>
+
+  <div class="cards">
+    <div class="card blue"><div class="num">{{ total_videos }}</div><div class="label">Total Videos</div></div>
+    <div class="card green"><div class="num">{{ total_completed }}</div><div class="label">Completed</div></div>
+    <div class="card purple"><div class="num">{{ total_partial }}</div><div class="label">Partial</div></div>
+    <div class="card orange"><div class="num">{{ total_assigned }}</div><div class="label">Pending</div></div>
+    <div class="card gray"><div class="num">{{ total_skipped }}</div><div class="label">Skipped</div></div>
+    <div class="card"><div class="num">{{ total_annotations }}</div><div class="label">Annotations</div></div>
+    <div class="card red"><div class="num">{{ annotations_needed }}</div><div class="label">Still Needed ({{ target_n }}x)</div></div>
+    <div class="card"><div class="num">{{ total_groups }}</div><div class="label">Groups</div></div>
+  </div>
+
+  <h2>Coverage (target: {{ target_n }}x per video)</h2>
+  <div class="cards">
+    <div class="card green"><div class="num">{{ coverage.fully }}</div><div class="label">Fully Covered</div></div>
+    <div class="card orange"><div class="num">{{ coverage.partially }}</div><div class="label">Partially Covered</div></div>
+    <div class="card gray"><div class="num">{{ coverage.uncovered }}</div><div class="label">Uncovered</div></div>
+  </div>
+
+  <h2>Per-Model Coverage</h2>
+  <table>
+    <thead>
+      <tr><th>Model</th><th>Total</th><th>3x</th><th>2x</th><th>1x</th><th>0x</th><th>Coverage</th></tr>
+    </thead>
+    <tbody>
+      {% for m in per_model %}
+      {% set mtotal = m.fully + m.partially + m.uncovered %}
+      <tr>
+        <td>{{ m.model }}</td>
+        <td>{{ mtotal }}</td>
+        <td><span class="tag tag-completed">{{ m.v3 }}</span></td>
+        <td><span class="tag tag-partial">{{ m.v2 }}</span></td>
+        <td>{{ m.v1 }}</td>
+        <td>{{ m.v0 }}</td>
+        <td>
+          {% if mtotal > 0 %}
+          <div class="bar-bg"><div class="bar-fill done" style="width:{{ (m.v3 / mtotal * 100)|round }}%"></div>{% if m.v2 > 0 %}<div class="bar-fill partial" style="width:{{ (m.v2 / mtotal * 100)|round }}%"></div>{% endif %}{% if m.v1 > 0 %}<div class="bar-fill skipped" style="width:{{ (m.v1 / mtotal * 100)|round }}%"></div>{% endif %}</div>
+          <span style="font-size:.75rem;color:#888">{{ m.v3 + m.v2 + m.v1 }}/{{ mtotal }}</span>
+          {% endif %}
+        </td>
+      </tr>
+      {% endfor %}
+    </tbody>
+  </table>
+
+  <h2>Cohort Summary</h2>
+  <table>
+    <thead>
+      <tr><th>Cohort</th><th>Registered</th><th>Completed</th><th>Partial</th><th>Pending</th><th>Skipped</th><th>Progress</th></tr>
+    </thead>
+    <tbody>
+      {% for c in cohort_summary %}
+      <tr>
+        <td>{{ c.cohort }}</td>
+        <td>{{ c.registered }}{% if c.expected %}/{{ c.expected }}{% endif %}</td>
+        <td><span class="tag tag-completed">{{ c.completed }}</span></td>
+        <td><span class="tag tag-partial">{{ c.partial }}</span></td>
+        <td><span class="tag tag-assigned">{{ c.assigned }}</span></td>
+        <td><span class="tag tag-skipped">{{ c.skipped }}</span></td>
+        <td>
+          {% set total = c.completed + c.partial + c.assigned + c.skipped %}
+          {% if total > 0 %}
+          <div class="bar-bg"><div class="bar-fill done" style="width:{{ (c.completed / total * 100)|round }}%"></div>{% if c.partial > 0 %}<div class="bar-fill partial" style="width:{{ (c.partial / total * 100)|round }}%"></div>{% endif %}{% if c.skipped > 0 %}<div class="bar-fill skipped" style="width:{{ (c.skipped / total * 100)|round }}%"></div>{% endif %}</div>
+          <span style="font-size:.75rem;color:#888">{{ c.completed + c.partial }}/{{ total }}</span>
+          {% else %}
+          <span class="empty">no tasks</span>
+          {% endif %}
+        </td>
+      </tr>
+      {% endfor %}
+      <tr style="font-weight:700;background:#f8fafc">
+        <td>Total</td>
+        <td>{{ cohort_summary|sum(attribute='registered') }}/{{ cohort_summary|sum(attribute='expected') }}</td>
+        <td><span class="tag tag-completed">{{ cohort_summary|sum(attribute='completed') }}</span></td>
+        <td><span class="tag tag-partial">{{ cohort_summary|sum(attribute='partial') }}</span></td>
+        <td><span class="tag tag-assigned">{{ cohort_summary|sum(attribute='assigned') }}</span></td>
+        <td><span class="tag tag-skipped">{{ cohort_summary|sum(attribute='skipped') }}</span></td>
+        <td></td>
+      </tr>
+    </tbody>
+  </table>
+
+  <h2>NEU PG Student IDs</h2>
+  <table>
+    <thead>
+      <tr><th>Name</th><th>Cohort</th><th>Completed</th><th>Partial</th><th>Assigned</th><th>Skipped</th><th>Progress</th></tr>
+    </thead>
+    <tbody>
+      {% for a in per_annotator %}
+      <tr>
+        <td>{{ a.name }}</td>
+        <td>{{ a.cohort or '-' }}</td>
+        <td><span class="tag tag-completed">{{ a.completed }}</span></td>
+        <td><span class="tag tag-partial">{{ a.partial }}</span></td>
+        <td><span class="tag tag-assigned">{{ a.assigned }}</span></td>
+        <td><span class="tag tag-skipped">{{ a.skipped }}</span></td>
+        <td>
+          {% set total = a.completed + a.partial + a.assigned + a.skipped %}
+          {% if total > 0 %}
+          <div class="bar-bg"><div class="bar-fill done" style="width:{{ (a.completed / total * 100)|round }}%"></div>{% if a.partial > 0 %}<div class="bar-fill partial" style="width:{{ (a.partial / total * 100)|round }}%"></div>{% endif %}{% if a.skipped > 0 %}<div class="bar-fill skipped" style="width:{{ (a.skipped / total * 100)|round }}%"></div>{% endif %}</div>
+          <span style="font-size:.75rem;color:#888">{{ a.completed + a.partial }}/{{ total }}</span>
+          {% else %}
+          <span class="empty">no tasks</span>
+          {% endif %}
+        </td>
+      </tr>
+      {% endfor %}
+    </tbody>
+  </table>
+
+  {% if recent_activity %}
+  <h2>Recent Activity</h2>
+  <table>
+    <thead>
+      <tr><th>Annotator</th><th>Video</th><th>Status</th><th>Time</th></tr>
+    </thead>
+    <tbody>
+      {% for r in recent_activity %}
+      <tr>
+        <td>{{ r.name }}</td>
+        <td title="{{ r.filename }}">{{ r.filename|truncate(40) }}</td>
+        <td><span class="tag tag-{{ r.status }}">{{ r.status }}</span></td>
+        <td>{{ r.completed_at or r.assigned_at }}</td>
+      </tr>
+      {% endfor %}
+    </tbody>
+  </table>
+  {% endif %}
+
+  <div class="ts">Last loaded: <script>document.write(new Date().toLocaleString())</script></div>
+</body>
+</html>

evals/human_eval/templates/demo.html

@@ -0,0 +1,132 @@
+{% extends "base.html" %}
+
+{% block title %}{% if lang == 'zh' %}Demo{% else %}Demo{% endif %} — Video Rating System{% endblock %}
+
+{% block content %}
+<div class="topbar">
+  <span class="annotator-name">{{ annotator_name }}</span>
+  <span class="progress-label">Progress: {{ user_completed_groups }} / {{ user_quota }}</span>
+</div>
+
+{% include "_progress_bar.html" %}
+
+<div class="container">
+  <!-- Instructions -->
+  <div class="instructions-box">
+    <h2>Instructions</h2>
+    <p>You will be shown pairs of videos along with their text prompts and reference images. Your task is to evaluate whether each video obeys real-world physical laws independently.</p>
+    <p>Please provide thoughtful and consistent ratings. Your evaluations are very important to us.</p>
+    <p>Check the scoring demo examples below to see how we score videos before you begin.</p>
+  </div>
+
+  {% include "_scale_table.html" %}
+
+  <!-- Scoring Demo Examples -->
+  <div class="guide-container" style="max-width:100%; padding:0;">
+    <h1 class="guide-title">{% if lang == 'zh' %}评分示范{% else %}Scoring Demo{% endif %}</h1>
+    <p class="guide-intro">
+      {% if lang == 'zh' %}
+      以下是人工打分的实际案例。高亮的按钮是给出的分数，下方是评分理由，供你参考如何打分。
+      {% else %}
+      Below are human scoring examples. The highlighted button is the score given, with reasoning shown below. Use these as a reference for how to rate.
+      {% endif %}
+    </p>
+
+    {% for demo in demos %}
+    <div class="guide-section demo-example">
+      <h2>{% if lang == 'zh' %}示例{% else %}Example{% endif %} {{ loop.index }}</h2>
+
+      <!-- Prompt -->
+      <div class="prompt-box compare-prompt">
+        <span class="prompt-label">Prompt</span>
+        <p class="prompt-text">{{ demo.prompt }}</p>
+      </div>
+
+      <!-- Video -->
+      <div class="demo-video-wrap">
+        <video class="demo-video" controls muted loop>
+          <source src="{{ demo.video_url }}" type="video/mp4">
+        </video>
+        <p class="text-muted" style="font-size:0.85em; margin-top:0.3em;">
+          {% if lang == 'zh' %}点击 play 可以播放视频，再次点击可以重放{% else %}Click play to start the video; click again to replay{% endif %}
+        </p>
+      </div>
+
+      <!-- General Dimensions — same layout as rating page -->
+      {% set rg = demo.rationale_general_zh if lang == 'zh' and demo.rationale_general_zh else demo.rationale_general %}
+      <div class="score-section">
+        <h3 class="section-title">{% if lang == 'zh' %}通用维度{% else %}General Dimensions{% endif %}</h3>
+        {% for key, dim_label, values, description, score_labels in general_dims %}
+        <div class="dim-row">
+          <div class="dim-info">
+            <span class="dim-label">{{ description }}</span>
+          </div>
+          <div class="score-btns">
+            {% for v in values %}
+            <button type="button"
+              class="score-btn{% if demo.scores.get(key) == v %} demo-selected{% endif %}"
+              title="{{ score_labels[v] }}"
+              disabled>{{ v }}</button>
+            {% endfor %}
+          </div>
+          {% if rg and rg.get(key) %}
+          <div class="dim-reasoning">{{ rg[key] }}</div>
+          {% endif %}
+        </div>
+        {% endfor %}
+      </div>
+
+      <!-- Physical Sub-questions — same layout as rating page -->
+      {% if demo.physical_dims %}
+      {% set rp = demo.rationale_physical_zh if lang == 'zh' and demo.rationale_physical_zh else demo.rationale_physical %}
+      <div class="score-section">
+        <h3 class="section-title">{% if lang == 'zh' %}物理子问题{% else %}Physical Sub-questions{% endif %}</h3>
+        {% set phy_dims = demo.physical_dims_zh if lang == 'zh' and demo.physical_dims_zh else demo.physical_dims %}
+        {% for law_key, law_desc in phy_dims %}
+        {% set hc = human_criteria_by_key.get(law_key) %}
+        <div class="dim-row">
+          <div class="dim-info">
+            {% if hc %}
+            <span class="dim-label"><span class="law-tag">{{ law_key | capitalize }}</span> {{ hc.question }}</span>
+            {% if hc.note %}<span class="dim-note">{{ hc.note }}</span>{% endif %}
+            {% else %}
+            <span class="dim-label"><span class="law-tag">{{ law_key | capitalize }}</span> {{ law_desc }}</span>
+            {% endif %}
+          </div>
+          <div class="score-btns">
+            {% for v in [1, 2, 3, 4, 5] %}
+            <button type="button"
+              class="score-btn{% if demo.physical_scores.get(law_key) == v %} demo-selected{% endif %}"
+              disabled>{{ v }}</button>
+            {% endfor %}
+          </div>
+          {% if rp and rp.get(law_key) %}
+          <div class="dim-reasoning">{{ rp[law_key] }}</div>
+          {% endif %}
+        </div>
+        {% endfor %}
+      </div>
+      {% endif %}
+    </div>
+    {% endfor %}
+  </div>
+
+  <!-- Start Rating button -->
+  <div class="start-section">
+    <form action="/tasks/start" method="post">
+      <button type="submit" class="btn btn-start">{% if lang == 'zh' %}我已了解评分标准 — 开始评分{% else %}Start Rating{% endif %}</button>
+    </form>
+  </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+// Color demo-selected buttons by score value
+document.querySelectorAll('.score-btn.demo-selected').forEach(function(btn) {
+  var v = parseInt(btn.textContent.trim());
+  var colors = {5: '#15803d', 4: '#16a34a', 3: '#eab308', 2: '#f97316', 1: '#ef4444'};
+  btn.style.background = colors[v] || '#888';
+});
+</script>
+{% endblock %}

evals/human_eval/templates/demographics.html

@@ -0,0 +1,65 @@
+{% extends "base.html" %}
+
+{% block title %}Basic Information — Video Rating System{% endblock %}
+
+{% block content %}
+<div class="container">
+  <div class="demographics-box">
+    <h3>Basic Information</h3>
+    <p>Background information for internal use only.</p>
+    <form action="/demographics" method="POST" class="demographics-form">
+      <div class="demo-field">
+        <label class="demo-label">Gender <span class="required">*</span></label>
+        <div class="demo-options">
+          <label><input type="radio" name="gender" value="male" required> Male</label>
+          <label><input type="radio" name="gender" value="female"> Female</label>
+          <label><input type="radio" name="gender" value="other"> Other</label>
+          <label><input type="radio" name="gender" value="prefer_not_to_say"> Prefer not to say</label>
+        </div>
+      </div>
+      <div class="demo-field">
+        <label class="demo-label">Age <span class="required">*</span></label>
+        <select name="age" class="demo-input" style="width:240px" required>
+          <option value="" disabled selected>Select</option>
+          <option value="under18">Under 18</option>
+          <option value="18-22">18–22</option>
+          <option value="22-25">22–25</option>
+          <option value="26-30">26–30</option>
+          <option value="31-40">31–40</option>
+          <option value="41+">41+</option>
+        </select>
+      </div>
+      <div class="demo-field">
+        <label class="demo-label">Major <span class="required">*</span></label>
+        <div class="demo-options">
+          <label><input type="radio" name="major" value="CS" required> Computer Science</label>
+          <label><input type="radio" name="major" value="EE"> Electrical and Computer Engineering</label>
+          <label><input type="radio" name="major" value="Business"> Business</label>
+          <label><input type="radio" name="major" value="other"> Other:</label>
+          <input type="text" name="major_other" class="demo-input demo-input-inline" placeholder="Please specify" disabled>
+        </div>
+      </div>
+      <div class="demo-field">
+        <label class="demo-label">Highest education (including pursuing) <span class="required">*</span></label>
+        <select name="education" class="demo-input" style="width:240px" required>
+          <option value="" disabled selected>Select</option>
+          <option value="bachelor">Bachelor</option>
+          <option value="master">Master</option>
+          <option value="phd">PhD</option>
+        </select>
+      </div>
+      <script>
+        document.querySelectorAll('input[name="major"]').forEach(function(r) {
+          r.addEventListener('change', function() {
+            var otherInput = document.querySelector('input[name="major_other"]');
+            otherInput.disabled = this.value !== 'other';
+            if (this.value === 'other') otherInput.focus();
+            else otherInput.value = '';
+          });
+        });
+      </script>
+      <button type="submit" class="btn btn-primary btn-start">Continue</button>
+    </form>
+  </div>
+</div>
+{% endblock %}

evals/human_eval/templates/guide.html

@@ -0,0 +1,108 @@
+{% extends "base.html" %}
+
+{% block title %}{% if lang == 'zh' %}评分指南{% else %}Scoring Guide{% endif %} — Video Rating System{% endblock %}
+
+{% block content %}
+<div class="container guide-container">
+  <div class="guide-topbar">
+    <form action="/tasks/start" method="post" style="display:inline;">
+      <button type="submit" class="btn btn-start btn-sm">{% if lang == 'zh' %}开始评分{% else %}Start Rating{% endif %}</button>
+    </form>
+    <span style="float:right"></span>
+  </div>
+
+  <h1 class="guide-title">{% if lang == 'zh' %}评分指南{% else %}Scoring Guide{% endif %}</h1>
+  <p class="guide-intro">
+    {% if lang == 'zh' %}
+    开始评分前请仔细阅读本指南。请完整观看视频后，对<strong>每个</strong>维度打分。
+    {% else %}
+    Please read this guide carefully before you start rating.
+    Watch the full video, then rate <strong>every</strong> dimension.
+    {% endif %}
+  </p>
+
+  <!-- ===== Scale ===== -->
+  <div class="guide-section">
+    <h2>{% if lang == 'zh' %}评分尺度{% else %}Rating Scale{% endif %}</h2>
+    <table class="guide-table">
+      <thead>
+        <tr><th>{% if lang == 'zh' %}分数{% else %}Score{% endif %}</th><th>{% if lang == 'zh' %}含义{% else %}Meaning{% endif %}</th></tr>
+      </thead>
+      <tbody>
+        {% if lang == 'zh' %}
+        <tr><td class="score-cell s5">5</td><td>完全合理</td></tr>
+        <tr><td class="score-cell s4">4</td><td>大部分合理</td></tr>
+        <tr><td class="score-cell s3">3</td><td>部分合理</td></tr>
+        <tr><td class="score-cell s2">2</td><td>大部分不合理</td></tr>
+        <tr><td class="score-cell s1">1</td><td>完全不合理</td></tr>
+        {% else %}
+        <tr><td class="score-cell s5">5</td><td>Fully plausible</td></tr>
+        <tr><td class="score-cell s4">4</td><td>Mostly plausible</td></tr>
+        <tr><td class="score-cell s3">3</td><td>Partially plausible</td></tr>
+        <tr><td class="score-cell s2">2</td><td>Largely implausible</td></tr>
+        <tr><td class="score-cell s1">1</td><td>Completely implausible</td></tr>
+        {% endif %}
+      </tbody>
+    </table>
+    <p class="guide-note">
+      {% if lang == 'zh' %}
+      所有维度统一使用 1–5 分制。
+      {% else %}
+      All dimensions (general and physical) use the 1–5 scale above.
+      {% endif %}
+    </p>
+  </div>
+
+  <!-- ===== General Dimensions ===== -->
+  <div class="guide-section">
+    <h2>{% if lang == 'zh' %}通用维度{% else %}General Dimensions{% endif %}</h2>
+    <div class="dim-cards">
+      {% for key, label, values, description, score_labels in general_dims_display %}
+      <div class="guide-card">
+        <div class="guide-card-header">
+          <span class="dim-key">{{ key }}</span>
+          <span class="guide-card-label">{{ label }}</span>
+          <span class="guide-card-scale">{% if values | length == 2 %}0/1{% else %}1–5{% endif %}</span>
+        </div>
+        <p class="guide-card-desc">{{ description }}</p>
+      </div>
+      {% endfor %}
+    </div>
+  </div>
+
+  <!-- ===== Physical Sub-questions (Rating Instrument) ===== -->
+  <div class="guide-section">
+    <h2>{% if lang == 'zh' %}物理子问题 (1–5){% else %}Physical Sub-questions (1–5){% endif %}</h2>
+    <p class="guide-note">
+      {% if lang == 'zh' %}
+      每个视频有 2–4 个需要评估的物理法则，只需对显示的法则打分。
+      {% else %}
+      Each video has 2–4 physical laws to evaluate. You only rate the laws shown for that video.
+      {% endif %}
+    </p>
+
+    <div class="dim-cards">
+      {% for c in human_criteria %}
+      <div class="guide-card guide-card-phys">
+        <div class="guide-card-header">
+          <span class="dim-key">{{ c.key | capitalize }}</span>
+          <span class="guide-card-scale">1–5</span>
+        </div>
+        <p class="guide-card-desc"><strong>Q:</strong> {{ c.question }}</p>
+        {% if c.note %}
+        <p class="guide-card-note"><strong>Note:</strong> {{ c.note }}</p>
+        {% endif %}
+      </div>
+      {% endfor %}
+    </div>
+  </div>
+
+
+
+  <div class="guide-footer">
+    <form action="/tasks/start" method="post">
+      <button type="submit" class="btn btn-start">{% if lang == 'zh' %}开始评分{% else %}Start Rating{% endif %}</button>
+    </form>
+  </div>
+</div>
+{% endblock %}

evals/human_eval/templates/login.html

@@ -0,0 +1,18 @@
+{% extends "base.html" %}
+
+{% block title %}Login — Video Rating System{% endblock %}
+
+{% block content %}
+<div class="login-container">
+  <h1>Video Rating System</h1>
+  {% if error %}
+  <div class="error-msg">{{ error }}</div>
+  {% endif %}
+  <form method="post" action="/login">
+    <input type="hidden" name="cohort" value="{{ cohort or 'others' }}">
+    <input type="text" name="username" placeholder="Enter your username" autocomplete="off" required>
+    <p class="login-hint">Your username will be saved. Please use the same username each time.</p>
+    <button type="submit" class="btn btn-primary">Enter</button>
+  </form>
+</div>
+{% endblock %}

evals/human_eval/templates/rate_compare.html

@@ -0,0 +1,154 @@
+{% extends "base.html" %}
+
+{% block title %}Compare — {{ video_entries | length }} Models{% endblock %}
+
+{% block content %}
+<div class="topbar">
+  <span class="annotator-name">{{ annotator_name }}</span>
+<a href="/demo" target="_blank" class="btn btn-guide">Demo</a>
+  <span class="progress-label">Progress: {{ user_completed_groups }} / {{ user_quota }}</span>
+</div>
+
+{% set progress_compact = true %}
+{% include "_progress_bar.html" %}
+
+<div class="container compare-container">
+  <div class="instruction-banner">
+    <strong>Instructions:</strong> Watch all three videos below. Rate <em>each</em> video independently.
+    Your rating should range from 1-5, with 1 meaning completely implausible and 5 meaning fully plausible.
+    Judge only physical plausibility — do not let brightness, colour saturation, or visual appeal influence your ratings.
+    <div class="scoring-guide-inline">
+      <span>Scoring:</span>
+      <span style="color:#ef4444">1 = Completely implausible</span>
+      <span style="color:#f97316">2 = Largely implausible</span>
+      <span style="color:#eab308">3 = Partially plausible</span>
+      <span style="color:#16a34a">4 = Mostly plausible</span>
+      <span style="color:#15803d">5 = Fully plausible</span>
+    </div>
+  </div>
+
+  <!-- Shared prompt -->
+  <div class="prompt-box compare-prompt">
+    <span class="prompt-label">Generation Prompt (shared by all videos)</span>
+    <p class="prompt-text">{{ prompt }}</p>
+  </div>
+
+  <!-- Video grid — single form wrapping all cards -->
+  <form id="submit-all-form" method="POST" action="/rate_group/{{ group_id }}">
+  <div class="compare-grid compare-grid-{{ video_entries | length }}">
+    {% for label, assignment in video_entries %}
+    {% set vid_status = status_map.get(assignment.id, STATUS_ASSIGNED) %}
+    {% set is_done = vid_status in (STATUS_COMPLETED, STATUS_SKIPPED) %}
+    <div class="compare-card{% if vid_status == STATUS_COMPLETED %} card-completed{% elif vid_status == STATUS_SKIPPED %} card-skipped{% endif %}" data-vid="{{ assignment.id }}">
+      <div class="compare-card-header">
+        <span class="compare-label">Video {{ label }}</span>
+        {% if vid_status == STATUS_COMPLETED %}
+        <span class="status-badge completed">Submitted</span>
+        {% elif vid_status == STATUS_SKIPPED %}
+        <span class="status-badge skipped">Skipped</span>
+        {% endif %}
+      </div>
+
+      <div class="compare-video-wrap">
+        <video class="video-player compare-video" muted>
+          <source src="/video/{{ assignment.dataset }}/{{ assignment.filename }}" type="video/mp4">
+        </video>
+        <div class="video-controls">
+          <button type="button" class="vc-btn vc-play" onclick="togglePlay(this)">&#9654;</button>
+          <div class="vc-bar" onclick="seekVideo(event, this)">
+            <div class="vc-progress"></div>
+          </div>
+          <button type="button" class="vc-btn vc-mute" onclick="toggleMute(this)">&#128263;</button>
+        </div>
+      </div>
+
+      <div class="card-form" data-vid="{{ assignment.id }}">
+        <!-- General dimensions -->
+        <div class="score-section">
+          <h3 class="section-title">General Dimensions</h3>
+          {% set es = existing_scores_map.get(assignment.id) %}
+          {% for key, dim_label, values, description, score_labels in general_dims %}
+          <div class="dim-row">
+            <div class="dim-info">
+              <span class="dim-label">{{ description }}</span>
+            </div>
+            <div class="score-btns">
+              {% for v in values %}
+              <button type="button"
+                class="score-btn{% if es and es.get('general', {}).get(key) == v %} selected{% endif %}"
+                data-value="{{ v }}"
+                title="{{ score_labels[v] }}"
+                onclick="selectScore(this)"
+                {% if is_done %}disabled{% endif %}>{{ v }}</button>
+              {% endfor %}
+              <input type="hidden" class="score-input" name="v{{ assignment.id }}_{{ key }}"
+                value="{{ es.get('general', {}).get(key, '') if es else '' }}">
+            </div>
+          </div>
+          {% endfor %}
+        </div>
+
+        <!-- Physical sub-questions (grouped by domain) -->
+        {% if physical_dims %}
+        <div class="score-section">
+          <h3 class="section-title">Physical Sub-questions</h3>
+          {% for key, desc in physical_dims %}
+          {% set hc = human_criteria_by_key.get(key) %}
+          <div class="dim-row physical-dim-row" data-law="{{ key }}">
+            <div class="dim-info">
+              {% if hc %}
+              <span class="dim-label"><span class="law-tag">{{ key | capitalize }}</span> {{ hc.question }}</span>
+              {% if hc.note %}<span class="dim-note">{{ hc.note }}</span>{% endif %}
+              {% else %}
+              <span class="dim-label"><span class="law-tag">{{ key | capitalize }}</span> {{ desc }}</span>
+              {% endif %}
+            </div>
+            <div class="score-btns">
+              {% for v in [1, 2, 3, 4, 5] %}
+              <button type="button"
+                class="score-btn{% if es and es.get('physical', {}).get(key) == v %} selected{% endif %}"
+                data-value="{{ v }}"
+                onclick="selectScore(this)"
+                {% if is_done %}disabled{% endif %}>{{ v }}</button>
+              {% endfor %}
+              <input type="hidden" class="score-input" name="v{{ assignment.id }}_{{ key }}"
+                value="{{ es.get('physical', {}).get(key, '') if es else '' }}">
+            </div>
+          </div>
+          {% endfor %}
+        </div>
+        {% endif %}
+
+        <div class="note-section">
+          <textarea name="v{{ assignment.id }}_note" class="note-input" placeholder="Notes (optional) — If a physical law is completely irrelevant to this prompt (e.g. buoyancy when there is no water), note it here."
+            {% if is_done %}disabled{% endif %}>{{ es.get('note', '') if es else '' }}</textarea>
+        </div>
+
+        <input type="hidden" name="v{{ assignment.id }}_play_count" class="play-count-input" value="0">
+        <input type="hidden" name="v{{ assignment.id }}_stay_seconds" class="stay-seconds-input" value="0">
+      </div>
+
+    </div>
+    {% endfor %}
+  </div>
+
+  {% set has_pending = namespace(val=false) %}
+  {% for label, assignment in video_entries %}
+    {% if status_map.get(assignment.id, STATUS_ASSIGNED) not in (STATUS_COMPLETED, STATUS_SKIPPED) %}
+      {% set has_pending.val = true %}
+    {% endif %}
+  {% endfor %}
+  {% if has_pending.val %}
+  <div class="submit-all-section" style="text-align:center; margin: 1.5rem 0; display:flex; justify-content:center; gap:1rem;">
+    <button type="button" class="btn btn-primary btn-lg" id="submit-all-btn" onclick="doSave()">Save</button>
+    <button type="button" class="btn btn-primary btn-lg" id="submit-next-btn" onclick="doNext()">Next</button>
+  </div>
+  {% endif %}
+  </form>
+
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script src="/static/rate.js"></script>
+{% endblock %}

evals/human_eval/templates/task_list.html

@@ -0,0 +1,102 @@
+{% extends "base.html" %}
+
+{% block title %}Task List — Video Rating System{% endblock %}
+
+{% block content %}
+<div class="topbar">
+  <span class="annotator-name">{{ annotator_name }}</span>
+  <a href="/demo" class="btn btn-guide" target="_blank">Demo</a>
+  <span class="progress-label">Progress: {{ user_completed_groups }} / {{ user_quota }}</span>
+</div>
+
+{% include "_progress_bar.html" %}
+
+<div class="container">
+  {% if needs_demographics %}
+  <div class="demographics-box">
+    <h2>Evaluating the Realism of Short Videos</h2>
+    <p>Welcome, and thank you for participating!</p>
+    <p>Your task is simple: you will watch a series of short videos and rate how realistic certain physical behaviours look to you.</p>
+    <p>Please read the following information before proceeding.</p>
+    <ul style="text-align:left; margin:0.8em 0;">
+      <li><strong>Voluntary participation.</strong> Your participation is voluntary. You may stop at any time, with no penalty.</li>
+      <li><strong>Duration.</strong> This takes about 15 minutes.</li>
+      <li><strong>Anonymity.</strong> All your responses are anonymous. We do not collect your name, email address, or any information that could identify you personally.</li>
+      <li><strong>Use of data.</strong> Your responses will be kept confidential and used internally only.</li>
+    </ul>
+    <hr style="margin:1.2em 0; border:none; border-top:1px solid #ccc;">
+    <h3>Basic Information</h3>
+    <p>We collect the following background information for internal use only.</p>
+    <form action="/demographics" method="POST" class="demographics-form">
+      <div class="demo-field">
+        <label class="demo-label">Gender <span class="required">*</span></label>
+        <div class="demo-options">
+          <label><input type="radio" name="gender" value="male" required> Male</label>
+          <label><input type="radio" name="gender" value="female"> Female</label>
+          <label><input type="radio" name="gender" value="other"> Other</label>
+          <label><input type="radio" name="gender" value="prefer_not_to_say"> Prefer not to say</label>
+        </div>
+      </div>
+      <div class="demo-field">
+        <label class="demo-label">Age <span class="required">*</span></label>
+        <select name="age" class="demo-input" style="width:240px" required>
+          <option value="" disabled selected>Select</option>
+          <option value="under18">Under 18</option>
+          <option value="18-22">18–22</option>
+          <option value="22-25">22–25</option>
+          <option value="26-30">26–30</option>
+          <option value="31-40">31–40</option>
+          <option value="41+">41+</option>
+        </select>
+      </div>
+      <div class="demo-field">
+        <label class="demo-label">Major <span class="required">*</span></label>
+        <div class="demo-options">
+          <label><input type="radio" name="major" value="CS" required> Computer Science</label>
+          <label><input type="radio" name="major" value="EE"> Electrical Engineering</label>
+          <label><input type="radio" name="major" value="Business"> Business</label>
+          <label><input type="radio" name="major" value="other"> Other:</label>
+          <input type="text" name="major_other" class="demo-input demo-input-inline" placeholder="Please specify" disabled>
+        </div>
+      </div>
+      <div class="demo-field">
+        <label class="demo-label">Highest education (including pursuing) <span class="required">*</span></label>
+        <select name="education" class="demo-input" style="width:240px" required>
+          <option value="" disabled selected>Select</option>
+          <option value="bachelor">Bachelor</option>
+          <option value="master">Master</option>
+          <option value="phd">PhD</option>
+        </select>
+      </div>
+      <script>
+        document.querySelectorAll('input[name="major"]').forEach(function(r) {
+          r.addEventListener('change', function() {
+            var otherInput = document.querySelector('input[name="major_other"]');
+            otherInput.disabled = this.value !== 'other';
+            if (this.value === 'other') otherInput.focus();
+            else otherInput.value = '';
+          });
+        });
+      </script>
+      <button type="submit" class="btn btn-primary btn-start">Continue</button>
+    </form>
+  </div>
+  {% else %}
+  <div class="instructions-box">
+    <h2>Instructions</h2>
+    <p>Welcome! You will be shown pairs of AI-generated videos along with their text prompts and reference images. Your task is to compare the videos and rate which one better follows the prompt and obeys real-world physical laws.</p>
+    <p>You can stop at any time and close the browser — your progress is saved automatically. Come back and resume whenever you like.</p>
+    <p>Please provide thoughtful and consistent ratings. Your evaluations are very important to us.</p>
+    <p>Check the <a href="/demo" target="_blank"><strong>Demo</strong></a> (top-right corner) to see how we score videos before you begin.</p>
+  </div>
+
+  {% include "_scale_table.html" %}
+
+  <div class="start-section">
+    <form action="/tasks/start" method="post" onsubmit="this.querySelector('button').disabled=true">
+      <button type="submit" class="btn btn-start">I understand the scale — Continue</button>
+    </form>
+  </div>
+  {% endif %}
+</div>
+{% endblock %}

evals/human_eval/templates/thanks.html

@@ -0,0 +1,44 @@
+{% extends "base.html" %}
+{% block title %}Thank You{% endblock %}
+{% block content %}
+<div style="max-width:600px; margin:80px auto; text-align:center; font-family:system-ui,sans-serif;">
+  <h1 style="font-size:2rem; margin-bottom:1rem;">Thank you for your participation!</h1>
+  <p style="font-size:1.1rem; color:#555; margin-bottom:2rem;">
+    Your annotations have been saved successfully.
+  </p>
+  <div style="background:#f0f7ff; border:2px solid #3b82f6; border-radius:12px; padding:2rem; margin-bottom:2rem;">
+    <p style="font-size:1rem; color:#333; margin-bottom:0.5rem;">Your completion code:</p>
+    <p id="code" style="font-size:2.5rem; font-weight:bold; letter-spacing:0.3em; color:#1d4ed8; margin:0.5rem 0;">{{ code }}</p>
+    <button id="copyBtn"
+            style="margin-top:1rem; padding:0.5rem 1.5rem; font-size:1rem; background:#3b82f6; color:#fff; border:none; border-radius:6px; cursor:pointer;">
+      Copy Code
+    </button>
+    <script>
+      document.getElementById('copyBtn').addEventListener('click', function() {
+        var text = '{{ code }}';
+        var btn = this;
+        if (navigator.clipboard && window.isSecureContext) {
+          navigator.clipboard.writeText(text).then(function() {
+            btn.textContent = 'Copied!';
+            setTimeout(function(){ btn.textContent = 'Copy Code'; }, 1500);
+          });
+        } else {
+          var ta = document.createElement('textarea');
+          ta.value = text;
+          ta.style.position = 'fixed';
+          ta.style.opacity = '0';
+          document.body.appendChild(ta);
+          ta.select();
+          document.execCommand('copy');
+          document.body.removeChild(ta);
+          btn.textContent = 'Copied!';
+          setTimeout(function(){ btn.textContent = 'Copy Code'; }, 1500);
+        }
+      });
+    </script>
+  </div>
+  <p style="font-size:1.05rem; color:#333;">
+    Please copy this code and paste it into the survey.
+  </p>
+</div>
+{% endblock %}

evals/human_eval/tests/conftest.py

@@ -0,0 +1,43 @@
+import sqlite3
+import pytest
+import sys
+from pathlib import Path
+
+EVAL_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(EVAL_ROOT) not in sys.path:
+    sys.path.append(str(EVAL_ROOT))
+
+
+@pytest.fixture
+def db():
+    from human_eval.db import init_db
+    conn = sqlite3.connect(":memory:")
+    conn.row_factory = sqlite3.Row
+    init_db(conn)
+    yield conn
+    conn.close()
+
+
+@pytest.fixture
+def app(tmp_path):
+    pytest.importorskip("flask")
+    from human_eval.app import create_app
+    test_app = create_app(
+        db_path=":memory:",
+        video_data_dir=tmp_path,
+        skip_import=True,
+    )
+    test_app.config["TESTING"] = True
+    yield test_app
+
+
+@pytest.fixture
+def client(app):
+    return app.test_client()
+
+
+@pytest.fixture
+def app_db(app):
+    from human_eval.app import get_app_db
+    with app.app_context():
+        yield get_app_db()

evals/human_eval/tests/test_assign.py

@@ -0,0 +1,246 @@
+import sqlite3
+import pytest
+
+
+def _insert_annotator(db, name):
+    db.execute("INSERT INTO annotators (name) VALUES (?)", (name,))
+    db.commit()
+    return db.execute("SELECT id FROM annotators WHERE name=?", (name,)).fetchone()["id"]
+
+
+def _insert_video(db, filename, dataset="ds", prompt="p", physical_laws='["fluid"]', difficulty=None):
+    db.execute(
+        "INSERT INTO videos (filename, dataset, prompt, physical_laws, difficulty_score, import_hash) "
+        "VALUES (?, ?, ?, ?, ?, 'hash')",
+        (filename, dataset, prompt, physical_laws, difficulty),
+    )
+    db.commit()
+    return db.execute(
+        "SELECT id FROM videos WHERE filename=?", (filename,)
+    ).fetchone()["id"]
+
+
+def _insert_assignment(db, video_id, annotator_id, status="assigned", hours_offset=1):
+    db.execute(
+        "INSERT INTO assignments (video_id, annotator_id, status, expires_at) "
+        "VALUES (?, ?, ?, datetime('now', ? || ' hours'))",
+        (video_id, annotator_id, status, f"+{hours_offset}" if hours_offset >= 0 else str(hours_offset)),
+    )
+    db.commit()
+
+
+def _insert_comparison_prompt(
+    db,
+    prompt,
+    models=("model-a", "model-b"),
+    physical_laws='["fluid"]',
+):
+    video_ids = []
+    for model in models:
+        video_ids.append(
+            _insert_video(
+                db,
+                f"{prompt}-{model}.mp4",
+                dataset=f"{model}-wmb",
+                prompt=prompt,
+                physical_laws=physical_laws,
+            )
+        )
+    return video_ids
+
+
+def _insert_comparison_group(db, group_id, prompt, physical_laws, video_ids, annotator_id, hours_offset=24):
+    db.execute(
+        "INSERT INTO comparison_groups (id, prompt, physical_laws) VALUES (?, ?, ?)",
+        (group_id, prompt, physical_laws),
+    )
+    for video_id in video_ids:
+        db.execute(
+            "INSERT INTO assignments (video_id, annotator_id, status, expires_at, group_id) "
+            "VALUES (?, ?, 'assigned', datetime('now', ? || ' hours'), ?)",
+            (video_id, annotator_id, f"+{hours_offset}" if hours_offset >= 0 else str(hours_offset), group_id),
+        )
+    db.commit()
+
+
+
+class TestAssignComparisonBatch:
+    def test_expired_group_cleanup_deletes_saved_drafts_before_reassignment(self, db):
+        from human_eval.assign import assign_comparison_batch
+
+        uid = _insert_annotator(db, "alice")
+        video_ids = _insert_comparison_prompt(db, "prompt-1")
+
+        _insert_comparison_group(
+            db,
+            "expired-group",
+            "prompt-1",
+            '["fluid"]',
+            video_ids,
+            uid,
+            hours_offset=-1,
+        )
+
+        expired_aid = db.execute(
+            "SELECT id FROM assignments WHERE group_id = 'expired-group' ORDER BY id LIMIT 1"
+        ).fetchone()["id"]
+        db.execute(
+            "INSERT INTO annotations (assignment_id, scores_json) VALUES (?, '{}')",
+            (expired_aid,),
+        )
+        annotation_id = db.execute(
+            "SELECT id FROM annotations WHERE assignment_id = ?",
+            (expired_aid,),
+        ).fetchone()["id"]
+        db.execute(
+            "INSERT INTO annotation_items (annotation_id, dimension, law, score) VALUES (?, ?, ?, ?)",
+            (annotation_id, "SA", None, 4),
+        )
+        db.commit()
+
+        new_groups = assign_comparison_batch(
+            db,
+            uid,
+            n_annotators=3,
+            batch_size=1,
+            ttl_hours=24,
+            models=["model-a", "model-b"],
+            models_per_group=2,
+        )
+
+        assert len(new_groups) == 1
+        assert db.execute(
+            "SELECT 1 FROM comparison_groups WHERE id = 'expired-group'",
+        ).fetchone() is None
+        assert db.execute(
+            "SELECT COUNT(*) AS c FROM annotations WHERE assignment_id = ?",
+            (expired_aid,),
+        ).fetchone()["c"] == 0
+        assert db.execute(
+            "SELECT COUNT(*) AS c FROM annotation_items WHERE annotation_id = ?",
+            (annotation_id,),
+        ).fetchone()["c"] == 0
+
+    def test_prompt_stays_assignable_until_each_model_reaches_target_coverage(self, db):
+        from human_eval.assign import assign_comparison_batch
+
+        uid_a = _insert_annotator(db, "alice")
+        uid_b = _insert_annotator(db, "bob")
+        uid_c = _insert_annotator(db, "carol")
+        uid_d = _insert_annotator(db, "dave")
+
+        video_ids = _insert_comparison_prompt(
+            db,
+            "prompt-1",
+            models=("model-a", "model-b", "model-c", "model-d"),
+        )
+        covered_video_ids = video_ids[:3]
+
+        for idx, uid in enumerate((uid_a, uid_b, uid_c), start=1):
+            group_id = f"completed-{idx}"
+            _insert_comparison_group(
+                db,
+                group_id,
+                "prompt-1",
+                '["fluid"]',
+                covered_video_ids,
+                uid,
+            )
+            db.execute(
+                "UPDATE assignments SET status = 'completed' WHERE group_id = ?",
+                (group_id,),
+            )
+        db.commit()
+
+        new_groups = assign_comparison_batch(
+            db,
+            uid_d,
+            n_annotators=3,
+            batch_size=1,
+            ttl_hours=24,
+            models=["model-a", "model-b", "model-c", "model-d"],
+            models_per_group=3,
+        )
+
+        assert len(new_groups) == 1
+        datasets = {
+            row["dataset"]
+            for row in db.execute(
+                "SELECT v.dataset FROM assignments a "
+                "JOIN videos v ON a.video_id = v.id "
+                "WHERE a.group_id = ?",
+                (new_groups[0],),
+            ).fetchall()
+        }
+        assert "model-d-wmb" in datasets
+
+    def test_repeated_call_keeps_pending_group_when_no_new_candidates(self, db):
+        from human_eval.assign import assign_comparison_batch
+
+        uid = _insert_annotator(db, "alice")
+        video_ids = _insert_comparison_prompt(db, "prompt-1")
+
+        first_groups = assign_comparison_batch(
+            db,
+            uid,
+            n_annotators=3,
+            batch_size=1,
+            ttl_hours=24,
+            models=["model-a", "model-b"],
+            models_per_group=2,
+        )
+
+        assert len(first_groups) == 1
+        group_id = first_groups[0]
+
+        second_groups = assign_comparison_batch(
+            db,
+            uid,
+            n_annotators=3,
+            batch_size=1,
+            ttl_hours=24,
+            models=["model-a", "model-b"],
+            models_per_group=2,
+        )
+
+        assert second_groups == []
+        assert db.execute(
+            "SELECT COUNT(*) AS c FROM assignments WHERE group_id = ?",
+            (group_id,),
+        ).fetchone()["c"] == len(video_ids)
+        assert db.execute(
+            "SELECT 1 FROM comparison_groups WHERE id = ?",
+            (group_id,),
+        ).fetchone() is not None
+
+    def test_new_group_assignment_does_not_delete_existing_pending_group(self, db):
+        from human_eval.assign import assign_comparison_batch
+
+        uid = _insert_annotator(db, "alice")
+        prompt_one_videos = _insert_comparison_prompt(db, "prompt-1")
+        _insert_comparison_prompt(db, "prompt-2")
+
+        _insert_comparison_group(
+            db,
+            "existing-group",
+            "prompt-1",
+            '["fluid"]',
+            prompt_one_videos,
+            uid,
+        )
+
+        new_groups = assign_comparison_batch(
+            db,
+            uid,
+            n_annotators=3,
+            batch_size=1,
+            ttl_hours=24,
+            models=["model-a", "model-b"],
+            models_per_group=2,
+        )
+
+        assert len(new_groups) == 1
+        assert new_groups[0] != "existing-group"
+        assert db.execute(
+            "SELECT COUNT(*) AS c FROM assignments WHERE group_id = 'existing-group'",
+        ).fetchone()["c"] == len(prompt_one_videos)

evals/human_eval/tests/test_db.py

@@ -0,0 +1,63 @@
+import sqlite3
+import pytest
+
+
+def test_tables_exist(db):
+    cursor = db.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+    tables = [row[0] for row in cursor.fetchall()]
+    assert "annotators" in tables
+    assert "videos" in tables
+    assert "assignments" in tables
+    assert "annotations" in tables
+    assert "annotation_items" in tables
+
+
+def test_annotator_unique_name(db):
+    db.execute("INSERT INTO annotators (name) VALUES ('alice')")
+    db.commit()
+    with pytest.raises(sqlite3.IntegrityError):
+        db.execute("INSERT INTO annotators (name) VALUES ('alice')")
+        db.commit()
+
+
+def test_assignment_unique_video_annotator(db):
+    db.execute("INSERT INTO annotators (name) VALUES ('alice')")
+    db.execute(
+        "INSERT INTO videos (filename, dataset, prompt, physical_laws, import_hash) "
+        "VALUES ('v.mp4', 'ds', 'prompt', '[\"fluid\"]', 'abc')"
+    )
+    db.commit()
+    db.execute(
+        "INSERT INTO assignments (video_id, annotator_id, status, expires_at) "
+        "VALUES (1, 1, 'assigned', datetime('now', '+1 hour'))"
+    )
+    db.commit()
+    with pytest.raises(sqlite3.IntegrityError):
+        db.execute(
+            "INSERT INTO assignments (video_id, annotator_id, status, expires_at) "
+            "VALUES (1, 1, 'assigned', datetime('now', '+1 hour'))"
+        )
+        db.commit()
+
+
+def test_annotation_unique_assignment(db):
+    db.execute("INSERT INTO annotators (name) VALUES ('alice')")
+    db.execute(
+        "INSERT INTO videos (filename, dataset, prompt, physical_laws, import_hash) "
+        "VALUES ('v.mp4', 'ds', 'prompt', '[\"fluid\"]', 'abc')"
+    )
+    db.execute(
+        "INSERT INTO assignments (video_id, annotator_id, status, expires_at) "
+        "VALUES (1, 1, 'assigned', datetime('now', '+1 hour'))"
+    )
+    db.execute(
+        "INSERT INTO annotations (assignment_id, scores_json) VALUES (1, '{}')"
+    )
+    db.commit()
+    with pytest.raises(sqlite3.IntegrityError):
+        db.execute(
+            "INSERT INTO annotations (assignment_id, scores_json) VALUES (1, '{}')"
+        )
+        db.commit()
+
+

evals/human_eval/tests/test_import.py

@@ -0,0 +1,56 @@
+import pytest
+
+
+def _make_eval_json(results, judge="gemini"):
+    return {
+        "schema_version": "v2.0",
+        "judge": judge,
+        "results": results,
+    }
+
+
+def _make_result(video, domain, prompt, scores=None):
+    base = {"video": video, "domain": domain, "prompt": prompt}
+    if scores:
+        base.update(scores)
+    return base
+
+
+class TestImportHash:
+    def test_deterministic(self, tmp_path):
+        from human_eval.import_videos import compute_import_hash
+        (tmp_path / "ds1").mkdir()
+        (tmp_path / "ds1" / "a.mp4").touch()
+        (tmp_path / "ds1" / "b.mp4").touch()
+        h1 = compute_import_hash(tmp_path)
+        h2 = compute_import_hash(tmp_path)
+        assert h1 == h2
+
+    def test_changes_with_files(self, tmp_path):
+        from human_eval.import_videos import compute_import_hash
+        (tmp_path / "ds1").mkdir()
+        (tmp_path / "ds1" / "a.mp4").touch()
+        h1 = compute_import_hash(tmp_path)
+        (tmp_path / "ds1" / "b.mp4").touch()
+        h2 = compute_import_hash(tmp_path)
+        assert h1 != h2
+
+
+class TestDifficultyScore:
+    def test_computes_mean_abs_diff(self):
+        from human_eval.import_videos import compute_difficulty_score
+        gemini = {"SA": 4, "PTV": 3, "persistence": 4}
+        qwen = {"SA": 2, "PTV": 1, "persistence": 2}
+        score = compute_difficulty_score(gemini, qwen)
+        assert abs(score - 6 / 3) < 1e-6
+
+    def test_returns_none_when_missing_keys(self):
+        from human_eval.import_videos import compute_difficulty_score
+        assert compute_difficulty_score({"SA": 1}, {}) is None
+
+
+class TestImportVideos:
+    def test_importer_disabled_without_prompt_selection_json(self, db, tmp_path):
+        from human_eval.import_videos import import_videos
+        with pytest.raises(RuntimeError, match="prompt-selection JSON"):
+            import_videos(db, tmp_path / "videos")

evals/human_eval/tests/test_routes.py

@@ -0,0 +1,149 @@
+import json
+import pytest
+
+from human_eval.config import STATUS_COMPLETED
+
+
+def _setup_user_and_video(app_db):
+    app_db.execute("INSERT INTO annotators (name) VALUES ('alice')")
+    app_db.execute(
+        "INSERT INTO videos (filename, dataset, prompt, physical_laws, import_hash) "
+        """VALUES ('v.mp4', 'ds', 'test prompt', '["flow_dynamics", "boundary_interaction", "fluid_continuity"]', 'hash')"""
+    )
+    app_db.commit()
+    return 1, 1
+
+
+
+class TestLogin:
+    def test_get_login_page(self, client):
+        resp = client.get("/")
+        assert resp.status_code == 200
+
+    def test_login_creates_annotator(self, client, app_db):
+        resp = client.post("/login", data={"username": "alice"}, follow_redirects=False)
+        assert resp.status_code == 302
+        row = app_db.execute("SELECT * FROM annotators WHERE name='alice'").fetchone()
+        assert row is not None
+
+    def test_login_empty_name_rejected(self, client):
+        resp = client.post("/login", data={"username": ""}, follow_redirects=True)
+        assert resp.status_code == 200
+
+
+def _setup_comparison_group(app_db, video_id, annotator_id, group_id="test-group"):
+    """Create a comparison group and a grouped assignment."""
+    app_db.execute(
+        "INSERT OR IGNORE INTO comparison_groups (id, prompt, physical_laws) "
+        """VALUES (?, 'test prompt', '["flow_dynamics"]')""",
+        (group_id,),
+    )
+    app_db.execute(
+        "INSERT INTO assignments (video_id, annotator_id, status, expires_at, group_id) "
+        "VALUES (?, ?, 'assigned', datetime('now', '+24 hours'), ?)",
+        (video_id, annotator_id, group_id),
+    )
+    app_db.commit()
+
+
+class TestTaskList:
+    def test_requires_login(self, client):
+        resp = client.get("/tasks")
+        assert resp.status_code == 302
+
+    def test_shows_assignments(self, client, app_db):
+        _setup_user_and_video(app_db)
+        with client.session_transaction() as sess:
+            sess["annotator_id"] = 1
+            sess["annotator_name"] = "alice"
+        _setup_comparison_group(app_db, 1, 1)
+        resp = client.get("/tasks", follow_redirects=True)
+        assert resp.status_code == 200
+
+
+class TestStats:
+    def test_stats_returns_json(self, client, app_db):
+        with client.session_transaction() as sess:
+            sess["annotator_id"] = 1
+            sess["annotator_name"] = "alice"
+        resp = client.get("/api/stats")
+        assert resp.status_code == 200
+        data = resp.get_json()
+        assert "total_videos" in data
+        assert "coverage" in data
+        assert "per_annotator" in data
+
+
+class TestEndToEnd:
+    def test_full_flow_comparison(self, client, app_db):
+        """Login → create comparison group → rate group → verify annotations."""
+        # Insert two test videos (same prompt, different models)
+        app_db.execute(
+            "INSERT INTO videos (filename, dataset, prompt, physical_laws, import_hash) "
+            """VALUES ('v1.mp4', 'model-a-wmb', 'water flows', '["flow_dynamics", "fluid_continuity"]', 'hash')"""
+        )
+        app_db.execute(
+            "INSERT INTO videos (filename, dataset, prompt, physical_laws, import_hash) "
+            """VALUES ('v1.mp4', 'model-b-wmb', 'water flows', '["flow_dynamics", "fluid_continuity"]', 'hash')"""
+        )
+        app_db.commit()
+
+        # Login
+        resp = client.post("/login", data={"username": "tester"}, follow_redirects=True)
+        assert resp.status_code == 200
+
+        # Manually create a comparison group (auto-assign won't match test models)
+        group_id = "test-e2e-group"
+        app_db.execute(
+            "INSERT INTO comparison_groups (id, prompt, physical_laws) VALUES (?, ?, ?)",
+            (group_id, "water flows", '["flow_dynamics", "fluid_continuity"]'),
+        )
+        annotator_id = app_db.execute("SELECT id FROM annotators WHERE name='tester'").fetchone()["id"]
+        for vid in [1, 2]:
+            app_db.execute(
+                "INSERT INTO assignments (video_id, annotator_id, status, expires_at, group_id) "
+                "VALUES (?, ?, 'assigned', datetime('now', '+24 hours'), ?)",
+                (vid, annotator_id, group_id),
+            )
+        app_db.commit()
+
+        # Get rate group page
+        resp = client.get(f"/rate_group/{group_id}")
+        assert resp.status_code == 200
+
+        # Submit scores for both videos
+        assignments = app_db.execute(
+            "SELECT id FROM assignments WHERE group_id=? ORDER BY id",
+            (group_id,),
+        ).fetchall()
+
+        scores = {}
+        for a in assignments:
+            aid = a["id"]
+            scores[f"v{aid}_SA"] = "4"
+            scores[f"v{aid}_PTV"] = "4"
+            scores[f"v{aid}_persistence"] = "3"
+            scores[f"v{aid}_flow_dynamics"] = "4"
+            scores[f"v{aid}_fluid_continuity"] = "2"
+
+        scores["action"] = "next"
+        resp = client.post(f"/rate_group/{group_id}", data=scores, follow_redirects=False)
+        assert resp.status_code == 200
+        resp_data = resp.get_json()
+        assert resp_data["ok"] is True
+
+        # Verify annotations created for both
+        for a in assignments:
+            ann = app_db.execute(
+                "SELECT * FROM annotations WHERE assignment_id=?", (a["id"],)
+            ).fetchone()
+            assert ann is not None
+            parsed = json.loads(ann["scores_json"])
+            assert parsed["general"]["SA"] == 4
+            assert parsed["physical"]["flow_dynamics"] == 4
+
+        # Verify all assignments marked completed
+        statuses = app_db.execute(
+            "SELECT status FROM assignments WHERE group_id=?", (group_id,)
+        ).fetchall()
+        assert all(r["status"] == STATUS_COMPLETED for r in statuses)

evals/physics_criteria.py

@@ -0,0 +1,240 @@
+"""Shared physical-law criteria definitions — single source of truth.
+
+Every module that needs law names, descriptions, or domain groupings should
+import from here instead of defining its own copy.
+"""
+
+from __future__ import annotations
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Full bilingual criteria (Chinese + English) — used by VLM evaluation prompts
+# ──────────────────────────────────────────────────────────────────────────────
+
+CRITERIA_EN: dict[str, str] = {
+    "gravity": "Do unsupported objects fall downward? Do thrown objects follow a curved trajectory? Does poured liquid fall with gravity?",
+    "inertia": "Do stationary objects remain still unless acted upon? Do moving objects maintain their motion unless stopped by friction, collision, or an obstacle?",
+    "momentum": "After collision, push, or pull, is the direction of motion reasonable? Ignore speed magnitude.",
+    "impenetrability": "Do objects maintain impenetrability — no passing through each other?",
+    "collision": "After impact, is there reasonable bounce/shatter/deformation? Does response match impact force?",
+    "material": "Does each material respond according to its properties? (glass shatters, rubber bounces, metal is rigid, cloth deforms softly, etc.)",
+    "buoyancy": "Do dense objects sink? Do wood/plastic float?",
+    "displacement": "When you add more liquid or put an object into it, does the liquid level rise in a realistic way? Does it overflow when full?",
+    "flow_dynamics": "Does the liquid's overall motion behave realistically over time — flowing along surfaces, spreading, draining naturally?",
+    "boundary_interaction": "When the liquid hits a boundary such as a rock face, container wall, or floor, does it respond realistically? Do local splash, rebound, or split patterns on impact look physically plausible?",
+    "fluid_continuity": "Does the liquid avoid disappearing or appearing out of nowhere? Small splashes that briefly break apart are okay.",
+    "reflection": "Does the reflection roughly match objects and colors in the scene, and avoid completely unrelated content?",
+    "shadow": "Are shadow directions consistent with light source? Do shadows move with objects?",
+}
+
+CRITERIA_ZH: dict[str, str] = {
+    "gravity": "无支撑的物体（固体或液体）是否向下掉落？抛出的物体轨迹是否呈弧线下落？倾倒的液体是否沿重力方向落下？",
+    "inertia": "静止物体是否保持静止？运动物体是否在没有摩擦、碰撞或障碍的情况下保持运动？",
+    "momentum": "碰撞、推或拉后，物体运动方向是否合理？忽略速度大小",
+    "impenetrability": "物体之间是否保持不可穿透，没有穿模？",
+    "collision": "物体撞击后是否有合理的反弹/碎裂/变形？撞击力度与响应程度是否匹配？",
+    "material": "每种材料的响应是否符合其属性？玻璃碎裂、橡胶弹回、金属坚硬、布料柔软变形。",
+    "buoyancy": "密度大于水的物体是否下沉？木头/塑料等是否浮于水面？",
+    "displacement": "当添加液体或物体浸入时，液面是否合理地上升？容器满后是否溢出？",
+    "flow_dynamics": "液体整体流动是否符合物理——沿表面流动、铺展、排出是否自然？",
+    "boundary_interaction": "液体撞击边界（如岩壁、杯壁、地面）时，局部交互是否合理？撞击后的飞溅、反弹或分流形态是否物理上可信？",
+    "fluid_continuity": "液体是否保持物理连续性与质量守恒——无不合理的断裂、消失或凭空生成？短暂飞溅分离可接受。",
+    "reflection": "镜子/光滑表面中的反射内容是否大致匹配场景中的物体和颜色，没有完全不相关的内容。",
+    "shadow": "阴影方向是否与光源位置一致？物体移动时阴影是否同步移动？",
+}
+
+# Backward-compatible alias — defaults to English
+CRITERIA = CRITERIA_EN
+
+# Re-export sub-question definitions (defined in evals/sub_questions.py)
+from evals.sub_questions import SUB_QUESTIONS, SubQuestion  # noqa: F401
+
+from dataclasses import dataclass, field
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Human-eval Rating Instrument — structured criteria for human annotators
+# ───────────────────────────────────────────────────────────────────────────���──
+
+
+@dataclass
+class HumanCriterion:
+    """A single criterion in the human-eval rating instrument."""
+    key: str                    # e.g. "gravity"
+    code: str                   # e.g. "A1"
+    domain: str                 # e.g. "Solid-Body Mechanics"
+    name: str                   # e.g. "Gravity"
+    question: str               # Full question text
+    note: str = ""              # Optional guidance note
+    name_zh: str = ""           # Chinese name
+    question_zh: str = ""       # Chinese question text
+    note_zh: str = ""           # Chinese guidance note
+    scale: list[int | str] = field(default_factory=lambda: [1, 2, 3, 4, 5, "N/A"])
+
+
+HUMAN_CRITERIA: list[HumanCriterion] = [
+    # ── G. General ───────────────────────────────────────────────────────────
+    HumanCriterion(
+        key="persistence", code="G1", domain="General", name="Object Persistence",
+        question="To what extent do objects maintain consistent appearance, shape, and existence throughout the video?",
+        name_zh="物体持久性",
+        question_zh="物体在整个视频中在多大程度上保持了一致的外观、形状和存在？",
+    ),
+    HumanCriterion(
+        key="PTV", code="G2", domain="General", name="Temporal Coherence",
+        question="To what extent does the temporal sequence of physical events follow a physically plausible order?",
+        note="Evaluate whether event ordering is logically consistent (e.g., objects break before scattering, liquid is poured before it flows).",
+        name_zh="时序连贯性",
+        question_zh="物理事件的时间顺序在多大程度上遵循了物理上合理的顺序？",
+        note_zh="例如，物体先碎裂再散开，液体先被倒出再流动。",
+    ),
+    HumanCriterion(
+        key="SA", code="G3", domain="General", name="Prompt Alignment",
+        question="To what extent does the video content align with the text prompt?",
+        note="Evaluate whether the depicted scene, objects, actions, and overall narrative correspond to the prompt description.",
+        name_zh="提示词对齐",
+        question_zh="视频内容在多大程度上与文本提示词一致？",
+        note_zh="评估所描绘的场景、物体、动作和整体叙事是否与提示词描述相对应。",
+    ),
+    # ── A. Solid-Body Mechanics ──────────────────────────────────────────────
+    HumanCriterion(
+        key="gravity", code="A1", domain="Solid-Body Mechanics", name="Gravity",
+        question="To what extent do objects and liquids move in accordance with gravity?",
+        note="e.g., unsupported objects fall downward, projectiles follow curved trajectories, poured liquids descend.",
+        name_zh="重力",
+        question_zh="物体和液体在多大程度上按照重力运动？",
+        note_zh="例如，无支撑的物体向下掉落，抛射物沿弧线轨迹运动，倾倒的液体向下流。",
+    ),
+    HumanCriterion(
+        key="inertia", code="A2", domain="Solid-Body Mechanics", name="Inertia",
+        question="To what extent do objects maintain their state of motion — remaining stationary or continuing to move — in the absence of a plausible external force?",
+        note="Penalise significant spontaneous motion or unexplained stopping with no identifiable cause.",
+        name_zh="惯性",
+        question_zh="在没有合理外力的情况下，物体在多大程度上保持其运动状态——静止的保持静止，运动的继续运动？",
+        note_zh="对无明确原因的显著自发运动或无故停止予以扣分。",
+    ),
+    HumanCriterion(
+        key="momentum", code="A3", domain="Solid-Body Mechanics", name="Momentum",
+        question="To what extent are post-collision directions of motion physically plausible?",
+        note="Evaluate direction only; ignore speed magnitude.",
+        name_zh="动量",
+        question_zh="碰撞后物体的运动方向在多大程度上是物理合理的？",
+        note_zh="仅评估方向；忽略速度大小。",
+    ),
+    HumanCriterion(
+        key="impenetrability", code="A4", domain="Solid-Body Mechanics", name="Impenetrability",
+        question="To what extent do solid objects maintain impenetrability, avoiding passage through one another?",
+        name_zh="不可穿透性",
+        question_zh="固体物体在多大程度上保持不可穿透，避免相互穿过？",
+    ),
+    HumanCriterion(
+        key="collision", code="A5", domain="Solid-Body Mechanics", name="Collision Response",
+        question="To what extent do objects exhibit physically plausible responses to impact, proportional to the applied force?",
+        note="e.g., bouncing, shattering, deforming.",
+        name_zh="碰撞响应",
+        question_zh="物体在多大程度上表现出与施加力成比例��物理合理碰撞响应？",
+        note_zh="例如，弹跳、碎裂、变形。",
+    ),
+    HumanCriterion(
+        key="material", code="A6", domain="Solid-Body Mechanics", name="Material Properties",
+        question="To what extent do objects respond in ways consistent with their apparent material properties?",
+        note="e.g., glass shatters, rubber bounces, metal dents, fabric drapes.",
+        name_zh="材料属性",
+        question_zh="物体在多大程度上以符合其表观材料属性的方式做出响应？",
+        note_zh="例如，玻璃碎裂、橡胶弹跳、金属凹陷、布料垂坠。",
+    ),
+    # ── B. Fluid Dynamics ────────────────────────────────────────────────────
+    HumanCriterion(
+        key="buoyancy", code="B1", domain="Fluid Dynamics", name="Buoyancy",
+        question="To what extent do objects sink or float in a manner consistent with their apparent density?",
+        name_zh="浮力",
+        question_zh="物体在多大程度上以符合其表观密度的方式下沉或漂浮？",
+    ),
+    HumanCriterion(
+        key="displacement", code="B2", domain="Fluid Dynamics", name="Displacement",
+        question="When volume is added or an object is submerged, to what extent does the liquid level rise in a physically plausible manner?",
+        note="e.g., level rises proportionally; container overflows when full.",
+        name_zh="液面变化",
+        question_zh="当添加液体或物体浸入时，液面是否合理地上升？",
+        note_zh="例如，液面按比例上升；容器满时溢出。",
+    ),
+    HumanCriterion(
+        key="flow_dynamics", code="B3", domain="Fluid Dynamics", name="Flow Dynamics",
+        question="To what extent does liquid flow along surfaces, spread, and drain in a physically plausible manner?",
+        note="Ignore brief splash details. Penalise unphysical acceleration, sudden stops, or unsupported uphill flow.",
+        name_zh="流体动力学",
+        question_zh="液体在多大程度上以物理合理的方式沿表面流动、铺展和排出？",
+        note_zh="忽略短暂飞溅细节。对非物理的加速、突然停止或无支撑的上坡流动予以扣分。",
+    ),
+    HumanCriterion(
+        key="boundary_interaction", code="B4", domain="Fluid Dynamics", name="Boundary Interaction",
+        question="To what extent does liquid splash, rebound, or split in a physically plausible manner when hitting a boundary?",
+        note="e.g., container walls, rock faces, floors.",
+        name_zh="边界交互",
+        question_zh="液体撞击边界时，其飞溅、反弹或分流在多大程度上是物理合理的？",
+        note_zh="例如，容器壁、岩面、地面。",
+    ),
+    HumanCriterion(
+        key="fluid_continuity", code="B5", domain="Fluid Dynamics", name="Fluid Continuity",
+        question="Does the liquid avoid disappearing or appearing out of nowhere?",
+        note="Small splashes that briefly break apart are okay.",
+        name_zh="流体连续性",
+        question_zh="液体在多大程度上避免了非物理的碎裂、消失或凭空生成？",
+        note_zh="短暂的、物理合理的飞溅分离可以接受。",
+    ),
+    # ── C. Optical Physics ───────────────────────────────────────────────────
+    HumanCriterion(
+        key="reflection", code="C1", domain="Optical Physics", name="Reflection",
+        question="To what extent do reflective surfaces display content that is physically plausible given the surrounding scene?",
+        note="Evaluate whether reflected objects and colours broadly correspond to the scene. Do not require precise geometric mirroring.",
+        name_zh="反射",
+        question_zh="反射表面在多大程度上显示了与周围场景物理合理的内容？",
+        note_zh="评估反射的物体和颜色是否大致对应场景。不要求精确的几何镜像。",
+    ),
+    HumanCriterion(
+        key="shadow", code="C2", domain="Optical Physics", name="Shadow",
+        question="To what extent are shadows physically plausible in their direction, placement, and movement relative to light sources and objects?",
+        name_zh="阴影",
+        question_zh="阴影的方向、位置和运动在多大程度上相对于光源和物体是物理合理的？",
+    ),
+]
+
+#: Quick lookup by criterion key for human-eval criteria.
+HUMAN_CRITERIA_BY_KEY: dict[str, HumanCriterion] = {c.key: c for c in HUMAN_CRITERIA}
+
+
+def get_criteria_text(law_name: str) -> str:
+    """Build full criteria text for a law, preferring HumanCriterion when available."""
+    criterion = HUMAN_CRITERIA_BY_KEY.get(law_name)
+    if criterion:
+        text = criterion.question
+        if criterion.note:
+            text += f" ({criterion.note})"
+        return text
+    return CRITERIA.get(law_name, "")
+
+#: Domain grouping for human-eval criteria.
+HUMAN_DOMAINS: dict[str, list[HumanCriterion]] = {}
+for _c in HUMAN_CRITERIA:
+    HUMAN_DOMAINS.setdefault(_c.domain, []).append(_c)
+
+#: Ordered list of all 13 physical laws (stable order for tabular reporting).
+ALL_LAWS: list[str] = list(CRITERIA_EN.keys())
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Domain → criteria-key groupings
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _subs(keys: list[str]) -> list[tuple[str, str]]:
+    """Return list of (key, bilingual_description) tuples for the given keys."""
+    return [(k, CRITERIA[k]) for k in keys]
+
+#: "fluid" domain covers liquid behaviour only (not smoke, steam, or other gases).
+#: Maps each physical domain to its list of (law_key, description) pairs.
+DOMAIN_SUBSCORES: dict[str, list[tuple[str, str]]] = {
+    "mechanics":      _subs(["gravity", "inertia", "momentum", "impenetrability", "collision", "material"]),
+    "collision":      _subs(["collision", "impenetrability", "momentum", "material"]),
+    "gravity":        _subs(["gravity", "inertia"]),
+    "buoyancy":       _subs(["buoyancy", "displacement"]),
+    "fluid":          _subs(["flow_dynamics", "boundary_interaction", "fluid_continuity"]),
+    "lighting":       _subs(["reflection", "shadow"]),
+}
+

evals/prompts/__init__.py

@@ -0,0 +1,210 @@
+"""Prompt templates and configuration for VLM evaluation and judge training.
+
+Supports loading prompt configs from YAML files for A/B comparison.
+Default config loaded at import for backward compatibility.
+
+Usage:
+    from evals.prompts import PromptConfig
+    cfg = PromptConfig.load("subq+human.yaml")
+    prompt = cfg.build_eval_prompt(caption, "SA")
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from evals.physics_criteria import SUB_QUESTIONS, SubQuestion
+
+_PROMPTS_DIR = Path(__file__).parent
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# PromptConfig
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class PromptConfig:
+    """A prompt template set loaded from YAML."""
+
+    name: str
+    scheme: str
+    system_prompt: str
+    general_keys: list[str]
+    eval_prompts: dict[str, str]
+    training_prompts: dict[str, str]
+    physical_template: str
+    physical_sub_questions: bool = False
+    sub_questions: dict[str, str] | None = None
+
+    @classmethod
+    def load(cls, name: str) -> PromptConfig:
+        """Load evals/prompts/{name}; name must be a YAML filename."""
+        raw_path = Path(name)
+        if raw_path.name != name or raw_path.suffix != ".yaml":
+            raise ValueError(
+                "prompt config must be a YAML filename under evals/prompts, "
+                f"got {name!r}"
+            )
+        path = _PROMPTS_DIR / name
+        with open(path) as f:
+            data = yaml.safe_load(f)
+        return cls._from_dict(data)
+
+    @classmethod
+    def _from_dict(cls, data: dict[str, Any]) -> PromptConfig:
+        def _resolve(raw: str | dict) -> str:
+            if isinstance(raw, str):
+                return raw
+            template = raw["template"]
+            considerations = raw.get("considerations")
+            if considerations and "{considerations}" in template:
+                block = "\n".join(
+                    f"{i}. {c}" for i, c in enumerate(considerations, 1)
+                )
+                template = template.replace("{considerations}", block)
+            return template
+
+        return cls(
+            name=data.get("name", ""),
+            scheme=data.get("scheme", "plain"),
+            system_prompt=data.get(
+                "system_prompt", "You are a strict video evaluation model."
+            ),
+            general_keys=data.get("general_keys", ["SA", "PTV", "persistence"]),
+            eval_prompts={
+                k: _resolve(v) for k, v in data.get("eval_prompts", {}).items()
+            },
+            training_prompts={
+                k: _resolve(v) for k, v in data.get("training_prompts", {}).items()
+            },
+            physical_template=data.get("physical_template", data.get("physical_training_template", "")),
+            physical_sub_questions=bool(data.get("physical_sub_questions", False)),
+            sub_questions=data.get("sub_questions"),
+        )
+
+    @property
+    def _answer_format(self) -> str | None:
+        if self.sub_questions:
+            return self.sub_questions.get("answer_format")
+        return None
+
+    def build_eval_prompt(
+        self, prompt_text: str, metric: str, *, answers_block: str = "",
+    ) -> str:
+        questions_block, question_keys_str = build_general_questions_block(
+            metric, self._answer_format,
+        )
+        return self.eval_prompts[metric].format(
+            prompt=prompt_text,
+            questions_block=questions_block,
+            question_keys_str=question_keys_str,
+            answers_block=answers_block,
+        )
+
+    def build_training_prompt(
+        self, prompt_text: str, dim: str, *, answers_block: str = "",
+    ) -> str:
+        prompts = self.training_prompts or self.eval_prompts
+        questions_block, question_keys_str = build_general_questions_block(
+            dim, self._answer_format,
+        )
+        return prompts[dim].format(
+            prompt=prompt_text,
+            questions_block=questions_block,
+            question_keys_str=question_keys_str,
+            answers_block=answers_block,
+        )
+
+    def build_physical_prompt(
+        self, prompt_text: str, law: str, criteria: str,
+        *, answers_block: str = "",
+    ) -> str:
+        if self.physical_sub_questions:
+            questions_block, question_keys_str = build_physical_questions_block(
+                law, criteria, self._answer_format,
+            )
+        else:
+            questions_block = ""
+            question_keys_str = ""
+        return self.physical_template.format(
+            prompt=prompt_text,
+            law=law,
+            criteria=criteria,
+            questions_block=questions_block,
+            question_keys_str=question_keys_str,
+            answers_block=answers_block,
+        )
+
+
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Scoring dimension keys
+# ──────────────────────────────────────────────────────────────────────────────
+
+GENERAL_KEYS = ["SA", "PTV", "persistence"]
+GENERAL_DIMS = GENERAL_KEYS
+
+GENERAL_SUB_QUESTIONS: dict[str, list[str]] = {
+    "SA": [
+        "Are the main objects in the caption present in the video?",
+        "Are the key actions or interactions from the caption visible?",
+        "Are important scene attributes and relationships preserved?",
+        "Does the video avoid major contradictions to the caption?",
+    ],
+    "PTV": [
+        "Do causes appear before their effects?",
+        "Do physical events unfold in a plausible temporal order?",
+        "Are motion transitions continuous rather than abrupt jumps or loops?",
+        "Does the sequence avoid impossible reversals or repeated resets?",
+    ],
+    "persistence": [
+        "Do objects maintain consistent existence throughout the video?",
+        "Do objects keep a stable shape, size, color, and texture?",
+        "Do objects avoid disappearing, appearing, or transforming unexpectedly?",
+        "Do objects preserve identity through motion and brief occlusion?",
+    ],
+}
+
+
+_ANSWER_FORMAT_SUFFIX = {
+    "answer": "Answer each with yes/no/uncertain.",
+}
+
+
+def _format_questions_block(
+    questions: list[str], answer_format: str | None = None,
+) -> tuple[str, str]:
+    keys: list[str] = []
+    lines: list[str] = []
+    for i, question in enumerate(questions, 1):
+        key = f"q{i}"
+        keys.append(key)
+        lines.append(f"{key}: {question}")
+    suffix = _ANSWER_FORMAT_SUFFIX.get(answer_format or "")
+    if suffix:
+        lines.append(suffix)
+    return "\n".join(lines), ", ".join(keys)
+
+
+def build_general_questions_block(
+    dim: str, answer_format: str | None = None,
+) -> tuple[str, str]:
+    questions = GENERAL_SUB_QUESTIONS.get(dim)
+    if not questions:
+        questions = [f"Does the video satisfy the {dim} criterion?"]
+    return _format_questions_block(questions, answer_format)
+
+
+def build_physical_questions_block(
+    law: str, criteria: str, answer_format: str | None = None,
+) -> tuple[str, str]:
+    sub_qs = SUB_QUESTIONS.get(law)
+    if not sub_qs:
+        sub_qs = [SubQuestion(f"{law}_q1", criteria, violation="no")]
+    return _format_questions_block([sq.question for sq in sub_qs], answer_format)

evals/prompts/cot-subq.yaml

@@ -0,0 +1,128 @@
+scheme: cot_subq
+description: |-
+  Structured sub-question rationale prompts for Claude distillation.
+  Claude answers fixed sub-questions with visible evidence, then outputs a JSON score.
+sub_questions:
+  source: static
+  answer_format: template
+system_prompt: |-
+  You are a strict video evaluation model.
+  Base your judgment only on visible evidence in the video.
+  Provide a concise rationale, then output a JSON object with the score.
+general_keys:
+- SA
+- PTV
+- persistence
+eval_prompts:
+  SA: |-
+    Evaluate Prompt Alignment (SA).
+
+    Caption:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    For each sub-question, briefly state the observed evidence, then give exactly one answer label from: yes, partial, no, uncertain.
+    Use this format for each sub-question:
+    qN: <brief evidence>; answer=<label>
+
+    {questions_block}
+
+    Score 1-5:
+    5=fully aligned
+    4=mostly aligned with minor deviations
+    3=partially aligned with notable gaps
+    2=mostly misaligned
+    1=not aligned
+
+    Answer every sub-question in the format above, then justify the overall score.
+    Then output a JSON object with keys "reasoning" (string) and "SA" (integer 1-5).
+    Output JSON only.
+
+    Example:
+    {{"reasoning": "q1: water balloon, target, and thrower all present; answer=yes. q2: balloon is thrown and bursts on impact; answer=yes. q3: outdoor setting and distance preserved; answer=yes. q4: target behaves like an inflatable rather than cardboard; answer=partial. Overall the scene matches well with one material mismatch.", "SA": 4}}
+  PTV: |-
+    Evaluate Temporal Coherence (PTV).
+
+    Caption:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    For each sub-question, briefly state the observed evidence, then give exactly one answer label from: yes, partial, no, uncertain.
+    Use this format for each sub-question:
+    qN: <brief evidence>; answer=<label>
+
+    {questions_block}
+
+    Score 1-5:
+    5=fully plausible event order
+    4=mostly plausible with minor timing issues
+    3=partially plausible
+    2=mostly implausible
+    1=completely implausible order
+
+    Answer every sub-question in the format above, then justify the overall score.
+    Then output a JSON object with keys "reasoning" (string) and "PTV" (integer 1-5).
+    Output JSON only.
+
+    Example:
+    {{"reasoning": "q1: bottle shatters before any object contacts it, effect precedes cause; answer=no. q2: rupture occurs without visible force, not a plausible physical event order; answer=no. q3: fragments appear instantly rather than progressing from impact point; answer=no. q4: no repeated resets, but the spontaneous break is an impossible state change; answer=partial. Temporal sequence is highly implausible.", "PTV": 1}}
+  persistence: |-
+    Evaluate Object Persistence.
+
+    Caption, for context only:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    For each sub-question, briefly state the observed evidence, then give exactly one answer label from: yes, partial, no, uncertain.
+    Use this format for each sub-question:
+    qN: <brief evidence>; answer=<label>
+
+    {questions_block}
+
+    Score 1-5:
+    5=fully consistent
+    4=mostly consistent with minor flicker
+    3=noticeable issues
+    2=major inconsistencies
+    1=severe disappearance or identity changes
+
+    Answer every sub-question in the format above, then justify the overall score.
+    Then output a JSON object with keys "reasoning" (string) and "persistence" (integer 1-5).
+    Output JSON only.
+
+    Example:
+    {{"reasoning": "q1: tire and ground remain present throughout; answer=yes. q2: tire and ground keep stable color and texture, but bottle label text changes mid-video; answer=partial. q3: no objects disappear or appear unexpectedly; answer=yes. q4: tire identity stable through motion, but bottle label shifts; answer=partial. Minor but noticeable label inconsistency.", "persistence": 3}}
+physical_sub_questions: true
+physical_template: |-
+  Evaluate physical realism for one physical law: {law}.
+
+  Criterion:
+  {criteria}
+
+  Caption, for context only:
+  "{prompt}"
+
+  For each sub-question, briefly state the observed evidence, then give exactly one answer label from: yes, no, uncertain, na.
+  Use this format for each sub-question:
+  qN: <brief evidence>; answer=<label>
+
+  {questions_block}
+
+  Judge the video itself. Do not penalize prompt mismatch unless it affects whether this physical law can be evaluated.
+
+  Score 1-5:
+  5=clearly correct
+  4=mostly correct with minor issues
+  3=partially correct or ambiguous
+  2=mostly incorrect
+  1=severely incorrect
+
+  Answer every sub-question in the format above, then justify the overall score.
+  Then output a JSON object with keys "reasoning" (string) and "{law}" (integer 1-5).
+  Output JSON only.
+
+  Example:
+  {{"reasoning": "q1: baseball stays in place after clear bat contact, completely unaffected; answer=yes. q2: brown chunk appears on ball surface, response wildly disproportionate to impact; answer=yes. q3: bat morphs and clips through ball, but no shattering from light touch; answer=no. Severely incorrect physical behavior.", "{law}": 1}}

evals/prompts/cotnosubq.yaml

@@ -0,0 +1,105 @@
+scheme: cot
+description: |-
+  Free-form rationale prompts for Claude distillation.
+  Claude outputs concise evidence-based reasoning plus a JSON score, used as training data for smaller VLM judges.
+system_prompt: |-
+  You are a strict video evaluation model.
+  Base your judgment only on visible evidence in the video.
+  Provide concise evidence-based reasoning, then output a JSON object with the score.
+general_keys:
+- SA
+- PTV
+- persistence
+eval_prompts:
+  SA: |-
+    Evaluate Prompt Alignment (SA).
+
+    Caption:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    Score 1-5:
+    5=fully aligned
+    4=mostly aligned with minor deviations
+    3=partially aligned with notable gaps
+    2=mostly misaligned
+    1=not aligned
+
+    Write concise reasoning that cites the visible evidence for the score. Consider whether the main objects, actions, scene attributes, and relationships from the caption are present, and whether the video avoids major contradictions to the caption.
+
+    Then output a JSON object with keys "reasoning" (string) and "SA" (integer 1-5).
+    Output JSON only.
+
+    Example:
+    {{"reasoning": "The video shows the water balloon, target, thrower, and outdoor setup described in the caption. The throw and burst are visible, but the target behaves more like an inflatable surface than cardboard, creating a minor material mismatch. Overall the scene follows the requested event with one noticeable deviation.", "SA": 4}}
+  PTV: |-
+    Evaluate Temporal Coherence (PTV).
+
+    Caption:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    Score 1-5:
+    5=fully plausible event order
+    4=mostly plausible with minor timing issues
+    3=partially plausible
+    2=mostly implausible
+    1=completely implausible order
+
+    Write concise reasoning that cites the visible evidence for the score. Consider cause-before-effect order, plausible event timing, continuous motion transitions, and whether the sequence avoids impossible reversals, jumps, loops, or resets.
+
+    Then output a JSON object with keys "reasoning" (string) and "PTV" (integer 1-5).
+    Output JSON only.
+
+    Example:
+    {{"reasoning": "The bottle shatters before any visible object contacts it, so the effect appears before the cause. The rupture happens without a clear force and the fragments appear nearly instantly rather than progressing from an impact point. The temporal sequence is therefore highly implausible.", "PTV": 1}}
+  persistence: |-
+    Evaluate Object Persistence.
+
+    Caption, for context only:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    Score 1-5:
+    5=fully consistent
+    4=mostly consistent with minor flicker
+    3=noticeable issues
+    2=major inconsistencies
+    1=severe disappearance or identity changes
+
+    Write concise reasoning that cites the visible evidence for the score. Consider whether objects remain present, keep stable shape, size, color, and texture, avoid unexpected appearances or transformations, and preserve identity through motion and brief occlusion.
+
+    Then output a JSON object with keys "reasoning" (string) and "persistence" (integer 1-5).
+    Output JSON only.
+
+    Example:
+    {{"reasoning": "The tire and ground remain visible throughout, and the main object identity is mostly stable during motion. However, the bottle label changes appearance mid-video and the held object shows small texture shifts. These are noticeable but not severe persistence errors.", "persistence": 3}}
+physical_sub_questions: false
+physical_template: |-
+  Evaluate physical realism for one physical law: {law}.
+
+  Criterion:
+  {criteria}
+
+  Caption, for context only:
+  "{prompt}"
+
+  Judge the video itself. Do not penalize prompt mismatch unless it affects whether this physical law can be evaluated.
+
+  Score 1-5:
+  5=clearly correct
+  4=mostly correct with minor issues
+  3=partially correct or ambiguous
+  2=mostly incorrect
+  1=severely incorrect
+
+  Write concise reasoning that cites the visible evidence for the score. Focus on whether the relevant physical law is followed in the visible motion, interactions, object boundaries, material behavior, and state changes.
+
+  Then output a JSON object with keys "reasoning" (string) and "{law}" (integer 1-5).
+  Output JSON only.
+
+  Example:
+  {{"reasoning": "The baseball receives clear bat contact but barely responds, so the collision response does not match the visible impact force. A brown deformation appears on the ball surface in a way that is disproportionate and inconsistent with the contact. The physical behavior is severely incorrect for this law.", "{law}": 1}}

evals/prompts/dashboard.py

@@ -0,0 +1,212 @@
+"""Simple dashboard to view prompt YAML files."""
+
+import yaml
+from pathlib import Path
+from flask import Flask, render_template_string
+
+_DIR = Path(__file__).resolve().parent
+
+app = Flask(__name__)
+
+TEMPLATE = r"""
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Prompt Viewer</title>
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+         background: #f5f5f5; color: #333; }
+  .header { background: #1a1a2e; color: #fff; padding: 24px 32px; }
+  .header h1 { font-size: 1.5rem; font-weight: 600; }
+  .header p { color: #aaa; margin-top: 4px; font-size: 0.9rem; }
+  .container { max-width: 1200px; margin: 0 auto; padding: 24px; }
+  .tabs { display: flex; gap: 8px; flex-wrap: wrap; margin-bottom: 24px; }
+  .tab { padding: 8px 20px; border: 1px solid #ddd; border-radius: 6px;
+         background: #fff; cursor: pointer; font-size: 0.9rem; transition: all 0.15s; }
+  .tab:hover { border-color: #667; }
+  .tab.active { background: #1a1a2e; color: #fff; border-color: #1a1a2e; }
+  .yaml-card { display: none; }
+  .yaml-card.active { display: block; }
+  .meta { display: flex; gap: 16px; margin-bottom: 20px; flex-wrap: wrap; }
+  .meta-item { background: #fff; border: 1px solid #e0e0e0; border-radius: 8px;
+               padding: 12px 20px; }
+  .meta-label { font-size: 0.75rem; text-transform: uppercase; color: #888; letter-spacing: 0.05em; }
+  .meta-value { font-size: 1rem; font-weight: 600; margin-top: 2px; }
+  .section { background: #fff; border: 1px solid #e0e0e0; border-radius: 8px;
+             margin-bottom: 16px; overflow: hidden; }
+  .section-header { padding: 12px 20px; background: #fafafa; border-bottom: 1px solid #e0e0e0;
+                    font-weight: 600; font-size: 0.95rem; cursor: pointer; user-select: none;
+                    display: flex; justify-content: space-between; align-items: center; }
+  .section-header:hover { background: #f0f0f0; }
+  .section-header .arrow { transition: transform 0.2s; font-size: 0.8rem; color: #888; }
+  .section-header.collapsed .arrow { transform: rotate(-90deg); }
+  .section-body { padding: 0; }
+  .section-header.collapsed + .section-body { display: none; }
+  .prompt-row { border-bottom: 1px solid #f0f0f0; }
+  .prompt-row:last-child { border-bottom: none; }
+  .prompt-key { padding: 10px 20px; background: #f8f9fa; font-weight: 600;
+                font-size: 0.85rem; color: #555; border-bottom: 1px solid #eee; }
+  .prompt-text { padding: 16px 20px; white-space: pre-wrap; font-family: 'SF Mono', Monaco,
+                 'Cascadia Code', monospace; font-size: 0.82rem; line-height: 1.6;
+                 color: #2d2d2d; background: #fff; }
+  .raw-block { padding: 16px 20px; white-space: pre-wrap; font-family: 'SF Mono', Monaco,
+               monospace; font-size: 0.82rem; line-height: 1.5; background: #fafafa; }
+</style>
+</head>
+<body>
+<div class="header">
+  <h1>Prompt YAML Viewer</h1>
+  <p>evals/prompts/ &mdash; {{ files | length }} files</p>
+</div>
+<div class="container">
+  <div class="tabs">
+    {% for f in files %}
+    <div class="tab {% if loop.first %}active{% endif %}" onclick="switchTab('{{ f.name }}', this)">
+      {{ f.name }}
+    </div>
+    {% endfor %}
+  </div>
+
+  {% for f in files %}
+  <div id="card-{{ f.name }}" class="yaml-card {% if loop.first %}active{% endif %}">
+    <div class="meta">
+      <div class="meta-item">
+        <div class="meta-label">Scheme</div>
+        <div class="meta-value">{{ f.data.get('scheme', '-') }}</div>
+      </div>
+      <div class="meta-item">
+        <div class="meta-label">General Keys</div>
+        <div class="meta-value">{{ f.data.get('general_keys', []) | join(', ') or '-' }}</div>
+      </div>
+      <div class="meta-item">
+        <div class="meta-label">Physical Sub-Questions</div>
+        <div class="meta-value">{{ f.data.get('physical_sub_questions', '-') }}</div>
+      </div>
+    </div>
+
+    {% if f.data.get('description') %}
+    <div class="section">
+      <div class="section-header" onclick="toggleSection(this)">
+        Description <span class="arrow">&#9660;</span>
+      </div>
+      <div class="section-body">
+        <div class="raw-block">{{ f.data['description'] }}</div>
+      </div>
+    </div>
+    {% endif %}
+
+    {% if f.data.get('system_prompt') %}
+    <div class="section">
+      <div class="section-header" onclick="toggleSection(this)">
+        System Prompt <span class="arrow">&#9660;</span>
+      </div>
+      <div class="section-body">
+        <div class="prompt-text">{{ f.data['system_prompt'] }}</div>
+      </div>
+    </div>
+    {% endif %}
+
+    {% if f.data.get('eval_prompts') %}
+    <div class="section">
+      <div class="section-header" onclick="toggleSection(this)">
+        Eval Prompts <span class="arrow">&#9660;</span>
+      </div>
+      <div class="section-body">
+        {% for key, val in f.data['eval_prompts'].items() %}
+        <div class="prompt-row">
+          <div class="prompt-key">{{ key }}</div>
+          <div class="prompt-text">{{ val }}</div>
+        </div>
+        {% endfor %}
+      </div>
+    </div>
+    {% endif %}
+
+    {% if f.data.get('training_prompts') %}
+    <div class="section">
+      <div class="section-header" onclick="toggleSection(this)">
+        Training Prompts <span class="arrow">&#9660;</span>
+      </div>
+      <div class="section-body">
+        {% for key, val in f.data['training_prompts'].items() %}
+        <div class="prompt-row">
+          <div class="prompt-key">{{ key }}</div>
+          <div class="prompt-text">{{ val }}</div>
+        </div>
+        {% endfor %}
+      </div>
+    </div>
+    {% endif %}
+
+    {% if f.data.get('physical_template') %}
+    <div class="section">
+      <div class="section-header" onclick="toggleSection(this)">
+        Physical Template <span class="arrow">&#9660;</span>
+      </div>
+      <div class="section-body">
+        <div class="prompt-text">{{ f.data['physical_template'] }}</div>
+      </div>
+    </div>
+    {% endif %}
+
+    {% if f.data.get('sub_questions') %}
+    <div class="section">
+      <div class="section-header" onclick="toggleSection(this)">
+        Sub-Questions Config <span class="arrow">&#9660;</span>
+      </div>
+      <div class="section-body">
+        <div class="raw-block">{{ f.sub_questions_str }}</div>
+      </div>
+    </div>
+    {% endif %}
+
+    <div class="section">
+      <div class="section-header collapsed" onclick="toggleSection(this)">
+        Raw YAML <span class="arrow">&#9660;</span>
+      </div>
+      <div class="section-body" style="display:none">
+        <div class="raw-block">{{ f.raw }}</div>
+      </div>
+    </div>
+  </div>
+  {% endfor %}
+</div>
+
+<script>
+function switchTab(name, el) {
+  document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+  document.querySelectorAll('.yaml-card').forEach(c => c.classList.remove('active'));
+  el.classList.add('active');
+  document.getElementById('card-' + name).classList.add('active');
+}
+function toggleSection(header) {
+  header.classList.toggle('collapsed');
+  const body = header.nextElementSibling;
+  body.style.display = body.style.display === 'none' ? '' : 'none';
+}
+</script>
+</body>
+</html>
+"""
+
+
+def load_yamls():
+    files = []
+    for p in sorted(_DIR.glob("*.yaml")):
+        raw = p.read_text()
+        data = yaml.safe_load(raw) or {}
+        sq = data.get("sub_questions")
+        sq_str = yaml.dump(sq, default_flow_style=False) if sq else ""
+        files.append({"name": p.name, "data": data, "raw": raw, "sub_questions_str": sq_str})
+    return files
+
+
+@app.route("/")
+def index():
+    return render_template_string(TEMPLATE, files=load_yamls())
+
+
+if __name__ == "__main__":
+    app.run(host="127.0.0.1", port=5003, debug=True)

evals/prompts/default.yaml

@@ -0,0 +1,124 @@
+scheme: plain
+description: Per-dimension evaluation prompts, 1-5 scale (v2)
+system_prompt: You are a strict video evaluation model.
+general_keys:
+- SA
+- PTV
+- persistence
+eval_prompts:
+  SA: |-
+    You are evaluating a generated video on Prompt Alignment (SA).
+
+    The text prompt used to generate this video is:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    Score SA (Prompt Alignment, 1-5):
+    5=perfectly matches prompt, 4=clearly matches, 3=mostly matches, 2=clearly does not match well, 1=severely contradicts.
+    Evaluate whether the depicted scene, objects, actions, and overall narrative correspond to the prompt description.
+
+    Output ONLY a JSON object with exactly one key "SA" (integer 1-5). No other text.
+
+    Example:
+    {{"SA": 3}}
+  PTV: |-
+    You are evaluating a generated video on Temporal Coherence (PTV).
+
+    The text prompt used to generate this video is:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    Score PTV (Temporal Coherence, 1-5):
+    5=perfect temporal sequence, 4=correct order with minor timing issues, 3=mostly correct order, 2=significant misordering, 1=completely wrong temporal sequence.
+    Evaluate whether event ordering is logically consistent (e.g., objects break before scattering, liquid is poured before it flows).
+
+    Output ONLY a JSON object with exactly one key "PTV" (integer 1-5). No other text.
+
+    Example:
+    {{"PTV": 4}}
+  persistence: |-
+    You are evaluating a generated video on Object Persistence.
+
+    The text prompt used to generate this video is:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    Score persistence (Object Persistence, 1-5):
+    5=perfect object constancy, 4=near-perfect with trivial flicker, 3=minor inconsistencies, 2=noticeable persistence issues, 1=severe violations (objects appear/disappear/transform randomly).
+
+    Output ONLY a JSON object with exactly one key "persistence" (integer 1-5). No other text.
+
+    Example:
+    {{"persistence": 4}}
+training_prompts:
+  SA: |-
+    You are evaluating a generated video on Prompt Alignment (SA).
+
+    Caption:
+    "{prompt}"
+
+    Evaluate whether the video content matches the caption, including scene, objects, actions, and relationships.
+
+    Score 1-5:
+    5=fully aligned
+    4=mostly aligned with minor deviations
+    3=partially aligned with notable gaps
+    2=mostly misaligned
+    1=not aligned
+
+    Output ONLY a JSON object with exactly one key: SA.
+  PTV: |-
+    You are evaluating Temporal Coherence (PTV).
+
+    Caption:
+    "{prompt}"
+
+    Evaluate whether the sequence of physical events follows a plausible temporal order.
+
+    Score 1-5:
+    5=fully plausible event order
+    4=mostly plausible with minor issues
+    3=partially plausible
+    2=mostly implausible
+    1=completely implausible order
+
+    Output ONLY a JSON object with exactly one key: PTV.
+  persistence: |-
+    You are evaluating Object Persistence.
+
+    Caption, for context only:
+    "{prompt}"
+
+    Evaluate whether objects maintain consistent existence, shape, and appearance throughout the video.
+
+    Score 1-5:
+    5=fully consistent
+    4=mostly consistent with minor flicker
+    3=noticeable issues
+    2=major inconsistencies
+    1=severe disappearance or identity changes
+
+    Output ONLY a JSON object with exactly one key: persistence.
+physical_sub_questions: false
+physical_template: |-
+  You are evaluating physical realism for one physical law: {law}.
+
+  Criterion:
+  {criteria}
+
+  Caption, for context only:
+  "{prompt}"
+  {questions_block}
+  Judge the video itself. Do not penalize prompt mismatch unless it affects whether this physical law can be evaluated.
+
+  Score 1-5:
+  5=clearly correct
+  4=mostly correct with minor issues
+  3=partially correct or ambiguous
+  2=mostly incorrect
+  1=severely incorrect
+
+  Output ONLY a JSON object with exactly one key: {law}.

evals/prompts/subq+answer.yaml

@@ -0,0 +1,123 @@
+scheme: subq_answer
+description: |-
+  JSON-only per-task prompts with sub-questions AND model (Qwen) answers.
+  输入: sub-questions + Qwen 对子问题的回答 + 视频. 输出: JSON score only.
+sub_questions:
+  source: static
+  answer_format: hint
+system_prompt: You are a strict video evaluation model.
+general_keys:
+- SA
+- PTV
+- persistence
+eval_prompts:
+  SA: |-
+    Evaluate Prompt Alignment (SA).
+
+    Caption:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    Sub-questions and reference answers from another model:
+    {questions_block}
+
+    Reference answers:
+    {answers_block}
+
+    Use the reference answers as additional context, but base your final judgment on the video itself.
+
+    Score 1-5:
+    5=fully aligned
+    4=mostly aligned with minor deviations
+    3=partially aligned with notable gaps
+    2=mostly misaligned
+    1=not aligned
+
+    Then output ONLY a JSON object with exactly one key: SA.
+
+    Example:
+    {{"SA": 3}}
+  PTV: |-
+    Evaluate Temporal Coherence (PTV).
+
+    Caption:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    Sub-questions and reference answers from another model:
+    {questions_block}
+
+    Reference answers:
+    {answers_block}
+
+    Use the reference answers as additional context, but base your final judgment on the video itself.
+
+    Score 1-5:
+    5=fully plausible event order
+    4=mostly plausible with minor timing issues
+    3=partially plausible
+    2=mostly implausible
+    1=completely implausible order
+
+    Then output ONLY a JSON object with exactly one key: PTV.
+
+    Example:
+    {{"PTV": 4}}
+  persistence: |-
+    Evaluate Object Persistence.
+
+    Caption, for context only:
+    "{prompt}"
+
+    The video was generated using a text+image-to-video (ti2v) model, conditioned on the first frame and the text prompt above.
+
+    Sub-questions and reference answers from another model:
+    {questions_block}
+
+    Reference answers:
+    {answers_block}
+
+    Use the reference answers as additional context, but base your final judgment on the video itself.
+
+    Score 1-5:
+    5=fully consistent
+    4=mostly consistent with minor flicker
+    3=noticeable issues
+    2=major inconsistencies
+    1=severe disappearance or identity changes
+
+    Then output ONLY a JSON object with exactly one key: persistence.
+
+    Example:
+    {{"persistence": 4}}
+physical_sub_questions: true
+physical_template: |-
+  Evaluate physical realism for one physical law: {law}.
+
+  Criterion:
+  {criteria}
+
+  Caption, for context only:
+  "{prompt}"
+
+  Sub-questions and reference answers from another model:
+  {questions_block}
+
+  Reference answers:
+  {answers_block}
+
+  Use the reference answers as additional context, but judge the video itself. Do not penalize prompt mismatch unless it affects whether this physical law can be evaluated.
+
+  Score 1-5:
+  5=clearly correct
+  4=mostly correct with minor issues
+  3=partially correct or ambiguous
+  2=mostly incorrect
+  1=severely incorrect
+
+  Then output ONLY a JSON object with exactly one key: {law}.
+
+  Example:
+  {{"{law}": 3}}