Initial RoboGen v1

README.md

@@ -1,13 +1,26 @@
 ---
-title: Robogen
-emoji: 📚
-colorFrom: gray
-colorTo: red
+title: RoboGen
+emoji: 📊
+colorFrom: purple
+colorTo: blue
 sdk: gradio
-sdk_version: 6.15.1
-python_version: '3.13'
+sdk_version: 4.29.0
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# RoboGen — Synthetic Robotics Dataset Generator
+
+**Physics-accurate LeRobot-format datasets for SO-100, SO-101, and Koch arms.**
+
+Generate synthetic datasets with physically-plausible trajectories, automatic quality
+scoring against HaptalAI's misalignment benchmark, and one-click download.
+
+## Features
+- Cubic spline trajectories with analytical velocity derivatives (not random walks)
+- Three failure modes: grasp slip, velocity spike, torque saturation
+- Quality scoring via calibrated MAD z-score thresholds (community-benchmarked)
+- Downloadable zip: parquet dataset + auto-generated README
+
+## Contact
+aarav@haptal.ai

airtable.py

@@ -0,0 +1,73 @@
+"""
+airtable.py — email gate logging to Airtable.
+
+Required env vars:
+  AIRTABLE_BASE_ID   — e.g. "appXXXXXXXXXXXXXX"
+  AIRTABLE_API_KEY   — personal access token ("pat...")
+
+Table name is hardcoded as "RoboGen Leads".  Change TABLE_NAME below if needed.
+Failures are swallowed — caller receives a (success: bool, message: str) tuple
+and must allow the download even if logging fails.
+"""
+
+import os
+import json
+import datetime
+from typing import Tuple, Optional
+
+try:
+    import requests
+    _REQUESTS_OK = True
+except ImportError:
+    _REQUESTS_OK = False
+
+TABLE_NAME = "RoboGen Leads"
+
+_BASE_ID = os.environ.get("AIRTABLE_BASE_ID", "")
+_API_KEY  = os.environ.get("AIRTABLE_API_KEY",  "")
+
+
+def log_email(
+    email:       str,
+    robot:       str,
+    task:        str,
+    n_episodes:  int,
+    quality_score: float,
+    band:        str,
+) -> Tuple[bool, str]:
+    """
+    POST one record to Airtable.
+
+    Returns (True, "Logged") on success, (False, reason) on failure.
+    Caller MUST still enable the download on failure.
+    """
+    if not _REQUESTS_OK:
+        return False, "requests library not installed"
+
+    if not _BASE_ID or not _API_KEY:
+        return False, "AIRTABLE_BASE_ID / AIRTABLE_API_KEY not set"
+
+    endpoint = f"https://api.airtable.com/v0/{_BASE_ID}/{TABLE_NAME.replace(' ', '%20')}"
+    headers  = {
+        "Authorization": f"Bearer {_API_KEY}",
+        "Content-Type":  "application/json",
+    }
+    payload  = {
+        "fields": {
+            "Email":         email.strip(),
+            "Robot":         robot,
+            "Task":          task,
+            "Episodes":      n_episodes,
+            "Quality Score": quality_score,
+            "Band":          band,
+            "Timestamp":     datetime.datetime.utcnow().isoformat() + "Z",
+        }
+    }
+
+    try:
+        resp = requests.post(endpoint, headers=headers, json=payload, timeout=6)
+        if resp.status_code in (200, 201):
+            return True, "Logged"
+        return False, f"HTTP {resp.status_code}: {resp.text[:200]}"
+    except Exception as exc:
+        return False, str(exc)

app.py

@@ -0,0 +1,616 @@
+"""
+RoboGen — HaptalAI Synthetic Robotics Dataset Generator
+Gradio Space: HaptalAI/robogen
+
+Step-by-step UI:
+  1 → Robot selection (card buttons)
+  2 → Task selection (dropdown)
+  3 → Parameter configuration (sliders + checkboxes with tooltips)
+  4 → Generate (progress bar)
+  5 → Results dashboard (quality score, band, failure breakdown)
+  6 → Email gate → Download zip (parquet + README)
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import io
+import json
+import zipfile
+import tempfile
+import traceback
+from typing import Optional, Dict, List
+
+# Allow running as  python space/app.py  from repo root
+sys.path.insert(0, os.path.dirname(__file__))
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+
+from generator import (
+    generate_dataset,
+    score_dataset,
+    annotate_quality_scores,
+    TASKS_BY_ROBOT,
+    ROBOT_CONFIG,
+    FAILURE_TYPES,
+)
+from readme_gen import generate_readme
+from airtable import log_email
+
+# ── Load CSS ──────────────────────────────────────────────────────────────────
+
+_CSS_PATH = os.path.join(os.path.dirname(__file__), "style.css")
+with open(_CSS_PATH) as _f:
+    _CSS = _f.read()
+
+# ── Robot display config ──────────────────────────────────────────────────────
+
+ROBOT_ICONS = {
+    "SO-100": "SO-100",
+    "SO-101": "SO-101",
+    "Koch":   "Koch",
+}
+
+ROBOT_DESCRIPTIONS = {
+    "SO-100": "Low-cost 6-DOF arm, community favourite",
+    "SO-101": "Upgraded SO-100 with refined kinematics",
+    "Koch":   "Koch arm — drawer & manipulation tasks",
+}
+
+TASK_LABELS = {
+    "pick_and_place":    "Pick and Place",
+    "push_object":       "Push Object",
+    "grasp_and_lift":    "Grasp and Lift",
+    "stacking":          "Stacking",
+    "drawer_open_close": "Drawer Open / Close",
+}
+
+FAILURE_LABELS = {
+    "grasp_slip":        "Grasp Slip",
+    "velocity_spike":    "Velocity Spike",
+    "torque_saturation": "Torque Saturation",
+}
+
+# ── Default parameters per robot × task ──────────────────────────────────────
+
+DEFAULTS: Dict[str, Dict] = {
+    "SO-100": {"n_eps": 50, "success": 70, "fmin": 1.0, "fmax": 10.0},
+    "SO-101": {"n_eps": 50, "success": 70, "fmin": 1.0, "fmax": 10.0},
+    "Koch":   {"n_eps": 30, "success": 75, "fmin": 0.5, "fmax":  8.0},
+}
+
+# ── HTML helpers ──────────────────────────────────────────────────────────────
+
+def _make_results_html(result: Dict, robot: str, task: str) -> str:
+    score  = result["overall_score"]
+    band   = result["band"]
+    n_pass = result["n_passed"]
+    n_flag = result["n_flagged"]
+    n_eps  = result["n_episodes"]
+    mismatch = result["mean_mismatch"]
+    fb       = result["failure_breakdown"]
+    scorer   = result["scorer_used"]
+
+    band_cls  = band.lower()
+    band_desc = {
+        "Clean":   "Trajectories are smooth and anomaly-free. Ready for policy training.",
+        "Review":  "Some anomalies detected. Review flagged episodes before training.",
+        "Flagged": "High anomaly rate. Best used for failure analysis and augmentation.",
+    }.get(band, "")
+
+    # Failure bars
+    total_failures = sum(fb.values()) or 1
+    bar_html = ""
+    for key, count in sorted(fb.items(), key=lambda x: -x[1]):
+        label = FAILURE_LABELS.get(key, key)
+        pct   = count / total_failures * 100
+        bar_html += f"""
+        <div class="rg-failure-bar">
+          <span class="rg-failure-label">{label}</span>
+          <div class="rg-bar-track"><div class="rg-bar-fill" style="width:{pct:.0f}%"></div></div>
+          <span class="rg-bar-count">{count}</span>
+        </div>"""
+
+    task_label  = TASK_LABELS.get(task, task)
+    no_failures = "No failure episodes in dataset." if not fb else ""
+
+    return f"""
+<div class="rg-results">
+  <div class="rg-score-row">
+    <div class="rg-score-circle {band_cls}">
+      <span class="rg-score-value">{score:.0f}</span>
+      <span class="rg-score-denom">/ 100</span>
+    </div>
+    <div class="rg-score-info">
+      <div class="rg-band-badge {band_cls}">{band}</div>
+      <div class="rg-band-desc">{band_desc}</div>
+    </div>
+  </div>
+
+  <div class="rg-stat-grid">
+    <div class="rg-stat">
+      <div class="rg-stat-value">{n_eps}</div>
+      <div class="rg-stat-label">Total Episodes</div>
+    </div>
+    <div class="rg-stat">
+      <div class="rg-stat-value" style="color:var(--green)">{n_pass}</div>
+      <div class="rg-stat-label">Passed</div>
+    </div>
+    <div class="rg-stat">
+      <div class="rg-stat-value" style="color:var(--red)">{n_flag}</div>
+      <div class="rg-stat-label">Flagged</div>
+    </div>
+    <div class="rg-stat">
+      <div class="rg-stat-value">{mismatch:.3f}</div>
+      <div class="rg-stat-label">Mean Mismatch</div>
+    </div>
+    <div class="rg-stat">
+      <div class="rg-stat-value">{robot}</div>
+      <div class="rg-stat-label">Robot</div>
+    </div>
+    <div class="rg-stat">
+      <div class="rg-stat-value" style="font-size:0.9rem">{task_label}</div>
+      <div class="rg-stat-label">Task</div>
+    </div>
+  </div>
+
+  <div class="rg-failure-section">
+    <div class="rg-failure-title">Failure Type Breakdown</div>
+    {bar_html or no_failures}
+  </div>
+
+  <div class="rg-scorer-note">
+    Scored by HaptalAI misalignment benchmark &middot; scorer: <code>{scorer}</code>
+  </div>
+</div>
+"""
+
+
+# ── Download bundle builder ───────────────────────────────────────────────────
+
+def _build_zip(
+    df:      pd.DataFrame,
+    result:  Dict,
+    robot:   str,
+    task:    str,
+    n_eps:   int,
+    success: float,
+    fmin:    float,
+    fmax:    float,
+    failures: List[str],
+) -> str:
+    """Annotate DF, write parquet + README into a temp zip, return zip path."""
+    df_annotated = annotate_quality_scores(df, result)
+
+    readme_md = generate_readme(
+        robot=robot, task=task, n_episodes=n_eps,
+        success_rate=success / 100, force_min=fmin, force_max=fmax,
+        failures=failures,
+        score=result["overall_score"], band=result["band"],
+        n_passed=result["n_passed"], n_flagged=result["n_flagged"],
+        mean_mismatch=result["mean_mismatch"],
+        failure_breakdown=result["failure_breakdown"],
+        scorer_used=result["scorer_used"],
+    )
+
+    tag     = f"{robot.replace('-', '')}_{task}"
+    zip_fd, zip_path = tempfile.mkstemp(suffix=".zip", prefix=f"robogen_{tag}_")
+    os.close(zip_fd)
+
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        # Parquet
+        buf = io.BytesIO()
+        df_annotated.to_parquet(buf, index=False)
+        zf.writestr(f"robogen_{tag}.parquet", buf.getvalue())
+        # README
+        zf.writestr("README.md", readme_md.encode("utf-8"))
+
+    return zip_path
+
+
+# ── Gradio app ────────────────────────────────────────────────────────────────
+
+def build_app() -> gr.Blocks:
+
+    with gr.Blocks(
+        css=_CSS,
+        theme=gr.themes.Base(
+            primary_hue=gr.themes.colors.purple,
+            neutral_hue=gr.themes.colors.slate,
+        ),
+        title="RoboGen — Synthetic Robotics Datasets",
+        analytics_enabled=False,
+    ) as demo:
+
+        # ── Persistent state ──────────────────────────────────────────────
+        robot_state  = gr.State("")
+        df_state     = gr.State(None)
+        result_state = gr.State(None)
+
+        # ── Header ────────────────────────────────────────────────────────
+        gr.HTML("""
+        <div class="rg-header">
+          <div class="rg-logo">RoboGen</div>
+          <div class="rg-tagline">Synthetic robotics datasets, physics-accurate &amp; quality-scored</div>
+          <div class="rg-badge">LeRobot-format &nbsp;&middot;&nbsp; SO-100 / SO-101 / Koch &nbsp;&middot;&nbsp; HaptalAI</div>
+        </div>
+        """)
+
+        # ────────────────────────────────────────────────────────────────────
+        # STEP 1 — Robot selection
+        # ────────────────────────────────────────────────────────────────────
+        with gr.Group(elem_classes=["step-card"]):
+            gr.HTML("""
+            <div class="step-header">
+              <span class="step-num">1</span>
+              <span class="step-title">Select Robot</span>
+            </div>""")
+
+            robot_select = gr.Radio(
+                choices=["SO-100", "Koch", "SO-101"],
+                value=None,
+                label="",
+                elem_classes=["robot-radio"],
+            )
+
+        # ────────────────────────────────────────────────────────────────────
+        # STEP 2 — Task selection
+        # ────────────────────────────────────────────────────────────────────
+        with gr.Group(visible=False, elem_classes=["step-card"]) as step2_grp:
+            gr.HTML("""
+            <div class="step-header">
+              <span class="step-num">2</span>
+              <span class="step-title">Select Task</span>
+            </div>""")
+
+            task_select = gr.Dropdown(
+                choices=[],
+                value=None,
+                label="Task",
+                interactive=True,
+            )
+
+        # ────────────────────────────────────────────────────────────────────
+        # STEP 3 — Parameters
+        # ────────────────────────────────────────────────────────────────────
+        with gr.Group(visible=False, elem_classes=["step-card"]) as step3_grp:
+            gr.HTML("""
+            <div class="step-header">
+              <span class="step-num">3</span>
+              <span class="step-title">Configure Parameters</span>
+            </div>""")
+
+            with gr.Row():
+                n_episodes_slider = gr.Slider(
+                    minimum=10, maximum=500, value=50, step=5,
+                    label="Number of Episodes",
+                    info="Total episodes in the dataset (10–500)",
+                )
+                success_slider = gr.Slider(
+                    minimum=0, maximum=100, value=70, step=5,
+                    label="Success Rate (%)",
+                    info="Fraction of episodes with successful trajectories",
+                )
+
+            with gr.Row():
+                force_min_slider = gr.Slider(
+                    minimum=0.1, maximum=10.0, value=1.0, step=0.1,
+                    label="Min Contact Force (N)",
+                    info="Lower bound of spring-damper contact force during grasping",
+                )
+                force_max_slider = gr.Slider(
+                    minimum=1.0, maximum=20.0, value=10.0, step=0.5,
+                    label="Max Contact Force (N)",
+                    info="Upper bound of contact force — higher = firmer grip",
+                )
+
+            gr.HTML("""
+            <div style="margin: 4px 0 8px;font-size:0.82rem;color:#8892a4;">
+              <b>Failure types to include</b> &nbsp;
+              <span style="font-style:italic;">
+                Grasp Slip — gripper opens mid-episode &nbsp;|&nbsp;
+                Velocity Spike — servo glitch (z&gt;6.5) &nbsp;|&nbsp;
+                Torque Saturation — joint hits angular limit
+              </span>
+            </div>""")
+
+            failure_check = gr.CheckboxGroup(
+                choices=["grasp_slip", "velocity_spike", "torque_saturation"],
+                value=["grasp_slip", "velocity_spike", "torque_saturation"],
+                label="",
+                elem_classes=["checkbox-group"],
+            )
+
+        # ────────────────────────────────────────────────────────────────────
+        # STEP 4 — Generate
+        # ────────────────────────────────────────────────────────────────────
+        with gr.Group(visible=False, elem_classes=["step-card"]) as step4_grp:
+            gr.HTML("""
+            <div class="step-header">
+              <span class="step-num">4</span>
+              <span class="step-title">Generate Dataset</span>
+            </div>""")
+
+            generate_btn = gr.Button(
+                "Generate Dataset",
+                elem_classes=["btn-generate"],
+                size="lg",
+            )
+            gen_status = gr.Markdown("", elem_classes=["status-msg"])
+
+        # ────────────────────────────────────────────────────────────────────
+        # STEP 5 — Results dashboard
+        # ────────────────────────────────────────────────────────────────────
+        with gr.Group(visible=False, elem_classes=["step-card"]) as step5_grp:
+            gr.HTML("""
+            <div class="step-header">
+              <span class="step-num">5</span>
+              <span class="step-title">Quality Results</span>
+            </div>""")
+            results_html = gr.HTML("")
+
+        # ────────────────────────────────────────────────────────────────────
+        # STEP 6 — Email gate + Download
+        # ──────────���─────────────────────────────────────────────────────────
+        with gr.Group(visible=False, elem_classes=["step-card"]) as step6_grp:
+            gr.HTML("""
+            <div class="step-header">
+              <span class="step-num">6</span>
+              <span class="step-title">Download Dataset</span>
+            </div>
+            <div class="email-gate-note">
+              Enter your email to unlock the download. You'll receive occasional
+              updates on new robot configs and dataset improvements.
+            </div>""")
+
+            with gr.Row():
+                email_input = gr.Textbox(
+                    placeholder="you@example.com",
+                    label="Email",
+                    scale=4,
+                    max_lines=1,
+                )
+                email_btn = gr.Button(
+                    "Confirm →",
+                    elem_classes=["btn-primary"],
+                    scale=1,
+                )
+
+            email_status = gr.Markdown("", visible=True)
+
+            download_file = gr.File(
+                label="Download robogen_dataset.zip",
+                visible=False,
+                interactive=False,
+            )
+
+        # ════════════════════════════════════════════════════════════════════
+        # EVENT HANDLERS
+        # ════════════════════════════════════════════════════════════════════
+
+        # ── Step 1 → Step 2: Robot selected ──────────────────────────────
+        def on_robot_select(robot: str):
+            if not robot:
+                return (
+                    gr.update(visible=False),
+                    gr.update(choices=[], value=None),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    robot,
+                )
+            tasks_raw = TASKS_BY_ROBOT[robot]
+            tasks_disp = [(TASK_LABELS.get(t, t), t) for t in tasks_raw]
+            d = DEFAULTS.get(robot, DEFAULTS["SO-100"])
+            return (
+                gr.update(visible=True),                            # step2_grp
+                gr.update(choices=tasks_disp, value=tasks_raw[0]), # task_select
+                gr.update(visible=False),                           # step3_grp
+                gr.update(visible=False),                           # step4_grp
+                robot,                                              # robot_state
+            )
+
+        robot_select.change(
+            on_robot_select,
+            inputs=[robot_select],
+            outputs=[step2_grp, task_select, step3_grp, step4_grp, robot_state],
+        )
+
+        # ── Step 2 → Step 3: Task selected ───────────────────────────────
+        def on_task_select(task: str, robot: str):
+            if not task or not robot:
+                return (
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    50, 70, 1.0, 10.0,
+                )
+            d = DEFAULTS.get(robot, DEFAULTS["SO-100"])
+            cfg_fr = ROBOT_CONFIG[robot]["force_range"]
+            return (
+                gr.update(visible=True),   # step3_grp
+                gr.update(visible=True),   # step4_grp
+                d["n_eps"],
+                d["success"],
+                cfg_fr[0],
+                cfg_fr[1],
+            )
+
+        task_select.change(
+            on_task_select,
+            inputs=[task_select, robot_state],
+            outputs=[
+                step3_grp, step4_grp,
+                n_episodes_slider, success_slider,
+                force_min_slider, force_max_slider,
+            ],
+        )
+
+        # ── Step 4: Generate ─────────────────────────────────────────────
+        def on_generate(
+            robot, task, n_eps, success_pct, fmin, fmax, failures,
+            progress=gr.Progress(track_tqdm=False),
+        ):
+            if not robot or not task:
+                return (
+                    "Please complete steps 1 and 2 first.",
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    None, None,
+                )
+            if not failures:
+                failures = list(FAILURE_TYPES)
+
+            try:
+                # ── Generation ──────────────────────────────────────────
+                def gen_progress(frac, msg):
+                    progress(frac * 0.65, desc=msg)
+
+                progress(0.0, desc="Generating episodes…")
+                df = generate_dataset(
+                    robot=robot, task=task,
+                    n_episodes=int(n_eps),
+                    success_rate=success_pct / 100,
+                    force_min=float(fmin), force_max=float(fmax),
+                    enabled_failures=list(failures),
+                    seed=None,
+                    progress_callback=gen_progress,
+                )
+
+                # ── Scoring ─────────────────────────────────────────────
+                progress(0.70, desc="Running quality checks…")
+
+                def score_progress(frac, msg):
+                    progress(0.70 + frac * 0.20, desc=msg)
+
+                result = score_dataset(df, progress_callback=score_progress)
+
+                progress(0.92, desc="Preparing results…")
+                results_panel = _make_results_html(result, robot, task)
+                progress(1.0, desc="Done")
+
+                status = (
+                    f"Generated {len(df):,} rows across {result['n_episodes']} episodes — "
+                    f"score **{result['overall_score']:.1f}/100** ({result['band']})"
+                )
+
+                return (
+                    status,
+                    gr.update(visible=True),   # step5_grp
+                    results_panel,             # results_html
+                    gr.update(visible=True),   # step6_grp
+                    df,                        # df_state
+                    result,                    # result_state
+                )
+
+            except Exception:
+                err = traceback.format_exc()
+                return (
+                    f"Generation failed:\n```\n{err}\n```",
+                    gr.update(visible=False),
+                    "",
+                    gr.update(visible=False),
+                    None, None,
+                )
+
+        generate_btn.click(
+            on_generate,
+            inputs=[
+                robot_state, task_select,
+                n_episodes_slider, success_slider,
+                force_min_slider, force_max_slider,
+                failure_check,
+            ],
+            outputs=[
+                gen_status,
+                step5_grp, results_html,
+                step6_grp,
+                df_state, result_state,
+            ],
+        )
+
+        # ── Step 6: Email gate → unlock download ──────────────────────────
+        def on_email_submit(
+            email: str,
+            robot: str,
+            task: str,
+            n_eps: float,
+            success_pct: float,
+            fmin: float,
+            fmax: float,
+            failures: List[str],
+            df: Optional[pd.DataFrame],
+            result: Optional[Dict],
+        ):
+            if not email or "@" not in email:
+                return (
+                    "Please enter a valid email address.",
+                    gr.update(visible=False),
+                )
+            if df is None or result is None:
+                return (
+                    "Generate a dataset first (Step 4).",
+                    gr.update(visible=False),
+                )
+
+            # Fire Airtable (failure is non-blocking)
+            try:
+                ok, msg = log_email(
+                    email=email.strip(),
+                    robot=robot, task=task,
+                    n_episodes=int(n_eps),
+                    quality_score=result["overall_score"],
+                    band=result["band"],
+                )
+                if not ok:
+                    print(f"[RoboGen] Airtable log failed: {msg}")
+            except Exception as exc:
+                print(f"[RoboGen] Airtable exception: {exc}")
+
+            # Build download zip regardless of Airtable outcome
+            try:
+                zip_path = _build_zip(
+                    df=df, result=result,
+                    robot=robot, task=task,
+                    n_eps=int(n_eps), success=success_pct,
+                    fmin=float(fmin), fmax=float(fmax),
+                    failures=list(failures),
+                )
+                return (
+                    "Email confirmed. Your download is ready below.",
+                    gr.update(visible=True, value=zip_path),
+                )
+            except Exception:
+                err = traceback.format_exc()
+                return (
+                    f"Download preparation failed:\n```\n{err}\n```",
+                    gr.update(visible=False),
+                )
+
+        email_btn.click(
+            on_email_submit,
+            inputs=[
+                email_input,
+                robot_state, task_select,
+                n_episodes_slider, success_slider,
+                force_min_slider, force_max_slider,
+                failure_check,
+                df_state, result_state,
+            ],
+            outputs=[email_status, download_file],
+        )
+
+    return demo
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    app = build_app()
+    app.launch(
+        share=True,
+        server_port=int(os.environ.get("PORT", 7860)),
+        show_error=True,
+    )

generator.py

@@ -0,0 +1,698 @@
+"""
+RoboGen — Synthetic Robotics Dataset Generator
+generator.py: Physically-plausible episode generation for LeRobot-format parquet datasets.
+
+Schema
+------
+  state_0..state_5   — observed joint positions at time t (rad)
+  action_0..action_5 — joint velocity COMMANDS at time t (rad/s)
+
+Physics model
+-------------
+  1. Task-specific waypoints (approach → contact → grasp/push → retract)
+  2. Cubic spline interpolation, clamped boundary (zero velocity at endpoints)
+  3. Velocities = analytical first derivative of position spline (rad/s)
+  4. Sensor noise: Gaussian σ_pos=0.002 rad, σ_vel=0.004 rad/s
+  5. Contact force: spring-damper ramp during contact window
+
+Failure modes
+-------------
+  grasp_slip        — smooth until 60-70%, then position discontinuity + velocity collapse
+  velocity_spike    — 1-2 frames with MAD z-score > 6.5 on joint velocity
+  torque_saturation — joint clamped at limit for ≥3 frames (velocity near zero, pos at limit)
+
+Z-score note: both injection and detection use robust MAD z-scores so that a single
+spike value does not inflate the reference statistics.
+
+Scorer
+------
+  Set SCORER_PATH env var to ~/Downloads/quality_scorer root; falls back to built-in.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Dict, List, Optional, Tuple
+import math
+
+import numpy as np
+import pandas as pd
+from scipy.interpolate import CubicSpline
+
+# ── Scorer import ────────────────────────────────────────────────────────────
+
+_SCORER_PATH = os.environ.get(
+    "SCORER_PATH", os.path.expanduser("~/Downloads/quality_scorer")
+)
+if _SCORER_PATH not in sys.path:
+    sys.path.insert(0, _SCORER_PATH)
+
+try:
+    from scorer.scorer import score_dataset as _ext_score_dataset  # type: ignore
+    EXTERNAL_SCORER = True
+except ImportError:
+    EXTERNAL_SCORER = False
+
+# ── Robot / task configuration ───────────────────────────────────────────────
+
+ROBOT_CONFIG: Dict[str, Dict] = {
+    "SO-100": {
+        "n_joints": 6,
+        # Per-joint [lo, hi] limits in radians
+        "joint_limits": [
+            (-3.14, 3.14),   # j0 base rotation
+            (-1.57, 1.57),   # j1 shoulder pitch
+            (-0.20, 2.80),   # j2 elbow
+            (-3.14, 3.14),   # j3 wrist roll
+            (-1.57, 1.57),   # j4 wrist pitch
+            (-0.10, 1.00),   # j5 gripper
+        ],
+        "home":    np.array([0.00, -0.52,  1.20,  0.00, -0.72,  0.05]),
+        "targets": {
+            "pick_and_place": np.array([ 0.30,  0.20,  0.80,  0.10, -0.30,  0.50]),
+            "push_object":    np.array([ 0.50,  0.12,  1.00,  0.00, -0.50,  0.00]),
+            "grasp_and_lift": np.array([ 0.22,  0.30,  0.48,  0.18, -0.40,  0.28]),
+            "stacking":       np.array([ 0.12,  0.42,  0.68,  0.14, -0.30,  0.18]),
+        },
+        "gripper_joint":     5,
+        "torque_joint_pool": [1, 2, 3, 4],   # joints that realistically saturate
+        "max_velocity":      1.5,             # rad/s
+        "force_range":       (0.5, 12.0),
+    },
+    "SO-101": {
+        "n_joints": 6,
+        "joint_limits": [
+            (-3.14, 3.14), (-1.57, 1.57), (-0.20, 2.80),
+            (-3.14, 3.14), (-1.57, 1.57), (-0.10, 1.00),
+        ],
+        "home":    np.array([0.00, -0.42,  1.12,  0.00, -0.62,  0.05]),
+        "targets": {
+            "pick_and_place": np.array([ 0.35,  0.24,  0.76,  0.14, -0.26,  0.46]),
+            "push_object":    np.array([ 0.54,  0.14,  0.96,  0.04, -0.46,  0.04]),
+            "grasp_and_lift": np.array([ 0.24,  0.34,  0.46,  0.24, -0.36,  0.24]),
+            "stacking":       np.array([ 0.14,  0.44,  0.66,  0.19, -0.26,  0.14]),
+        },
+        "gripper_joint":     5,
+        "torque_joint_pool": [1, 2, 3, 4],
+        "max_velocity":      1.5,
+        "force_range":       (0.5, 12.0),
+    },
+    "Koch": {
+        "n_joints": 6,
+        "joint_limits": [
+            (-3.14, 3.14), (-1.57, 1.57), (-0.10, 2.50),
+            (-3.14, 3.14), (-1.57, 1.57), (-0.10, 1.00),
+        ],
+        "home":    np.array([0.00, -0.60,  1.28,  0.00, -0.82,  0.05]),
+        "targets": {
+            "pick_and_place":    np.array([ 0.40,  0.16,  0.88,  0.06, -0.42,  0.58]),
+            "drawer_open_close": np.array([ 0.00,  0.10,  1.10,  0.00, -0.60,  0.00]),
+            "grasp_and_lift":    np.array([ 0.28,  0.26,  0.54,  0.19, -0.46,  0.34]),
+        },
+        "gripper_joint":     5,
+        "torque_joint_pool": [1, 2, 3],
+        "max_velocity":      1.2,
+        "force_range":       (0.3, 10.0),
+    },
+}
+
+TASKS_BY_ROBOT: Dict[str, List[str]] = {
+    "SO-100": ["pick_and_place", "push_object", "grasp_and_lift", "stacking"],
+    "SO-101": ["pick_and_place", "push_object", "grasp_and_lift", "stacking"],
+    "Koch":   ["pick_and_place", "drawer_open_close", "grasp_and_lift"],
+}
+
+FAILURE_TYPES = ["grasp_slip", "velocity_spike", "torque_saturation"]
+
+FRAMES_PER_EPISODE = 50
+DT                 = 0.02   # seconds/frame at 50 Hz
+
+# Community-calibrated thresholds (MAD z-score basis)
+VELOCITY_SPIKE_Z   = 6.5
+MISMATCH_THRESHOLD = 0.50
+
+# ── Robust statistics helpers ─────────────────────────────────────────────────
+
+def _robust_z(values: np.ndarray) -> np.ndarray:
+    """
+    Compute per-column MAD z-scores:  z = |x - median| / (MAD * 1.4826)
+    The 1.4826 factor makes MAD a consistent estimator of σ under normality.
+    A single outlier barely affects median or MAD, so injected spikes retain
+    their true z-score instead of being pulled down by contaminated reference stats.
+    """
+    med = np.median(values, axis=0)
+    mad = np.median(np.abs(values - med), axis=0)
+    scale = mad * 1.4826 + 1e-6
+    return np.abs(values - med) / scale
+
+
+# ── Waypoint factory ──────────────────────────────────────────────────────────
+
+def _build_waypoints(
+    task: str,
+    home: np.ndarray,
+    target: np.ndarray,
+    rng: np.random.Generator,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Return (t_knots_normalised [0..1], waypoint_matrix [n_knots, n_joints]).
+    Waypoints encode task-specific motion primitives; small Gaussian noise
+    ensures episode-to-episode variation.
+    """
+    n = len(home)
+    ns = lambda s=0.008: rng.normal(0, s, n)
+
+    if task == "pick_and_place":
+        approach  = home + 0.25 * (target - home) + ns()
+        pre_grasp = home + 0.44 * (target - home) + ns()
+        grasp     = home + 0.60 * (target - home) + ns(0.003)
+        lift      = grasp.copy(); lift[2] = lift[2] * 0.82 + ns(0.003)[2]
+        transport = home + 0.82 * (target - home) + ns()
+        place     = target + ns(0.003)
+        t = np.array([0.0, 0.18, 0.38, 0.55, 0.68, 0.83, 1.0])
+        w = np.vstack([home, approach, pre_grasp, grasp, lift, transport, place])
+
+    elif task == "push_object":
+        approach = home + 0.35 * (target - home) + ns()
+        contact  = home + 0.56 * (target - home) + ns(0.004)
+        push_end = target + ns(0.006)
+        retract  = home + 0.20 * (target - home) + ns()
+        t = np.array([0.0, 0.28, 0.52, 0.73, 1.0])
+        w = np.vstack([home, approach, contact, push_end, retract])
+
+    elif task == "grasp_and_lift":
+        descend   = home + 0.28 * (target - home) + ns()
+        pre_grasp = home + 0.52 * (target - home) + ns()
+        grasp     = target + ns(0.003)
+        lift      = grasp.copy(); lift[2] -= 0.28 + ns(0.005)[2]
+        t = np.array([0.0, 0.22, 0.46, 0.68, 1.0])
+        w = np.vstack([home, descend, pre_grasp, grasp, lift])
+
+    elif task == "stacking":
+        grasp_pos = home + 0.38 * (target - home) + ns()
+        lift_pos  = grasp_pos.copy(); lift_pos[2] -= 0.32
+        hover     = home + 0.70 * (target - home) + ns()
+        lower     = target + ns(0.004)
+        release   = lower.copy(); release[5] += 0.18
+        t = np.array([0.0, 0.20, 0.40, 0.60, 0.82, 1.0])
+        w = np.vstack([home, grasp_pos, lift_pos, hover, lower, release])
+
+    elif task == "drawer_open_close":
+        extend    = home + 0.28 * (target - home) + ns()
+        at_handle = home + 0.52 * (target - home) + ns(0.004)
+        pull_mid  = home + 0.74 * (target - home) + ns()
+        open_pos  = target + ns(0.006)
+        t = np.array([0.0, 0.26, 0.50, 0.74, 1.0])
+        w = np.vstack([home, extend, at_handle, pull_mid, open_pos])
+
+    else:
+        mid = home + 0.50 * (target - home) + ns()
+        t   = np.array([0.0, 0.50, 1.0])
+        w   = np.vstack([home, mid, target])
+
+    return t, w
+
+
+# ── Smooth trajectory via cubic spline ────────────────────────────────────────
+
+def _smooth_trajectory(
+    task: str,
+    home: np.ndarray,
+    target: np.ndarray,
+    n_frames: int,
+    rng: np.random.Generator,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Returns:
+        positions  (n_frames, n_joints) rad   — joint positions
+        velocities (n_frames, n_joints) rad/s — analytical spline derivative
+    """
+    n_joints = len(home)
+    t_norm, wpts = _build_waypoints(task, home, target, rng)
+    t_knots  = t_norm * (n_frames - 1)
+    t_frames = np.arange(n_frames, dtype=float)
+
+    pos = np.zeros((n_frames, n_joints))
+    vel = np.zeros((n_frames, n_joints))
+
+    for j in range(n_joints):
+        cs       = CubicSpline(t_knots, wpts[:, j], bc_type="clamped")
+        pos[:, j] = cs(t_frames)
+        vel[:, j] = cs(t_frames, 1) / DT   # derivative in rad/frame → rad/s
+
+    pos += rng.normal(0, 0.002, pos.shape)
+    vel += rng.normal(0, 0.004, vel.shape)
+    return pos, vel
+
+
+# ── Contact force model ────────────���──────────────────────────────────────────
+
+def _force_profile(
+    n_frames: int,
+    task: str,
+    force_range: Tuple[float, float],
+    rng: np.random.Generator,
+) -> np.ndarray:
+    """Spring-damper contact force, non-zero during contact window."""
+    f_min, f_max = force_range
+    force = np.zeros(n_frames)
+    if task not in {"pick_and_place", "grasp_and_lift", "stacking",
+                    "push_object", "drawer_open_close"}:
+        return force
+    c0, c1 = int(0.30 * n_frames), int(0.75 * n_frames)
+    for i in range(n_frames):
+        if c0 <= i <= c1:
+            phase   = (i - c0) / max(c1 - c0, 1)
+            ramp    = math.sin(phase * math.pi / 2) if phase < 0.30 else 1.0
+            force[i] = ramp * rng.uniform(f_min * 1.5, f_max) + rng.normal(0, 0.12)
+        else:
+            force[i] = rng.uniform(0, f_min * 0.25)
+    return np.clip(force, 0, f_max + 1)
+
+
+# ── Failure injectors ─────────────────────────────────────────────────────────
+
+def _inject_grasp_slip(
+    pos: np.ndarray,
+    vel: np.ndarray,
+    force: np.ndarray,
+    gripper: int,
+    rng: np.random.Generator,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Grasp slip at 60-70% of episode:
+      pos : gripper jumps open (discontinuity ≥ 0.18 rad)
+      vel : transient spike at slip frame, then near-zero (contact lost)
+      force: collapses post-slip
+    """
+    n = pos.shape[0]
+    sf = int(rng.uniform(0.60, 0.70) * n)
+
+    # Position discontinuity — gripper opens
+    slip_mag           = rng.uniform(0.18, 0.38)
+    pos[sf:, gripper]  += slip_mag
+    pos[sf:, max(0, gripper - 1)] += rng.uniform(0.04, 0.12)
+
+    # Velocity: brief spike at slip frame then collapse
+    v_med = float(np.median(np.abs(vel[:sf, gripper]))) + 0.05
+    vel[sf, gripper]    += v_med * rng.uniform(9.0, 12.0)   # big transient
+    vel[sf + 1:, gripper] *= rng.uniform(0.04, 0.12)
+
+    force[sf:] = np.clip(rng.exponential(0.25, n - sf), 0, 0.5)
+    return pos, vel, force
+
+
+def _inject_velocity_spike(
+    vel: np.ndarray,
+    rng: np.random.Generator,
+) -> np.ndarray:
+    """
+    1-2 frames with MAD z-score > 6.5 in the middle 60% of episode.
+    Uses robust reference stats (median / MAD) so the injected spike value
+    correctly yields the target z-score when detected later.
+    """
+    n_frames, n_joints = vel.shape
+    n_spikes = int(rng.integers(1, 3))
+
+    zone    = np.arange(int(0.20 * n_frames), int(0.80 * n_frames))
+    frames  = rng.choice(zone, size=min(n_spikes, len(zone)), replace=False)
+
+    v_med   = np.median(vel, axis=0)
+    v_mad   = np.median(np.abs(vel - v_med), axis=0) * 1.4826 + 1e-4
+
+    for sf in frames:
+        j        = int(rng.integers(0, n_joints - 1))   # skip gripper
+        z_target = float(rng.uniform(7.5, 9.8))
+        sign     = 1.0 if rng.random() > 0.5 else -1.0
+        # spike = median + z_target * sigma_MAD  → guaranteed MAD z-score ≈ z_target
+        vel[sf, j] = v_med[j] + sign * z_target * v_mad[j]
+
+    return vel
+
+
+def _inject_torque_saturation(
+    pos: np.ndarray,
+    vel: np.ndarray,
+    joint_limits: List[Tuple[float, float]],
+    torque_pool: List[int],
+    rng: np.random.Generator,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    One arm joint hits its angular limit and holds for ≥3 frames:
+      pos : clamped at limit (within sensor noise)
+      vel : near zero during saturation (joint stalled)
+    """
+    n = pos.shape[0]
+    j = int(rng.choice(torque_pool))
+    lo, hi = joint_limits[j]
+
+    mid_pos  = pos[:, j].mean()
+    at_limit = hi if mid_pos > (lo + hi) / 2 else lo
+
+    sat_start = int(rng.uniform(0.25, 0.62) * n)
+    sat_len   = int(rng.integers(3, 9))
+    sat_end   = min(sat_start + sat_len, n)
+
+    pos[sat_start:sat_end, j] = at_limit + rng.normal(0, 0.001, sat_end - sat_start)
+    vel[sat_start:sat_end, j] = rng.normal(0, 0.005, sat_end - sat_start)
+
+    return pos, vel
+
+
+# ── Episode builder ───────────────────────────────────────────────────────────
+
+def _build_episode(
+    ep_idx:       int,
+    robot:        str,
+    task:         str,
+    failure_type: str,
+    cfg:          Dict,
+    rng:          np.random.Generator,
+) -> pd.DataFrame:
+    """
+    Build one LeRobot-compatible episode DataFrame.
+
+    Columns: state_0..5 (rad), action_0..5 (rad/s), timestamp (s),
+             episode_index, frame_index, task, use_for_training,
+             failure_type, quality_score (placeholder=0)
+    """
+    n  = cfg["n_joints"]
+    home   = cfg["home"].copy()
+    target = cfg["targets"][task].copy() + rng.normal(0, 0.025, n)
+
+    pos, vel = _smooth_trajectory(task, home, target, FRAMES_PER_EPISODE, rng)
+    force    = _force_profile(FRAMES_PER_EPISODE, task, cfg["force_range"], rng)
+
+    if   failure_type == "grasp_slip":
+        pos, vel, force = _inject_grasp_slip(pos, vel, force, cfg["gripper_joint"], rng)
+    elif failure_type == "velocity_spike":
+        vel             = _inject_velocity_spike(vel, rng)
+    elif failure_type == "torque_saturation":
+        pos, vel        = _inject_torque_saturation(pos, vel, cfg["joint_limits"],
+                                                    cfg["torque_joint_pool"], rng)
+
+    for j, (lo, hi) in enumerate(cfg["joint_limits"]):
+        pos[:, j] = np.clip(pos[:, j], lo, hi)
+
+    vel = np.clip(vel, -cfg["max_velocity"] * 2, cfg["max_velocity"] * 2)
+
+    label = failure_type if failure_type != "none" else "success"
+
+    return pd.DataFrame({
+        **{f"state_{j}":  pos[:, j] for j in range(n)},
+        **{f"action_{j}": vel[:, j] for j in range(n)},
+        "timestamp":       np.arange(FRAMES_PER_EPISODE, dtype=float) * DT,
+        "episode_index":   np.full(FRAMES_PER_EPISODE, ep_idx, dtype=int),
+        "frame_index":     np.arange(FRAMES_PER_EPISODE, dtype=int),
+        "task":            task,
+        "use_for_training": (failure_type == "none"),
+        "failure_type":    label,
+        "quality_score":   0.0,
+    })
+
+
+# ── Dataset generator ─────────────────────────────────────────────────────────
+
+def generate_dataset(
+    robot:            str,
+    task:             str,
+    n_episodes:       int,
+    success_rate:     float,
+    force_min:        float,
+    force_max:        float,
+    enabled_failures: List[str],
+    seed:             Optional[int] = None,
+    progress_callback = None,
+) -> pd.DataFrame:
+    """
+    Generate a full synthetic dataset.
+
+    Parameters
+    ----------
+    robot             : "SO-100" | "SO-101" | "Koch"
+    task              : from TASKS_BY_ROBOT[robot]
+    n_episodes        : 10–500
+    success_rate      : 0.0–1.0
+    force_min/max     : contact force range override (N)
+    enabled_failures  : subset of FAILURE_TYPES
+    seed              : reproducibility seed
+    progress_callback : optional (fraction: float, message: str) → None
+
+    Returns
+    -------
+    pd.DataFrame, n_episodes * FRAMES_PER_EPISODE rows
+    """
+    if robot not in ROBOT_CONFIG:
+        raise ValueError(f"Unknown robot '{robot}'. Options: {list(ROBOT_CONFIG)}")
+    if task not in TASKS_BY_ROBOT.get(robot, []):
+        raise ValueError(f"Task '{task}' invalid for {robot}.")
+    if not enabled_failures:
+        enabled_failures = list(FAILURE_TYPES)
+
+    rng = np.random.default_rng(seed)
+    cfg = {**ROBOT_CONFIG[robot], "force_range": (force_min, force_max)}
+
+    n_success  = int(round(n_episodes * success_rate))
+    n_fail     = n_episodes - n_success
+    pool       = (list(enabled_failures) * (n_fail // max(len(enabled_failures), 1) + 1))[:n_fail]
+    manifest   = ["none"] * n_success + pool
+    rng.shuffle(manifest)
+
+    frames = []
+    for i, ft in enumerate(manifest):
+        if progress_callback and i % max(1, n_episodes // 20) == 0:
+            progress_callback(i / n_episodes, f"Generating episode {i + 1}/{n_episodes}…")
+        frames.append(_build_episode(i, robot, task, ft, cfg, rng))
+
+    if progress_callback:
+        progress_callback(0.95, "Concatenating dataset…")
+
+    df = pd.concat(frames, ignore_index=True)
+    # Embed robot metadata column so scorer can look up joint limits
+    df["robot"] = robot
+    return df
+
+
+# ── Built-in scorer ───────────────────────────────────────────────────────────
+
+def _builtin_score(df: pd.DataFrame) -> Dict:
+    """
+    Calibrated quality scorer using MAD z-scores (community thresholds).
+
+    Detection criteria
+    ------------------
+    velocity_spike     : MAD z-score on action columns > 6.5 in any frame
+    grasp_slip         : |Δgripper_pos| > 0.10 rad in a single frame
+    torque_saturation  : ≥3 consecutive frames with |velocity| < 0.012 rad/s
+                         AND position within 3% of known joint limit
+                         (uses 'robot' column if present, otherwise ±0.90*π heuristic)
+    mismatch_fraction  : (n_spike + slip + sat anomalous frames) / n_frames
+    flagged            : mismatch_fraction > 0.50
+    """
+    act_cols = [f"action_{j}" for j in range(6)]
+    pos_cols = [f"state_{j}"  for j in range(6)]
+
+    # Try to get joint limits from robot column
+    robot_col = df.get("robot", pd.Series(dtype=str))
+    first_robot = robot_col.iloc[0] if len(robot_col) else None
+    joint_limits = (
+        ROBOT_CONFIG[first_robot]["joint_limits"]
+        if first_robot in ROBOT_CONFIG else [(-3.14, 3.14)] * 6
+    )
+
+    rows = []
+    for ep_idx, ep in df.groupby("episode_index"):
+        acts  = ep[act_cols].values
+        poss  = ep[pos_cols].values
+        n_f   = len(ep)
+
+        # ── Velocity spike (MAD z-score) ──────────────────────────────────
+        z           = _robust_z(acts)
+        spike_mask  = z.max(axis=1) > VELOCITY_SPIKE_Z
+        n_spikes    = int(spike_mask.sum())
+        max_z       = float(z.max())
+
+        # ── Grasp slip ────────────────────────────────────────────────────
+        gripper_delta = np.abs(np.diff(poss[:, 5]))
+        n_slip_frames = int((gripper_delta > 0.10).sum())
+
+        # ── Torque saturation (velocity near-zero AND position near limit) ─
+        sat_joints = 0
+        for j in range(5):   # joints 0-4; skip gripper (j=5)
+            lo, hi    = joint_limits[j]
+            limit_tol = abs(hi - lo) * 0.03    # 3% of range from limit
+            consec = 0
+            for i in range(n_f):
+                near_limit = (
+                    poss[i, j] >= hi - limit_tol or
+                    poss[i, j] <= lo + limit_tol
+                )
+                near_zero = abs(acts[i, j]) < 0.012
+                if near_limit and near_zero:
+                    consec += 1
+                    if consec >= 3:
+                        sat_joints += 1
+                        break
+                else:
+                    consec = 0
+
+        # ── Mismatch fraction & episode score ─────────────────────────────
+        n_anomalous       = n_spikes + min(1, n_slip_frames) + min(1, sat_joints)
+        mismatch_fraction = n_anomalous / max(n_f, 1)
+        flagged           = mismatch_fraction > MISMATCH_THRESHOLD
+
+        penalty    = n_spikes * 9.0 + n_slip_frames * 7.0 + sat_joints * 6.0 + mismatch_fraction * 18.0
+        ep_score   = float(np.clip(100.0 - penalty, 0, 100))
+
+        rows.append({
+            "episode_index":     ep_idx,
+            "failure_type":      ep["failure_type"].iloc[0],
+            "n_spike_frames":    n_spikes,
+            "max_velocity_z":    round(max_z, 2),
+            "n_slip_frames":     n_slip_frames,
+            "n_sat_joints":      sat_joints,
+            "mismatch_fraction": round(mismatch_fraction, 4),
+            "episode_score":     round(ep_score, 2),
+            "flagged":           flagged,
+        })
+
+    ep_df      = pd.DataFrame(rows)
+    n_eps      = len(ep_df)
+    n_flagged  = int(ep_df["flagged"].sum())
+    n_passed   = n_eps - n_flagged
+    mean_score = float(ep_df["episode_score"].mean())
+    band       = "Clean" if mean_score >= 80 else ("Review" if mean_score >= 55 else "Flagged")
+
+    failure_breakdown = (
+        ep_df[ep_df["failure_type"] != "success"]
+        .groupby("failure_type").size().to_dict()
+    )
+
+    return {
+        "overall_score":     round(mean_score, 2),
+        "band":              band,
+        "n_episodes":        n_eps,
+        "n_passed":          n_passed,
+        "n_flagged":         n_flagged,
+        "mean_mismatch":     round(float(ep_df["mismatch_fraction"].mean()), 4),
+        "failure_breakdown": failure_breakdown,
+        "episode_details":   ep_df,
+        "scorer_used":       "builtin",
+    }
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+def score_dataset(df: pd.DataFrame, progress_callback=None) -> Dict:
+    """Score a dataset; prefers external scorer if SCORER_PATH resolves."""
+    if progress_callback:
+        progress_callback(0.05, "Running quality checks…")
+
+    if EXTERNAL_SCORER:
+        try:
+            result = _ext_score_dataset(df)
+            result["scorer_used"] = "external"
+            if progress_callback:
+                progress_callback(1.0, "Scoring complete (external scorer).")
+            return result
+        except Exception as exc:
+            print(f"[RoboGen] External scorer failed ({exc}); using built-in.")
+
+    result = _builtin_score(df)
+    if progress_callback:
+        progress_callback(1.0, "Scoring complete.")
+    return result
+
+
+def annotate_quality_scores(df: pd.DataFrame, score_result: Dict) -> pd.DataFrame:
+    """Merge per-episode quality scores into the main DataFrame."""
+    ep_scores = (
+        score_result["episode_details"][["episode_index", "episode_score"]]
+        .rename(columns={"episode_score": "quality_score"})
+    )
+    return df.drop(columns=["quality_score"], errors="ignore").merge(
+        ep_scores, on="episode_index", how="left"
+    )
+
+
+# ── CLI demo ──────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    pd.set_option("display.max_columns", 20)
+    pd.set_option("display.width", 160)
+    pd.set_option("display.float_format", "{:+.4f}".format)
+
+    DEMO = [
+        ("SO-100", "pick_and_place", "none",              "SUCCESS          "),
+        ("SO-100", "pick_and_place", "grasp_slip",        "GRASP SLIP       "),
+        ("SO-100", "pick_and_place", "velocity_spike",    "VELOCITY SPIKE   "),
+        ("SO-100", "pick_and_place", "torque_saturation", "TORQUE SAT.      "),
+    ]
+
+    rng = np.random.default_rng(42)
+    cfg = ROBOT_CONFIG["SO-100"].copy()
+
+    print("=" * 92)
+    print("  RoboGen — generator.py validation")
+    print("  state_*  = joint positions (rad) | action_* = velocity commands (rad/s)")
+    print("=" * 92)
+
+    for ep_idx, (robot, task, ft, label) in enumerate(DEMO):
+        print(f"\n{'─'*92}")
+        print(f"  Episode {ep_idx}  │  {label}│  {robot} / {task}")
+        print(f"{'─'*92}")
+        ep = _build_episode(ep_idx, robot, task, ft, cfg, rng)
+
+        cols = ["frame_index", "state_0", "state_4", "state_5",
+                "action_0", "action_4", "action_5"]
+        sample = pd.concat([ep.head(4), ep.iloc[28:33], ep.tail(4)])[cols]
+        print(sample.to_string(index=False))
+
+        acts = ep[[f"action_{j}" for j in range(6)]].values
+        poss = ep[[f"state_{j}"  for j in range(6)]].values
+
+        z             = _robust_z(acts)
+        n_spikes      = int((z.max(1) > VELOCITY_SPIKE_Z).sum())
+        max_z         = z.max()
+        n_slip        = int((np.abs(np.diff(poss[:, 5])) > 0.10).sum())
+
+        jl = cfg["joint_limits"]
+        sat_joints = 0
+        for j in range(5):
+            lo, hi  = jl[j]
+            tol     = abs(hi - lo) * 0.03
+            consec  = 0
+            for i in range(len(ep)):
+                nl = poss[i, j] >= hi - tol or poss[i, j] <= lo + tol
+                nz = abs(acts[i, j]) < 0.012
+                consec = consec + 1 if (nl and nz) else 0
+                if consec >= 3: sat_joints += 1; break
+
+        print(f"\n  Vel (action)  │ mean={acts.mean():+.3f}  std={acts.std():.3f}  "
+              f"max_MAD_z={max_z:.2f}  spike_frames(z>{VELOCITY_SPIKE_Z})={n_spikes}")
+        print(f"  Gripper pos   │ max_Δ={np.abs(np.diff(poss[:,5])).max():.4f} rad  "
+              f"slip_frames(Δ>0.10)={n_slip}  sat_joints={sat_joints}")
+
+    print(f"\n{'='*92}")
+    print("  10-episode mini-dataset  (60% success, all failure modes, seed=99)")
+    print(f"{'='*92}")
+    mini = generate_dataset(
+        robot="SO-100", task="pick_and_place",
+        n_episodes=10, success_rate=0.60,
+        force_min=1.0, force_max=10.0,
+        enabled_failures=list(FAILURE_TYPES), seed=99,
+    )
+    res = score_dataset(mini)
+    pd.set_option("display.float_format", "{:.2f}".format)
+    print(f"\n  Overall score  : {res['overall_score']:.1f}/100")
+    print(f"  Band           : {res['band']}")
+    print(f"  Passed/Flagged : {res['n_passed']} / {res['n_flagged']}")
+    print(f"  Mean mismatch  : {res['mean_mismatch']:.4f}")
+    print(f"  Failures       : {res['failure_breakdown']}")
+    print(f"  Scorer         : {res['scorer_used']}")
+    print()
+    cols = ["episode_index","failure_type","n_spike_frames","max_velocity_z",
+            "n_slip_frames","n_sat_joints","mismatch_fraction","episode_score","flagged"]
+    print(res["episode_details"][cols].to_string(index=False))
+    print(f"\n{'='*92}\n")

readme_gen.py

@@ -0,0 +1,180 @@
+"""
+readme_gen.py — dynamically generated README for downloaded RoboGen datasets.
+"""
+
+from __future__ import annotations
+import datetime
+from typing import Dict, List
+
+
+COLUMN_DOCS = {
+    "state_0":  "Joint 0 — base rotation (rad)",
+    "state_1":  "Joint 1 — shoulder pitch (rad)",
+    "state_2":  "Joint 2 — elbow (rad)",
+    "state_3":  "Joint 3 — wrist roll (rad)",
+    "state_4":  "Joint 4 — wrist pitch (rad)",
+    "state_5":  "Joint 5 — gripper (rad, 0=closed → 1=open)",
+    "action_0": "Velocity command joint 0 — base (rad/s)",
+    "action_1": "Velocity command joint 1 — shoulder (rad/s)",
+    "action_2": "Velocity command joint 2 — elbow (rad/s)",
+    "action_3": "Velocity command joint 3 — wrist roll (rad/s)",
+    "action_4": "Velocity command joint 4 — wrist pitch (rad/s)",
+    "action_5": "Velocity command joint 5 — gripper (rad/s)",
+    "timestamp":       "Seconds since episode start (50 Hz → Δt=0.02 s)",
+    "episode_index":   "Integer episode identifier (0-indexed)",
+    "frame_index":     "Frame number within episode (0–49 for 50-frame episodes)",
+    "task":            "Task label string",
+    "use_for_training":"True for successful episodes only; False for failure episodes",
+    "failure_type":    "'success' | 'grasp_slip' | 'velocity_spike' | 'torque_saturation'",
+    "quality_score":   "Per-episode quality score (0–100) from HaptalAI scorer",
+    "robot":           "Robot model string: 'SO-100' | 'SO-101' | 'Koch'",
+}
+
+FAILURE_DESCRIPTIONS = {
+    "grasp_slip":        "Smooth trajectory until 60-70% of episode, then gripper opens "
+                         "unintentionally (position discontinuity ≥ 0.18 rad) and contact "
+                         "force collapses. Mimics inadequate grasp force.",
+    "velocity_spike":    "1-2 isolated frames with joint velocity MAD z-score > 6.5 rad/s, "
+                         "surrounded by normal motion. Mimics servo glitch or controller "
+                         "communication dropout.",
+    "torque_saturation": "One arm joint clamped at its angular limit for ≥ 3 consecutive frames "
+                         "with near-zero velocity. Mimics joint hitting mechanical stop or "
+                         "exceeding torque budget.",
+}
+
+
+def generate_readme(
+    robot:         str,
+    task:          str,
+    n_episodes:    int,
+    success_rate:  float,
+    force_min:     float,
+    force_max:     float,
+    failures:      List[str],
+    score:         float,
+    band:          str,
+    n_passed:      int,
+    n_flagged:     int,
+    mean_mismatch: float,
+    failure_breakdown: Dict[str, int],
+    scorer_used:   str,
+) -> str:
+    """Generate a complete README.md for the downloaded dataset."""
+
+    task_display   = task.replace("_", " ").title()
+    failures_list  = "\n".join(f"- **{f}**: {FAILURE_DESCRIPTIONS.get(f, f)}" for f in failures)
+    col_table_rows = "\n".join(
+        f"| `{col}` | {desc} |" for col, desc in COLUMN_DOCS.items()
+    )
+    fb_lines = "\n".join(f"- {k}: {v} episodes" for k, v in failure_breakdown.items()) or "- None"
+    generated_at   = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC")
+    band_emoji     = ""
+
+    return f"""# RoboGen Synthetic Dataset — {robot} / {task_display}
+
+> Generated by [HaptalAI RoboGen](https://huggingface.co/spaces/HaptalAI/robogen)
+> on {generated_at}
+
+---
+
+## Dataset Summary
+
+| Field | Value |
+|---|---|
+| Robot | **{robot}** |
+| Task | **{task_display}** |
+| Total episodes | **{n_episodes}** |
+| Success rate (configured) | **{success_rate * 100:.0f}%** |
+| Contact force range | **{force_min:.1f} – {force_max:.1f} N** |
+| Frames per episode | **50** (50 Hz, Δt = 0.02 s) |
+| Total rows | **{n_episodes * 50:,}** |
+
+---
+
+## Quality Score
+
+| Metric | Value |
+|---|---|
+| Overall score | **{score:.1f} / 100** |
+| Band | **{band}** |
+| Episodes passed | **{n_passed}** |
+| Episodes flagged | **{n_flagged}** |
+| Mean mismatch rate | **{mean_mismatch:.4f}** |
+| Scorer | `{scorer_used}` |
+
+**Quality bands:**
+- **Clean** (>= 80): suitable for policy training and augmentation
+- **Review** (55-79): usable with caution; inspect flagged episodes
+- **Flagged** (< 55): high anomaly rate; use for failure analysis only
+
+---
+
+## What the Dataset Contains
+
+This dataset contains **{n_episodes} synthetic episodes** of a **{robot}** robot performing
+the **{task_display}** task. Each episode is 50 frames (1 second at 50 Hz).
+
+**Episode composition:**
+- Success episodes (`use_for_training=True`): ~{success_rate * 100:.0f}% of total
+- Failure episodes: ~{(1 - success_rate) * 100:.0f}% of total
+
+### Failure types included
+{failures_list}
+
+### Failure breakdown in this dataset
+{fb_lines}
+
+---
+
+## Column Reference
+
+| Column | Description |
+|---|---|
+{col_table_rows}
+
+---
+
+## Physics Model
+
+Joint trajectories are generated using **cubic spline interpolation** over
+task-specific waypoints (approach → contact/grasp → lift/push → retract).
+Velocities are the **analytical first derivative** of the position spline — not
+independently sampled — ensuring physical consistency between state and action.
+
+- Sensor noise: Gaussian σ_pos = 0.002 rad, σ_vel = 0.004 rad/s
+- Contact force: spring-damper model during contact window (30–75% of episode)
+- Episode variation: small Gaussian perturbations on target position (±2.5 cm equivalent)
+- Joint limits: enforced per robot specification
+
+---
+
+## Recommended Use
+
+Synthetic data is best used for:
+1. **Policy bootstrapping** — pre-train before collecting real demonstrations
+2. **Augmentation** — mix with real data to increase diversity and robustness
+3. **Failure analysis / anomaly detection** — the labelled failure episodes are
+   especially useful for training or evaluating anomaly detectors
+4. **Simulation-to-real transfer research** — study domain gap with known ground truth
+
+> **Do not** rely solely on synthetic data for safety-critical deployments.
+> Always validate against real demonstrations before deploying to physical hardware.
+
+---
+
+## Validation & Benchmark
+
+This dataset was generated and validated by **HaptalAI's misalignment failure benchmark
+and physical failure scorer** — the same pipeline used to evaluate community SO-100
+datasets. Calibrated thresholds:
+- Velocity spike: MAD z-score > 6.5 rad/s
+- Mismatch fraction: > 0.50 per episode → flagged
+
+For questions, dataset requests, or benchmark access:
+**aarav@haptal.ai**
+
+---
+
+*RoboGen is open source. Star us on GitHub and contribute at
+[HaptalAI/robogen](https://github.com/aaravbedi/robogen).*
+"""

requirements.txt

@@ -0,0 +1,6 @@
+gradio==4.29.0
+numpy>=1.24.0,<2.0.0
+pandas>=2.0.0
+scipy>=1.11.0
+pyarrow>=12.0.0
+requests>=2.31.0

style.css

@@ -0,0 +1,525 @@
+/* ══════════════════════════════════════════════════════════
+   RoboGen — Dark SaaS UI
+   Reference: Claude.ai / Perplexity aesthetic
+   ══════════════════════════════════════════════════════════ */
+
+/* ── Base token overrides ─────────────────────────────────── */
+:root {
+  --bg-base:     #0a0a0f;
+  --bg-surface:  #111118;
+  --bg-card:     #16161f;
+  --bg-input:    #1d1d28;
+  --border:      #2a2a3d;
+  --border-focus:#6366f1;
+  --accent:      #6366f1;
+  --accent-dim:  #4f46e5;
+  --text-primary:#e2e8f0;
+  --text-muted:  #8892a4;
+  --text-faint:  #4a5568;
+  --green:       #22c55e;
+  --green-dim:   #166534;
+  --amber:       #f59e0b;
+  --amber-dim:   #78350f;
+  --red:         #ef4444;
+  --red-dim:     #7f1d1d;
+  --radius-sm:   8px;
+  --radius-md:   12px;
+  --radius-lg:   18px;
+}
+
+/* ── Gradio shell reset ───────────────────────────────────── */
+body, .gradio-container {
+  background: var(--bg-base) !important;
+  color: var(--text-primary) !important;
+  font-family: "Inter", system-ui, -apple-system, sans-serif !important;
+}
+
+.gradio-container {
+  max-width: 860px !important;
+  margin: 0 auto !important;
+  padding: 0 16px 80px !important;
+}
+
+footer { display: none !important; }
+
+/* ── Header ──────────────────────────────────────────────── */
+.rg-header {
+  text-align: center;
+  padding: 52px 0 36px;
+}
+
+.rg-logo {
+  font-size: 2.8rem;
+  font-weight: 800;
+  letter-spacing: -0.04em;
+  background: linear-gradient(135deg, #a5b4fc 0%, #818cf8 50%, #6366f1 100%);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+  display: inline-block;
+  margin-bottom: 6px;
+}
+
+.rg-tagline {
+  color: var(--text-muted);
+  font-size: 1rem;
+  letter-spacing: 0.01em;
+}
+
+.rg-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  margin-top: 14px;
+  padding: 5px 14px;
+  background: rgba(99, 102, 241, 0.12);
+  border: 1px solid rgba(99, 102, 241, 0.30);
+  border-radius: 999px;
+  font-size: 0.78rem;
+  color: #a5b4fc;
+  letter-spacing: 0.02em;
+}
+
+/* ── Step cards ──────────────────────────────────────────── */
+.step-card {
+  background: var(--bg-card) !important;
+  border: 1px solid var(--border) !important;
+  border-radius: var(--radius-lg) !important;
+  padding: 28px !important;
+  margin-bottom: 16px !important;
+  transition: border-color 0.2s ease;
+}
+
+.step-card:focus-within {
+  border-color: var(--border-focus) !important;
+}
+
+.step-header {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 22px;
+}
+
+.step-num {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  border-radius: 50%;
+  background: var(--accent);
+  color: #fff;
+  font-size: 0.8rem;
+  font-weight: 700;
+  flex-shrink: 0;
+}
+
+.step-title {
+  font-size: 1rem;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+/* ── Robot selection cards ───────────────────────────────── */
+/* Style Gradio's radio buttons as large click cards */
+.robot-radio .wrap {
+  display: flex !important;
+  gap: 12px !important;
+  flex-wrap: nowrap !important;
+}
+
+.robot-radio .wrap label {
+  flex: 1 !important;
+  min-width: 0 !important;
+  display: flex !important;
+  flex-direction: column !important;
+  align-items: center !important;
+  gap: 10px !important;
+  padding: 22px 12px !important;
+  background: var(--bg-input) !important;
+  border: 2px solid var(--border) !important;
+  border-radius: var(--radius-md) !important;
+  cursor: pointer !important;
+  transition: border-color 0.18s, background 0.18s, transform 0.12s !important;
+  color: var(--text-primary) !important;
+  font-size: 0.95rem !important;
+  font-weight: 600 !important;
+  text-align: center !important;
+  user-select: none !important;
+}
+
+.robot-radio .wrap label:hover {
+  border-color: var(--accent) !important;
+  transform: translateY(-2px) !important;
+}
+
+.robot-radio .wrap label:has(input:checked) {
+  border-color: var(--accent) !important;
+  background: rgba(99,102,241,0.12) !important;
+}
+
+.robot-radio .wrap input[type="radio"] {
+  display: none !important;
+}
+
+.robot-radio > .label-wrap { display: none !important; }
+
+/* Robot icons (first span inside label) */
+.robot-icon {
+  font-size: 2.2rem;
+  line-height: 1;
+}
+
+/* ── Dropdowns & Inputs ──────────────────────��──────────── */
+select, input[type="text"], input[type="email"], textarea, .gr-input {
+  background: var(--bg-input) !important;
+  border: 1px solid var(--border) !important;
+  border-radius: var(--radius-sm) !important;
+  color: var(--text-primary) !important;
+  font-size: 0.9rem !important;
+}
+
+select:focus, input:focus {
+  border-color: var(--border-focus) !important;
+  outline: none !important;
+  box-shadow: 0 0 0 3px rgba(99,102,241,0.15) !important;
+}
+
+/* Dropdown label */
+label.svelte-1b6s6g, .gr-label, .block label > span {
+  color: var(--text-muted) !important;
+  font-size: 0.82rem !important;
+  letter-spacing: 0.04em !important;
+  text-transform: uppercase !important;
+  font-weight: 600 !important;
+}
+
+/* ── Sliders ────────────────────────────────────────────── */
+input[type="range"] {
+  accent-color: var(--accent) !important;
+}
+
+/* ── Checkboxes ─────────────────────────────────────────── */
+.checkbox-group .wrap {
+  display: flex !important;
+  gap: 10px !important;
+  flex-wrap: wrap !important;
+}
+
+.checkbox-group label {
+  display: flex !important;
+  align-items: center !important;
+  gap: 8px !important;
+  padding: 8px 14px !important;
+  background: var(--bg-input) !important;
+  border: 1px solid var(--border) !important;
+  border-radius: 999px !important;
+  cursor: pointer !important;
+  color: var(--text-primary) !important;
+  font-size: 0.85rem !important;
+  font-weight: 500 !important;
+  transition: border-color 0.15s, background 0.15s !important;
+}
+
+.checkbox-group label:has(input:checked) {
+  border-color: var(--accent) !important;
+  background: rgba(99,102,241,0.12) !important;
+  color: #a5b4fc !important;
+}
+
+input[type="checkbox"] {
+  accent-color: var(--accent) !important;
+}
+
+/* ── Buttons ────────────────────────────────────────────── */
+.gr-button, button.gr-button {
+  border-radius: var(--radius-sm) !important;
+  font-weight: 600 !important;
+  font-size: 0.88rem !important;
+  padding: 10px 20px !important;
+  transition: all 0.15s ease !important;
+  border: none !important;
+  cursor: pointer !important;
+}
+
+.btn-primary {
+  background: var(--accent) !important;
+  color: #fff !important;
+}
+.btn-primary:hover {
+  background: var(--accent-dim) !important;
+  transform: translateY(-1px) !important;
+  box-shadow: 0 4px 20px rgba(99,102,241,0.35) !important;
+}
+
+.btn-generate {
+  width: 100% !important;
+  padding: 16px !important;
+  font-size: 1.05rem !important;
+  letter-spacing: 0.02em !important;
+  background: linear-gradient(135deg, #6366f1, #4f46e5) !important;
+  color: #fff !important;
+  border-radius: var(--radius-md) !important;
+  box-shadow: 0 4px 24px rgba(99,102,241,0.3) !important;
+}
+
+.btn-generate:hover {
+  box-shadow: 0 6px 30px rgba(99,102,241,0.45) !important;
+  transform: translateY(-2px) !important;
+}
+
+.btn-ghost {
+  background: transparent !important;
+  border: 1px solid var(--border) !important;
+  color: var(--text-muted) !important;
+}
+.btn-ghost:hover {
+  border-color: var(--border-focus) !important;
+  color: var(--text-primary) !important;
+}
+
+.btn-download {
+  width: 100% !important;
+  padding: 14px !important;
+  background: rgba(34,197,94,0.15) !important;
+  border: 1px solid rgba(34,197,94,0.4) !important;
+  color: var(--green) !important;
+  border-radius: var(--radius-md) !important;
+  font-size: 0.96rem !important;
+}
+.btn-download:hover {
+  background: rgba(34,197,94,0.25) !important;
+  border-color: var(--green) !important;
+}
+
+/* ── Results dashboard ──────────────────────────────────── */
+.rg-results {
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-lg);
+  padding: 32px;
+  font-family: "Inter", system-ui, sans-serif;
+}
+
+.rg-score-row {
+  display: flex;
+  align-items: center;
+  gap: 24px;
+  margin-bottom: 28px;
+}
+
+.rg-score-circle {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  width: 120px;
+  height: 120px;
+  border-radius: 50%;
+  flex-shrink: 0;
+  position: relative;
+}
+
+.rg-score-circle.clean {
+  background: radial-gradient(circle, rgba(34,197,94,0.15), rgba(34,197,94,0.05));
+  border: 3px solid var(--green);
+  box-shadow: 0 0 30px rgba(34,197,94,0.2);
+}
+
+.rg-score-circle.review {
+  background: radial-gradient(circle, rgba(245,158,11,0.15), rgba(245,158,11,0.05));
+  border: 3px solid var(--amber);
+  box-shadow: 0 0 30px rgba(245,158,11,0.2);
+}
+
+.rg-score-circle.flagged {
+  background: radial-gradient(circle, rgba(239,68,68,0.15), rgba(239,68,68,0.05));
+  border: 3px solid var(--red);
+  box-shadow: 0 0 30px rgba(239,68,68,0.2);
+}
+
+.rg-score-value {
+  font-size: 2.2rem;
+  font-weight: 800;
+  letter-spacing: -0.04em;
+  color: var(--text-primary);
+  line-height: 1;
+}
+
+.rg-score-denom {
+  font-size: 0.85rem;
+  color: var(--text-muted);
+  margin-top: 2px;
+}
+
+.rg-score-info {
+  flex: 1;
+}
+
+.rg-band-badge {
+  display: inline-block;
+  padding: 5px 14px;
+  border-radius: 999px;
+  font-size: 0.82rem;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  margin-bottom: 10px;
+}
+
+.rg-band-badge.clean   { background: rgba(34,197,94,0.15); color: var(--green); border: 1px solid rgba(34,197,94,0.4); }
+.rg-band-badge.review  { background: rgba(245,158,11,0.15); color: var(--amber); border: 1px solid rgba(245,158,11,0.4); }
+.rg-band-badge.flagged { background: rgba(239,68,68,0.15); color: var(--red); border: 1px solid rgba(239,68,68,0.4); }
+
+.rg-band-desc {
+  font-size: 0.88rem;
+  color: var(--text-muted);
+  line-height: 1.5;
+}
+
+.rg-stat-grid {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 12px;
+  margin-bottom: 24px;
+}
+
+.rg-stat {
+  background: var(--bg-input);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-md);
+  padding: 16px;
+  text-align: center;
+}
+
+.rg-stat-value {
+  font-size: 1.6rem;
+  font-weight: 700;
+  color: var(--text-primary);
+  line-height: 1;
+  margin-bottom: 4px;
+}
+
+.rg-stat-label {
+  font-size: 0.75rem;
+  color: var(--text-muted);
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
+.rg-failure-section {
+  margin-top: 20px;
+}
+
+.rg-failure-title {
+  font-size: 0.82rem;
+  font-weight: 600;
+  color: var(--text-muted);
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  margin-bottom: 10px;
+}
+
+.rg-failure-bar {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 8px;
+}
+
+.rg-failure-label {
+  font-size: 0.85rem;
+  color: var(--text-muted);
+  width: 160px;
+  flex-shrink: 0;
+}
+
+.rg-bar-track {
+  flex: 1;
+  height: 6px;
+  background: var(--border);
+  border-radius: 999px;
+  overflow: hidden;
+}
+
+.rg-bar-fill {
+  height: 100%;
+  border-radius: 999px;
+  background: var(--accent);
+}
+
+.rg-bar-count {
+  font-size: 0.82rem;
+  color: var(--text-muted);
+  width: 40px;
+  text-align: right;
+  flex-shrink: 0;
+}
+
+.rg-scorer-note {
+  margin-top: 18px;
+  font-size: 0.78rem;
+  color: var(--text-faint);
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+/* ── Tooltip helper ─────────────────────────────────────── */
+.tooltip-row {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  margin-top: 4px;
+}
+
+.tooltip-label {
+  font-size: 0.78rem;
+  color: var(--text-faint);
+  font-style: italic;
+  line-height: 1.4;
+}
+
+/* ── Progress & status ──────────────────────────────────── */
+.status-msg {
+  font-size: 0.88rem;
+  color: var(--text-muted);
+  min-height: 1.2em;
+}
+
+/* ── Email gate ─────────────────────────────────────────── */
+.email-gate-note {
+  font-size: 0.84rem;
+  color: var(--text-muted);
+  margin-bottom: 14px;
+  line-height: 1.5;
+}
+
+/* ── Mobile ──────────────────────────────────────────────── */
+@media (max-width: 600px) {
+  .robot-radio .wrap {
+    flex-direction: column !important;
+  }
+  .rg-stat-grid {
+    grid-template-columns: repeat(2, 1fr) !important;
+  }
+  .rg-score-row {
+    flex-direction: column !important;
+    align-items: flex-start !important;
+  }
+  .gradio-container {
+    padding: 0 10px 60px !important;
+  }
+}
+
+/* ── Gradio block chrome cleanup ────────────────────────── */
+.block.padded { padding: 0 !important; }
+.block { border: none !important; background: transparent !important; box-shadow: none !important; }
+.panel { background: transparent !important; }
+div.form { border: none !important; background: transparent !important; }
+.gr-prose { color: var(--text-primary) !important; }
+
+/* ── Hide default Gradio decorations ──────────────────────── */
+.hide-label > div > label { display: none !important; }
+.no-border { border: none !important; background: transparent !important; }