beautification, custom scripts loader, artefacts json to csv

README.md

@@ -2,8 +2,8 @@
 title: FFASR Leaderboard
 short_description: Far-Field ASR — clean / noisy / reverberant benchmark
 emoji: 🎙️
-colorFrom: indigo
-colorTo: pink
+colorFrom: teal
+colorTo: green
 sdk: gradio
 sdk_version: 5.29.0
 app_file: app.py

analytics.py

@@ -312,53 +312,56 @@ def plot_leaderboard_score_bars(
     return fig
 
 
+def _radar_absolute_value(row: pd.Series, axis: str) -> tuple[float, str]:
+    """Map a leaderboard row to an absolute 0–1 radar coordinate (higher = better)."""
+    if axis == "Dry Speech":
+        wer = pd.to_numeric(row.get("wer_anechoic_speech"), errors="coerce")
+        if not np.isfinite(wer):
+            return 0.0, "Dry speech WER: N/A"
+        v = float(max(0.0, min(1.0, 1.0 - float(wer))))
+        return v, f"Dry speech WER: {float(wer):.4f} → accuracy {v:.3f}"
+    if axis == "Score":
+        score = pd.to_numeric(row.get("ff_score"), errors="coerce")
+        if not np.isfinite(score):
+            return 0.0, "Far-field score: N/A"
+        v = float(max(0.0, min(1.0, float(score) / 100.0)))
+        return v, f"Far-field score: {float(score):.2f} / 100 → {v:.3f}"
+    if axis == "Speed":
+        rtf = pd.to_numeric(row.get("eval_rtf"), errors="coerce")
+        if not np.isfinite(rtf) or float(rtf) < 0:
+            return 0.0, "RTF: N/A"
+        r = float(rtf)
+        v = float(max(0.0, min(1.0, r / (1.0 + r))))
+        return v, f"RTF: {r:.4f}× → speed {v:.3f} (RTF/(1+RTF))"
+    if axis == "Compactness":
+        pm = pd.to_numeric(row.get("num_params_m"), errors="coerce")
+        if not np.isfinite(pm) or float(pm) < 0:
+            return 0.0, "Parameters: N/A"
+        p = float(pm)
+        v = float(max(0.0, min(1.0, 1.0 / (1.0 + p / 1000.0))))
+        return v, f"Parameters: {p:.2f} M → compactness {v:.3f}"
+    return 0.0, f"{axis}: N/A"
+
+
+_RADAR_ABSOLUTE_AXES: tuple[str, ...] = ("Dry Speech", "Score", "Speed", "Compactness")
+
+
 def plot_robustness_radar(
     df: pd.DataFrame,
     model_ids: Sequence[str],
-    title: str = "Robustness radar (relative strength; outward is better)",
+    title: str = "Robustness radar (absolute 0–1; outward is better)",
 ) -> go.Figure:
     """
-    Fixed-axis robustness radar: **strength** view (lines only, no fill).
-
-    Every axis is phrased so farther from the centre = better. WER and model
-    size / parameter count are inverted before normalisation; RTF is not.
-    Strength is a per-axis score computed across **all** leaderboard rows
-    with a log transform and global min/max, so axes are directly comparable
-    across models. Missing or invalid raw values map to a low baseline strength for display.
+    Four-axis radar with **absolute** coordinates in [0, 1] (not relative to other models).
 
-    The Compactness axis prefers `num_params_m` (recorded for every modern
-    eval) and falls back to `model_size_mb` only when params are unavailable;
-    the asterisk on the axis label flags that fallback in the chart.
+    Dry Speech = 1 − WER; Score = ff_score / 100; Speed = RTF / (1 + RTF);
+    Compactness = 1 / (1 + num_params_m / 1000). Missing values map to 0.
     """
     if df.empty:
         return _empty_fig("No leaderboard data yet.")
 
     d = df.copy().reset_index(drop=True)
-
-    axes: list[tuple[str, np.ndarray, np.ndarray, str, bool, str, str, bool]] = []
-    for label, primary, fallback, inverse, raw_disp, raw_unit in _RADAR_AXES:
-        col_label = label
-        col_name = primary
-        using_fallback = False
-        col = (
-            pd.to_numeric(d[primary], errors="coerce")
-            if primary in d.columns
-            else pd.Series([np.nan] * len(d))
-        )
-        if not col.notna().any() and fallback and fallback in d.columns:
-            col = pd.to_numeric(d[fallback], errors="coerce")
-            col_label = f"{label}*"
-            col_name = fallback
-            using_fallback = True
-            override = _RADAR_FALLBACK_DISPLAY.get(primary)
-            if override is not None:
-                raw_disp, raw_unit = override
-        strength = _log_normalize(col.to_numpy(), inverse=inverse)
-        axes.append(
-            (col_label, strength, col.to_numpy(), col_name, inverse, raw_disp, raw_unit, using_fallback)
-        )
-
-    labels = [a[0] for a in axes]
+    labels = list(_RADAR_ABSOLUTE_AXES)
     labels_closed = labels + [labels[0]]
 
     selected = [m for m in (model_ids or []) if m in set(d["model_id"])]
@@ -372,21 +375,13 @@ def plot_robustness_radar(
         rows = d.index[d["model_id"] == mid].tolist()
         if not rows:
             continue
-        idx = rows[0]
+        row = d.iloc[rows[0]]
         r_vals: list[float] = []
         raw_text: list[str] = []
-        for _lab, strength, raw_series, _src, inv, raw_disp, raw_unit, using_fb in axes:
-            s = strength[idx]
-            rv = raw_series[idx]
-            if np.isfinite(s):
-                r_vals.append(float(max(s, 0.1)))
-            else:
-                r_vals.append(0.1)
-            direction = "lower is better" if inv else "higher is better"
-            if not np.isfinite(rv):
-                raw_text.append(f"{raw_disp}: N/A ({direction})")
-            else:
-                raw_text.append(f"{raw_disp}: {rv:.4f}{raw_unit} ({direction})")
+        for ax in labels:
+            v, tip = _radar_absolute_value(row, ax)
+            r_vals.append(v)
+            raw_text.append(tip)
 
         r_closed = r_vals + [r_vals[0]]
         raw_closed = raw_text + [raw_text[0]]
@@ -405,7 +400,7 @@ def plot_robustness_radar(
                 opacity=1.0,
                 hovertemplate=(
                     f"<b>{short}</b><br>"
-                    "%{theta} strength: %{r:.2f}<br>"
+                    "%{theta}: %{r:.2f}<br>"
                     "%{customdata}<extra></extra>"
                 ),
             )
@@ -415,10 +410,10 @@ def plot_robustness_radar(
         polar=dict(
             radialaxis=dict(
                 visible=True,
-                range=[0.1, 1.0],
+                range=[0, 1],
                 showticklabels=True,
                 tickformat=".2f",
-                tickvals=[0.1, 0.25, 0.5, 0.75, 1.0],
+                tickvals=[0, 0.25, 0.5, 0.75, 1.0],
             ),
             angularaxis=dict(direction="clockwise", rotation=90),
         ),
@@ -696,56 +691,32 @@ def plot_latency_vs_wer(
         "num_params_m": "Parameters (millions)",
     }.get(x_key, x_key)
 
-    xs = d[x_key].to_numpy(dtype=float)
-    ys = d[y_metric_key].to_numpy(dtype=float)
-    mx_f = float(np.nanmedian(xs))
-    my_f = float(np.nanmedian(ys))
-
-    def _bucket(xv: float, yv: float) -> tuple[str, str]:
-        if x_key == "eval_rtf":
-            fast = xv >= mx_f
-        else:
-            fast = xv <= mx_f
-        accurate = yv <= my_f
-        if fast and accurate:
-            return "Fast · accurate", "#22c55e"
-        if fast and not accurate:
-            return "Fast · higher WER", "#3b82f6"
-        if not fast and accurate:
-            return "Slower · lower WER", "#f59e0b"
-        return "Slower · higher WER", "#ef4444"
-
-    buckets = [_bucket(float(a), float(b)) for a, b in zip(xs, ys)]
-    labels = [b[0] for b in buckets]
-
     fig = go.Figure()
-    for lab, color in (
-        ("Fast · accurate", "#22c55e"),
-        ("Fast · higher WER", "#3b82f6"),
-        ("Slower · lower WER", "#f59e0b"),
-        ("Slower · higher WER", "#ef4444"),
-    ):
-        idx = [i for i, lb in enumerate(labels) if lb == lab]
-        if not idx:
+    palette = qualitative.Alphabet * 3
+
+    for i, (_, row) in enumerate(d.iterrows()):
+        mid = str(row["model_id"])
+        short = mid.split("/")[-1][:28]
+        xv = pd.to_numeric(row[x_key], errors="coerce")
+        yv = pd.to_numeric(row[y_metric_key], errors="coerce")
+        if not (np.isfinite(xv) and np.isfinite(yv)):
             continue
+        color = palette[i % len(palette)]
         fig.add_trace(
             go.Scatter(
-                x=d.iloc[idx][x_key],
-                y=d.iloc[idx][y_metric_key],
+                x=[float(xv)],
+                y=[float(yv)],
                 mode="markers",
-                text=d.iloc[idx]["model_id"].str.split("/").str[-1].str[:28],
-                name=lab,
-                legendgroup=lab,
+                name=short,
+                legendgroup=mid,
                 marker=dict(size=11, opacity=0.9, color=color, line=dict(width=0.6, color="white")),
                 hovertemplate=(
-                    f"<b>%{{text}}</b><br>{lab}<br>{x_title}: %{{x:.4f}}<br>"
+                    f"<b>{mid}</b><br>{x_title}: %{{x:.4f}}<br>"
                     f"{y_label}: %{{y:.4f}}<extra></extra>"
                 ),
             )
         )
 
-    fig.add_vline(x=mx_f, line_dash="dot", line_color="rgba(0,0,0,0.25)")
-    fig.add_hline(y=my_f, line_dash="dot", line_color="rgba(0,0,0,0.25)")
     ttl = title or f"Speed versus accuracy: {y_label}"
     fig.update_layout(
         title=dict(text=ttl, x=0.5, xanchor="center"),
@@ -753,9 +724,9 @@ def plot_latency_vs_wer(
         yaxis=dict(title=y_label + " (lower is better)", rangemode="tozero"),
         template=_TEMPLATE,
         height=_FIG_HEIGHT,
-        margin=dict(l=60, r=40, t=60, b=60),
-        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+        margin=dict(l=60, r=120, t=60, b=60),
         showlegend=True,
+        **_plotly_legend_config(),
     )
     return fig
 

app.py

@@ -11,6 +11,7 @@ from constants import (
     INTRODUCTION_TEXT,
     LEADERBOARD_CSS,
     tab_label,
+    treble_gradio_theme,
 )
 import analytics
 from family_registry import default_family_id
@@ -46,9 +47,9 @@ MODEL_COL = AutoEvalColumn.model.name  # "Model"
 # Empty table at import; real data loaded on demo.load (avoids blocking Space "preparing").
 original_df = pd.DataFrame(columns=COLS)
 
-_QUEUE_STATUS_PLACEHOLDER = (
-    "<div class='queue-status' style='font-size:0.9em;opacity:0.85'>"
-    "<em>Loading queue status…</em></div>"
+_NEXT_UP_PLACEHOLDER = (
+    "<div class='next-up-panel' style='font-size:0.9em;opacity:0.85'>"
+    "<em>Loading upcoming evaluations…</em></div>"
 )
 
 # ---------------------------------------------------------------------------
@@ -126,7 +127,28 @@ def _wer_cell(row: dict, key: str) -> str:
     return str(v).strip()
 
 
-def submit_model(model_id: str, submission_notes: str) -> str:
+def _model_hub_page_link(model_id: str) -> str:
+    mid = (model_id or "").strip().replace(" ", "")
+    if not mid or "/" not in mid:
+        return (
+            "<p style='font-size:0.9em;opacity:0.85'>"
+            "Enter a model id (<code>author/name</code>) to open its Hub page.</p>"
+        )
+    url = f"https://huggingface.co/{mid}"
+    return (
+        f"<p style='font-size:0.9em'>"
+        f"<a href='{url}' target='_blank' rel='noopener noreferrer'>"
+        f"Open model page on the Hub</a> — request access if the repo is gated.</p>"
+    )
+
+
+def submit_model(
+    model_id: str,
+    submission_notes: str,
+    extra_requirements: str,
+    custom_script: str,
+    is_gated: bool,
+) -> str:
     """Validate and enqueue evaluation; a background worker runs approved jobs (up to 4 parallel Hub Jobs when remote mode is on).
 
     The backend always uses the "Auto" family (pipeline → Granite → universal → CTC),
@@ -156,9 +178,17 @@ def submit_model(model_id: str, submission_notes: str) -> str:
     if not on_hub:
         return styled_error(f"Model '{model_id}' {err_msg}")
 
-    job_id, position, err, awaiting_mod = job_queue.enqueue(
-        model_id, family_id, submission_notes=submission_notes or ""
-    )
+    try:
+        job_id, position, err, awaiting_mod = job_queue.enqueue(
+            model_id,
+            family_id,
+            submission_notes=submission_notes or "",
+            extra_requirements=extra_requirements or "",
+            custom_script=custom_script or "",
+            is_gated=bool(is_gated),
+        )
+    except Exception as exc:
+        return styled_warning(f"Could not enqueue submission: {exc}")
     if err == "remote_jobs_required":
         return styled_error(
             "Hub Jobs are required. Set Space secrets "
@@ -289,15 +319,7 @@ def _analytics_apply(models, line_keys, top_n, latency_x, latency_y):
 # Gradio App
 # ---------------------------------------------------------------------------
 
-_theme = gr.themes.Soft(
-    primary_hue="indigo",
-    secondary_hue="blue",
-    neutral_hue="slate",
-).set(
-    button_primary_background_fill="*primary_500",
-    button_primary_background_fill_hover="*primary_400",
-    block_radius="12px",
-)
+_theme = treble_gradio_theme()
 
 with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
     gr.HTML(BANNER, elem_id="banner")
@@ -342,7 +364,7 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                     return original_df
 
             def _on_startup():
-                """Load leaderboard + queue after UI is up (keeps Space prepare step fast)."""
+                """Load leaderboard + next-up list after UI is up (keeps Space prepare step fast)."""
                 global original_df
                 from init import invalidate_results_cache
 
@@ -352,20 +374,19 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                     table = filter_main_table("", toggleable_columns)
                 except Exception as exc:
                     table = original_df
-                    queue_html = (
-                        "<div class='queue-status'><p style='color:orange'>"
+                    next_html = (
+                        "<div class='next-up-panel'><p style='color:orange'>"
                         f"<strong>Startup warning:</strong> {exc}</p></div>"
                     )
-                    return table, queue_html
+                    return table, next_html
                 try:
                     job_queue.ensure_worker_started()
-                    queue_html = job_queue.status_html()
+                    next_html = job_queue.next_up_html()
                 except Exception as exc:
-                    queue_html = (
-                        "<div class='queue-status'><p style='color:orange'>"
-                        f"<strong>Queue unavailable:</strong> {exc}</p></div>"
-                    )
-                return table, queue_html
+                    next_html = (
+                        "<div class='next-up-panel'><p style='color:orange'>"
+                        f"<strong>Queue unavailable:</strong> {exc}</p></motionmotionmotionmotiondiv>")
+                return table, next_html
 
             filter_inputs = [search_box, column_checkboxes]
             search_box.change(filter_main_table, inputs=filter_inputs, outputs=leaderboard_table)
@@ -396,30 +417,55 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                 )
                 submit_btn = gr.Button("Evaluate", variant="primary", scale=1)
 
-            submission_notes = gr.Textbox(
-                label="Optional notes for moderators",
-                placeholder="Repo link, paper, eval caveats, hardware notes…",
+            requirements_input = gr.Textbox(
+                label="Optional extra Python requirements (one per line, requirements.txt format)",
+                placeholder="transformers @ git+https://github.com/huggingface/transformers.git\nsentencepiece",
                 lines=4,
-                max_length=4000,
+                max_length=8000,
+            )
+            script_input = gr.Code(
+                label="Optional custom uv-run script (only run if a moderator approves it)",
+                language="python",
+                lines=12,
             )
             gr.Markdown(
-                "**Custom evaluation code is not run** on this Space (security). "
-                "Notes are stored with the submission for reviewers only. "
-                "To propose a different metric or pipeline, open an issue or PR against the leaderboard repo."
+                "Custom scripts are **not** executed on this Space. They are stored with your submission "
+                "and run on a Hub Job **only** after a moderator explicitly approves using that script."
+            )
+            with gr.Row():
+                is_gated_input = gr.Checkbox(label="This is a gated repo", value=False)
+            gated_link = gr.HTML(value=_model_hub_page_link(""))
+            model_input.change(fn=_model_hub_page_link, inputs=[model_input], outputs=[gated_link])
+            notes_input = gr.Textbox(
+                label="Optional free-form notes for moderators",
+                placeholder="Repo link, paper, eval caveats, hardware notes…",
+                lines=2,
+                max_length=4000,
             )
 
             status_output = gr.HTML()
-            with gr.Row():
-                gr.Markdown("### Queue status")
-                queue_refresh_btn = gr.Button("Refresh", scale=0, min_width=100)
-            queue_panel = gr.HTML(value=_QUEUE_STATUS_PLACEHOLDER, elem_classes="queue-status")
+            gr.Markdown("### Next models to evaluate")
+            next_up_panel = gr.HTML(value=_NEXT_UP_PLACEHOLDER, elem_classes="next-up-panel")
+
+            def _submit_and_refresh(model_id, notes, reqs, script, gated):
+                status = submit_model(model_id, notes, reqs, script, gated)
+                try:
+                    nxt = job_queue.next_up_html()
+                except Exception as exc:
+                    nxt = f"<p style='color:orange'>Could not load queue: {exc}</p>"
+                return status, nxt
 
             submit_btn.click(
-                fn=submit_model,
-                inputs=[model_input, submission_notes],
-                outputs=[status_output],
+                fn=_submit_and_refresh,
+                inputs=[
+                    model_input,
+                    notes_input,
+                    requirements_input,
+                    script_input,
+                    is_gated_input,
+                ],
+                outputs=[status_output, next_up_panel],
             )
-            queue_refresh_btn.click(fn=job_queue.status_html, outputs=[queue_panel])
 
         with gr.TabItem(tab_label("moderate", "Moderate"), elem_id="moderate-tab", id=2):
             gr.Markdown("## Moderator access")
@@ -446,40 +492,56 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                 )
                 mod_refresh = gr.Button("Refresh pending list")
                 pending_table = gr.HTML(value=job_queue.moderation_locked_placeholder_html())
-                gr.Markdown("### Recent job activity (status, errors, timestamps)")
-                mod_recent_jobs = gr.HTML(value=job_queue.moderation_locked_placeholder_html())
+                gr.Markdown("### Recent job activity")
                 gr.Markdown(
-                    "**Retry / remove:** pick a job below. **Retry** re-queues **failed** jobs only. "
-                    "**Remove** drops a job from this list (not allowed while **running**)."
-                )
-                mod_action_job = gr.Dropdown(
-                    label="Job for retry or remove",
-                    choices=[("(Unlock required)", "")],
-                    value=None,
+                    "**Retry** re-queues **failed** jobs only. **Remove** drops a job from this list "
+                    "(not allowed while **running**)."
                 )
-                with gr.Row():
-                    retry_job_btn = gr.Button("Retry selected job", variant="secondary")
-                    remove_job_btn = gr.Button("Remove from list", variant="stop")
+                mod_jobs_tick = gr.State(0)
                 job_pick = gr.Dropdown(
                     label="Select a pending job (approve / reject)",
                     choices=[("(Unlock required)", "")],
                     value=None,
                 )
+                mod_run_custom_script = gr.Checkbox(
+                    label="Run submitter's custom script on approval (if provided)",
+                    value=False,
+                )
                 with gr.Row():
                     approve_btn = gr.Button("Approve selected job", variant="primary")
                     reject_btn = gr.Button("Reject selected job", variant="stop")
+                gr.Markdown("### Import result from bucket artifact")
+                gr.Markdown(
+                    "If a Hub Job finished but the leaderboard CSV was not updated, paste the artifact "
+                    "file name from <code>results/remote_artifacts/</code> (e.g. <code>a1b2c3d4.json</code>) "
+                    "to merge WER/RTF into the CSV. The far-field score is computed automatically."
+                )
+                mod_artifact_ref = gr.Textbox(
+                    label="Artifact JSON file name or bucket path",
+                    placeholder="e.g. a1b2c3d4.json or results/remote_artifacts/a1b2c3d4.json",
+                )
+                mod_replace_existing = gr.Checkbox(
+                    label="Replace existing leaderboard row for this model",
+                    value=False,
+                )
+                mod_import_notes = gr.Textbox(
+                    label="Optional submission notes override",
+                    placeholder="Leave empty to use notes from the matched queue job, if any",
+                    lines=1,
+                    max_length=4000,
+                )
+                import_artifact_btn = gr.Button("Import artifact to CSV", variant="secondary")
                 mod_feedback = gr.HTML()
 
             _MOD_OUTS = [
                 mod_feedback,
                 pending_table,
                 job_pick,
-                mod_recent_jobs,
-                mod_action_job,
+                mod_jobs_tick,
                 mod_progress,
             ]
 
-            def _mod_refresh_data():
+            def _mod_refresh_core():
                 try:
                     return (
                         job_queue.moderation_list_html(),
@@ -487,11 +549,6 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                             choices=job_queue.pending_job_dropdown_choices(),
                             value=None,
                         ),
-                        job_queue.recent_jobs_html(30, with_heading=False),
-                        gr.update(
-                            choices=job_queue.moderation_action_job_choices(),
-                            value=None,
-                        ),
                         job_queue.progress_html(),
                     )
                 except Exception as e:
@@ -502,91 +559,150 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                     return (
                         msg,
                         gr.update(choices=[("(Queue unavailable)", "")], value=None),
-                        job_queue.recent_jobs_html(30, with_heading=False),
-                        gr.update(choices=[("(Queue unavailable)", "")], value=None),
                         msg,
                     )
 
-            def _mod_refresh(secret: str, unlocked: bool):
+            def _mod_refresh_data(tick: int):
+                pending, pick, progress = _mod_refresh_core()
+                return pending, pick, int(tick or 0) + 1, progress
+
+            def _mod_locked_tuple(tick: int):
+                ph = job_queue.moderation_locked_placeholder_html()
+                return ph, gr.update(choices=[("(Unlock required)", "")], value=None), int(tick or 0), ph
+
+            def _mod_refresh(secret: str, unlocked: bool, tick: int):
                 if not unlocked:
-                    return (
-                        job_queue.moderation_locked_placeholder_html(),
-                        gr.update(choices=[("(Unlock required)", "")], value=None),
-                        job_queue.moderation_locked_placeholder_html(),
-                        gr.update(choices=[("(Unlock required)", "")], value=None),
-                        job_queue.moderation_locked_placeholder_html(),
-                    )
+                    return _mod_locked_tuple(tick)
                 ok, msg = job_queue.verify_moderator_secret(secret)
                 if not ok:
                     return (
                         f"<p style='color:red'>{msg}</p>",
                         gr.update(choices=[("(Invalid secret)", "")], value=None),
-                        job_queue.moderation_locked_placeholder_html(),
-                        gr.update(choices=[("(Invalid secret)", "")], value=None),
+                        int(tick or 0),
                         job_queue.moderation_locked_placeholder_html(),
                     )
-                return _mod_refresh_data()
+                return _mod_refresh_data(tick)
 
-            def _mod_bundle(note_html: str):
-                data = _mod_refresh_data()
-                return (note_html, *data)
+            def _mod_bundle(note_html: str, tick: int):
+                pending, pick, new_tick, progress = _mod_refresh_data(tick)
+                return note_html, pending, pick, new_tick, progress
 
-            def _mod_run(fn, secret, jid, empty_msg: str, unlocked: bool):
-                if not unlocked:
-                    return _mod_bundle("<p style='color:red'>Unlock moderator tools first.</p>")
-                if not jid or not str(jid).strip():
-                    return _mod_bundle(f"<p style='color:red'>{empty_msg}</p>")
-                ok, msg = fn(jid, secret)
+            def _mod_row_action(secret: str, jid: str, tick: int, action_fn):
+                ok, msg = action_fn(jid, secret)
                 color = "green" if ok else "red"
-                return _mod_bundle(f"<p style='color:{color}'>{msg}</p>")
+                return _mod_bundle(f"<p style='color:{color}'>{msg}</p>", tick)
 
-            def _mod_unlock(secret: str):
+            def _mod_unlock(secret: str, tick: int):
                 ok, msg = job_queue.verify_moderator_secret(secret)
                 if not ok:
+                    ph = job_queue.moderation_locked_placeholder_html()
                     return (
                         False,
                         gr.update(visible=False),
                         f"<p style='color:red'>{msg}</p>",
-                        *(
-                            job_queue.moderation_locked_placeholder_html(),
-                            gr.update(choices=[("(Unlock required)", "")], value=None),
-                            job_queue.moderation_locked_placeholder_html(),
-                            gr.update(choices=[("(Unlock required)", "")], value=None),
-                            job_queue.moderation_locked_placeholder_html(),
-                        ),
+                        ph,
+                        gr.update(choices=[("(Unlock required)", "")], value=None),
+                        int(tick or 0),
+                        ph,
                     )
                 try:
-                    data = _mod_refresh_data()
+                    pending, pick, new_tick, progress = _mod_refresh_data(tick)
                 except Exception as e:
-                    data = (
-                        f"<p style='color:orange'><strong>Queue unavailable:</strong> {e}</p>",
-                        gr.update(choices=[("(Queue unavailable)", "")], value=None),
-                        job_queue.recent_jobs_html(30, with_heading=False),
-                        gr.update(choices=[("(Queue unavailable)", "")], value=None),
-                        f"<p style='color:orange'><strong>Queue unavailable:</strong> {e}</p>",
-                    )
+                    pending = f"<p style='color:orange'><strong>Queue unavailable:</strong> {e}</p>"
+                    pick = gr.update(choices=[("(Queue unavailable)", "")], value=None)
+                    new_tick = int(tick or 0) + 1
+                    progress = pending
                 return (
                     True,
                     gr.update(visible=True),
                     "<p style='color:green'>Moderator tools unlocked for this session.</p>",
-                    *data,
+                    pending,
+                    pick,
+                    new_tick,
+                    progress,
                 )
 
-            def _mod_approve(secret, jid, unlocked):
-                return _mod_run(job_queue.approve_job, secret, jid, "Select a job.", unlocked)
+            def _mod_approve(secret, jid, unlocked, run_custom, tick):
+                if not unlocked:
+                    return _mod_bundle("<p style='color:red'>Unlock moderator tools first.</p>", tick)
+                if not jid or not str(jid).strip():
+                    return _mod_bundle("<p style='color:red'>Select a job.</p>", tick)
 
-            def _mod_reject(secret, jid, unlocked):
-                return _mod_run(job_queue.reject_job, secret, jid, "Select a job.", unlocked)
+                def _approve(j, s):
+                    return job_queue.approve_job(j, s, run_custom_script=bool(run_custom))
 
-            def _mod_retry(secret, jid, unlocked):
-                return _mod_run(
-                    job_queue.retry_failed_job, secret, jid, "Select a job in Retry / remove.", unlocked
-                )
+                return _mod_row_action(secret, str(jid).strip(), tick, _approve)
+
+            def _mod_reject(secret, jid, unlocked, tick):
+                if not unlocked:
+                    return _mod_bundle("<p style='color:red'>Unlock moderator tools first.</p>", tick)
+                if not jid or not str(jid).strip():
+                    return _mod_bundle("<p style='color:red'>Select a job.</p>", tick)
+                return _mod_row_action(secret, str(jid).strip(), tick, job_queue.reject_job)
 
-            def _mod_remove(secret, jid, unlocked):
-                return _mod_run(
-                    job_queue.remove_job_entry, secret, jid, "Select a job in Retry / remove.", unlocked
+            def _mod_import_artifact(
+                secret, artifact_ref, replace_existing, import_notes, unlocked, tick
+            ):
+                if not unlocked:
+                    return _mod_bundle("<p style='color:red'>Unlock moderator tools first.</p>", tick)
+                ok, msg = job_queue.import_artifact_to_leaderboard(
+                    artifact_ref,
+                    secret,
+                    replace_existing=bool(replace_existing),
+                    submission_notes=import_notes or "",
                 )
+                color = "green" if ok else "red"
+                return _mod_bundle(f"<p style='color:{color}'>{msg}</p>", tick)
+
+            @gr.render(inputs=[mod_unlocked, mod_secret, mod_jobs_tick])
+            def _render_job_activity_rows(unlocked: bool, secret: str, tick: int):
+                if not unlocked:
+                    gr.Markdown("*Unlock moderator tools to see job activity.*")
+                    return
+                try:
+                    rows = job_queue.recent_jobs_for_render(30)
+                except Exception as e:
+                    gr.Markdown(f"*Queue unavailable: {e}*")
+                    return
+                if not rows:
+                    gr.Markdown("*No job history yet.*")
+                    return
+                for row in rows:
+                    jid = row["id"]
+                    hub = row.get("hub_link_html") or ""
+                    hub_bit = f" · {hub}" if hub else ""
+                    script_bit = " · custom script" if row.get("has_custom_script") else ""
+                    summary = (
+                        f"**{row['model_id']}** — `{row['status']}` "
+                        f"(job `{jid}`, {row['updated_at']}){script_bit}{hub_bit}"
+                    )
+                    if row.get("error"):
+                        summary += f"\n\n`{row['error']}`"
+                    with gr.Row():
+                        gr.Markdown(summary, scale=4)
+                        retry_b = gr.Button(
+                            "Retry",
+                            variant="secondary",
+                            scale=0,
+                            min_width=90,
+                            interactive=bool(row.get("can_retry")),
+                        )
+                        remove_b = gr.Button(
+                            "Remove",
+                            variant="stop",
+                            scale=0,
+                            min_width=90,
+                            interactive=bool(row.get("can_remove")),
+                        )
+
+                        def _retry_fn(s=secret, j=jid, t=tick):
+                            return _mod_row_action(s, j, t, job_queue.retry_failed_job)
+
+                        def _remove_fn(s=secret, j=jid, t=tick):
+                            return _mod_row_action(s, j, t, job_queue.remove_job_entry)
+
+                        retry_b.click(fn=_retry_fn, outputs=_MOD_OUTS)
+                        remove_b.click(fn=_remove_fn, outputs=_MOD_OUTS)
 
             def _mod_progress_gated(unlocked: bool):
                 if not unlocked:
@@ -595,47 +711,42 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
 
             mod_unlock_btn.click(
                 fn=_mod_unlock,
-                inputs=[mod_secret],
+                inputs=[mod_secret, mod_jobs_tick],
                 outputs=[
                     mod_unlocked,
                     mod_panel,
                     mod_unlock_feedback,
                     pending_table,
                     job_pick,
-                    mod_recent_jobs,
-                    mod_action_job,
+                    mod_jobs_tick,
                     mod_progress,
                 ],
             )
             mod_refresh.click(
                 fn=_mod_refresh,
-                inputs=[mod_secret, mod_unlocked],
-                outputs=[
-                    pending_table,
-                    job_pick,
-                    mod_recent_jobs,
-                    mod_action_job,
-                    mod_progress,
-                ],
+                inputs=[mod_secret, mod_unlocked, mod_jobs_tick],
+                outputs=[pending_table, job_pick, mod_jobs_tick, mod_progress],
             )
             approve_btn.click(
                 fn=_mod_approve,
-                inputs=[mod_secret, job_pick, mod_unlocked],
+                inputs=[mod_secret, job_pick, mod_unlocked, mod_run_custom_script, mod_jobs_tick],
                 outputs=_MOD_OUTS,
             )
             reject_btn.click(
                 fn=_mod_reject,
-                inputs=[mod_secret, job_pick, mod_unlocked],
+                inputs=[mod_secret, job_pick, mod_unlocked, mod_jobs_tick],
                 outputs=_MOD_OUTS,
             )
-            retry_job_btn.click(
-                fn=_mod_retry,
-                inputs=[mod_secret, mod_action_job, mod_unlocked],
-                outputs=_MOD_OUTS,
-            )
-            remove_job_btn.click(
-                fn=_mod_remove,
-                inputs=[mod_secret, mod_action_job, mod_unlocked],
+            import_artifact_btn.click(
+                fn=_mod_import_artifact,
+                inputs=[
+                    mod_secret,
+                    mod_artifact_ref,
+                    mod_replace_existing,
+                    mod_import_notes,
+                    mod_unlocked,
+                    mod_jobs_tick,
+                ],
                 outputs=_MOD_OUTS,
             )
 
@@ -647,10 +758,10 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
                 "(weighted harmonic mean of 1/(1+WER); higher is better).\n\n"
                 "**WER heatmap** shows WER by model and scenario for the top N models (sorted by score); lower WER "
                 "corresponds to greener cells.\n\n"
-                "**Speed versus accuracy** compares an inference or scale metric on the horizontal axis with "
-                "WER on the vertical axis to illustrate accuracy and compute trade-offs.\n\n"
-                "**Robustness radar** summarizes relative strength across scenarios plus speed (RTF) and model "
-                "size; outward distance indicates stronger relative performance on each axis.\n\n"
+                "**Speed versus accuracy** colors each model by name (toggle in the legend) on an inference or "
+                "scale metric versus WER.\n\n"
+                "**Robustness radar** uses absolute axes from 0 to 1: **Dry Speech** (1 − WER), **Score** "
+                "(far-field / 100), **Speed** (RTF / (1 + RTF)), and **Compactness** (1 / (1 + params_M / 1000)).\n\n"
                 "**WER by scenario** compares raw WER across conditions for the selected top models."
             )
             with gr.Row():
@@ -740,12 +851,12 @@ with gr.Blocks(title=APP_TITLE, theme=_theme, css=LEADERBOARD_CSS) as demo:
     # Periodic queue refresh (Timer added in Gradio 4.44). Avoid demo.load(..., every=); unsupported on some builds.
     if hasattr(gr, "Timer"):
         with gr.Row(visible=False):
-            _queue_timer = gr.Timer(5)
+            _next_up_timer = gr.Timer(15)
             _progress_timer = gr.Timer(2)
-        _queue_timer.tick(fn=job_queue.status_html, outputs=[queue_panel])
+        _next_up_timer.tick(fn=job_queue.next_up_html, outputs=[next_up_panel])
         _progress_timer.tick(fn=_mod_progress_gated, inputs=[mod_unlocked], outputs=[mod_progress])
 
-    demo.load(fn=_on_startup, outputs=[leaderboard_table, queue_panel])
+    demo.load(fn=_on_startup, outputs=[leaderboard_table, next_up_panel])
     demo.load(
         fn=_analytics_initial,
         outputs=[

backends/auto.py

@@ -108,8 +108,16 @@ def build_transcriber(
     except Exception as e:
         _record_error("universal", e)
 
+    # CTC only applies to wav2vec/hubert-style checkpoints; skip when config says seq2seq.
     try:
-        return transformers_ctc.build_transcriber(model_id, device_str)
+        from .family_resolve import infer_model_type
+
+        mt = infer_model_type(model_id)
+        _ctc_skip_types = frozenset(
+            {"cohere_asr", "whisper", "granite_speech", "speech_to_text", "moonshine_streaming"}
+        )
+        if mt not in _ctc_skip_types:
+            return transformers_ctc.build_transcriber(model_id, device_str)
     except Exception as e:
         _record_error("ctc", e)
 

backends/family_resolve.py

@@ -0,0 +1,61 @@
+"""
+Resolve ``family_id='auto'`` using Hub ``config.json`` ``model_type`` when possible.
+
+Avoids running the full auto cascade (pipeline → universal → CTC) for models that
+need a specific loader (e.g. Cohere ASR is seq2seq remote code, not CTC).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+# model_type (config.json) -> backend family id
+_MODEL_TYPE_TO_FAMILY: dict[str, str] = {
+    "granite_speech": "granite_speech",
+    "cohere_asr": "universal",
+}
+
+# Extra uv/pip packages commonly required by remote-code checkpoints (not always declared on Hub).
+_MODEL_TYPE_EXTRA_DEPS: dict[str, list[str]] = {
+    "cohere_asr": ["sentencepiece"],
+}
+
+
+def infer_model_type(model_id: str) -> str:
+    """Read ``model_type`` from the Hub ``config.json`` without loading weights."""
+    try:
+        from huggingface_hub import hf_hub_download
+
+        token = os.environ.get("HF_TOKEN") or os.environ.get("ds_token")
+        path = hf_hub_download(
+            repo_id=model_id,
+            filename="config.json",
+            token=token,
+        )
+        with open(path, encoding="utf-8") as f:
+            cfg = json.load(f)
+        return str(cfg.get("model_type", "") or "")
+    except Exception:
+        return ""
+
+
+def extra_deps_for_model(model_id: str) -> list[str]:
+    """Optional packages implied by ``model_type`` (for uv job dependency lists)."""
+    mt = infer_model_type(model_id)
+    return list(_MODEL_TYPE_EXTRA_DEPS.get(mt, []))
+
+
+def resolve_auto_family(model_id: str, family_id: str) -> str:
+    """
+    If ``family_id`` is ``auto``, map known ``model_type`` values to a concrete backend.
+    Otherwise normalize aliases and return unchanged.
+    """
+    from family_registry import _FAMILY_ALIASES
+
+    fid = (family_id or "auto").strip().lower()
+    fid = _FAMILY_ALIASES.get(fid, fid)
+    if fid != "auto":
+        return fid
+    mt = infer_model_type(model_id)
+    return _MODEL_TYPE_TO_FAMILY.get(mt, "auto")

backends/registry.py

@@ -43,7 +43,9 @@ def build_transcriber(
         universal,
     )
 
-    fid = _FAMILY_ALIASES.get(family_id, family_id)
+    from .family_resolve import resolve_auto_family
+
+    fid = resolve_auto_family(model_id, _FAMILY_ALIASES.get(family_id, family_id))
     if fid == "auto":
         return auto.build_transcriber(model_id, device_str, device_int)
     if fid == "transformers_pipeline":

constants.py

@@ -197,6 +197,71 @@ AUDIO_CONDITIONS = {
     "reverberant": {"folder": "wavs", "label": "WER Reverberant"},
 }
 
+# Treble brand palette (dark UI — teal accent instead of purple/indigo)
+TREBLE_TEAL = "#38BFA1"
+TREBLE_TEAL_RGB = "56, 191, 161"
+TREBLE_MINT = "#3DFFA3"
+TREBLE_CYAN = "#2D9BF0"
+TREBLE_BG = "#121212"
+TREBLE_SURFACE = "#1A1A1E"
+TREBLE_BORDER = "rgba(160, 160, 160, 0.18)"
+TREBLE_TEXT_MUTED = "#A0A0A0"
+
+
+def treble_gradio_theme():
+    """Dark Gradio theme with Treble teal primary (replaces indigo/purple)."""
+    import gradio as gr
+
+    treble_primary = gr.themes.colors.Color(
+        name="treble",
+        c50="#e8faf6",
+        c100="#c5f0e8",
+        c200="#9ae4d4",
+        c300="#6fd7c0",
+        c400="#52cdb0",
+        c500=TREBLE_TEAL,
+        c600="#2da88a",
+        c700="#238a72",
+        c800="#1a6c5a",
+        c900="#124e43",
+        c950="#0a3029",
+    )
+    return (
+        gr.themes.Base(
+            primary_hue=treble_primary,
+            secondary_hue="cyan",
+            neutral_hue="gray",
+        )
+        .set(
+            body_background_fill=TREBLE_BG,
+            body_background_fill_dark=TREBLE_BG,
+            block_background_fill=TREBLE_SURFACE,
+            block_background_fill_dark=TREBLE_SURFACE,
+            block_border_color=f"rgba({TREBLE_TEAL_RGB}, 0.14)",
+            block_border_color_dark=f"rgba({TREBLE_TEAL_RGB}, 0.14)",
+            border_color_primary=f"rgba({TREBLE_TEAL_RGB}, 0.22)",
+            border_color_primary_dark=f"rgba({TREBLE_TEAL_RGB}, 0.22)",
+            color_accent=TREBLE_TEAL,
+            color_accent_soft=f"rgba({TREBLE_TEAL_RGB}, 0.14)",
+            link_text_color=TREBLE_TEAL,
+            link_text_color_hover=TREBLE_MINT,
+            link_text_color_active=TREBLE_CYAN,
+            link_text_color_dark=TREBLE_TEAL,
+            link_text_color_hover_dark=TREBLE_MINT,
+            button_primary_background_fill="*primary_500",
+            button_primary_background_fill_hover="*primary_400",
+            button_primary_text_color="#0d1412",
+            button_primary_text_color_hover="#0d1412",
+            button_large_radius="999px",
+            button_medium_radius="999px",
+            button_small_radius="999px",
+            block_radius="12px",
+            input_background_fill="#141418",
+            input_background_fill_dark="#141418",
+        )
+    )
+
+
 LEADERBOARD_CSS = """
 /* Hide Gradio footer logo */
 footer { display: none !important; }
@@ -205,7 +270,7 @@ footer { display: none !important; }
 .ffasr-banner {
     text-align: center;
     padding: 1.4rem 0 0.8rem 0;
-    border-bottom: 1px solid var(--border-color-primary, rgba(120, 120, 120, 0.18));
+    border-bottom: 1px solid var(--border-color-primary, rgba(160, 160, 160, 0.18));
     margin-bottom: 0.6rem;
 }
 .ffasr-banner h1 {
@@ -214,7 +279,7 @@ footer { display: none !important; }
     margin: 0;
     font-weight: 800;
     letter-spacing: -0.02em;
-    background: linear-gradient(90deg, #4c8bf5 0%, #7c3aed 55%, #ec4899 100%);
+    background: linear-gradient(90deg, __TREBLE_TEAL__ 0%, __TREBLE_CYAN__ 52%, __TREBLE_MINT__ 100%);
     -webkit-background-clip: text;
     background-clip: text;
     -webkit-text-fill-color: transparent;
@@ -224,6 +289,7 @@ footer { display: none !important; }
     margin-top: 0.35rem;
     font-size: 1rem;
     opacity: 0.72;
+    color: __TREBLE_TEXT_MUTED__;
 }
 .ffasr-badges {
     margin-top: 0.7rem;
@@ -236,9 +302,9 @@ footer { display: none !important; }
     font-size: 0.78rem;
     padding: 0.18rem 0.65rem;
     border-radius: 999px;
-    background: rgba(76, 139, 245, 0.12);
-    color: #4c8bf5;
-    border: 1px solid rgba(76, 139, 245, 0.30);
+    background: rgba(__TREBLE_TEAL_RGB__, 0.12);
+    color: __TREBLE_TEAL__;
+    border: 1px solid rgba(__TREBLE_TEAL_RGB__, 0.32);
     font-weight: 500;
     letter-spacing: 0.01em;
 }
@@ -251,8 +317,9 @@ footer { display: none !important; }
     font-weight: 500 !important;
 }
 .tab-buttons button.selected {
-    border-bottom: 2px solid #4c8bf5 !important;
-    background: var(--block-background-fill, #fafbfd) !important;
+    border-bottom: 2px solid __TREBLE_TEAL__ !important;
+    background: var(--block-background-fill, __TREBLE_SURFACE__) !important;
+    color: __TREBLE_TEAL__ !important;
 }
 
 /* ---- Leaderboard table ---- */
@@ -274,18 +341,31 @@ footer { display: none !important; }
     table-layout: auto !important;
 }
 #leaderboard-table tbody tr:hover td {
-    background: rgba(76, 139, 245, 0.06);
+    background: rgba(__TREBLE_TEAL_RGB__, 0.08);
 }
 
 /* ---- Card-like panels ---- */
 .queue-status,
+.next-up-panel,
 .ffasr-card {
     padding: 0.8rem 1rem;
     border-radius: 12px;
-    background: var(--block-background-fill, #fafbfd);
-    border: 1px solid var(--border-color-primary, rgba(120, 120, 120, 0.15));
+    background: var(--block-background-fill, __TREBLE_SURFACE__);
+    border: 1px solid var(--border-color-primary, rgba(__TREBLE_TEAL_RGB__, 0.15));
+}
+.queue-status p,
+.next-up-panel p { margin: 0.15rem 0; }
+
+/* ---- Links (markdown, footnote) ---- */
+.markdown-text a,
+.ffasr-footnote a {
+    color: __TREBLE_TEAL__;
+    text-decoration-color: rgba(__TREBLE_TEAL_RGB__, 0.45);
+}
+.markdown-text a:hover,
+.ffasr-footnote a:hover {
+    color: __TREBLE_MINT__;
 }
-.queue-status p { margin: 0.15rem 0; }
 
 /* ---- Sub-status footer line ---- */
 .ffasr-footnote {
@@ -293,10 +373,17 @@ footer { display: none !important; }
     font-size: 0.82rem;
     opacity: 0.65;
     margin-top: 0.8rem;
+    color: __TREBLE_TEXT_MUTED__;
 }
 
 /* ---- Primary button emphasis ---- */
 button.primary, .primary button {
     font-weight: 600 !important;
 }
-"""
+""".replace("__TREBLE_TEAL__", TREBLE_TEAL).replace(
+    "__TREBLE_CYAN__", TREBLE_CYAN
+).replace("__TREBLE_MINT__", TREBLE_MINT).replace(
+    "__TREBLE_TEAL_RGB__", TREBLE_TEAL_RGB
+).replace("__TREBLE_SURFACE__", TREBLE_SURFACE).replace(
+    "__TREBLE_TEXT_MUTED__", TREBLE_TEXT_MUTED
+)

evaluation/remote_artifact.py

@@ -13,6 +13,24 @@ def default_remote_artifact_path(job_id: str) -> str:
     return f"results/remote_artifacts/{jid}.json"
 
 
+def normalize_artifact_bucket_path(artifact_ref: str) -> str:
+    """
+    Resolve a moderator-entered artifact reference to a bucket path.
+
+    Accepts ``jobid.json``, ``jobid``, or ``results/remote_artifacts/jobid.json``.
+    """
+    ref = (artifact_ref or "").strip().replace("\\", "/").lstrip("/")
+    if not ref:
+        raise ValueError("Enter a JSON artifact file name or bucket path.")
+    if ".." in ref.split("/"):
+        raise ValueError("Invalid artifact path.")
+    if "/" not in ref:
+        ref = f"results/remote_artifacts/{ref}"
+    if not ref.lower().endswith(".json"):
+        ref = f"{ref}.json"
+    return ref
+
+
 def build_artifact(
     *,
     model_id: str,

family_registry.py

@@ -7,7 +7,8 @@ from __future__ import annotations
 FAMILY_META: dict[str, tuple[str, str]] = {
     "auto": (
         "Auto",
-        "SpeechBrain (if detected) → (Granite chat if id matches) → pipeline → universal → CTC → SpeechBrain fallback.",
+        "Reads Hub config.model_type when possible, then: SpeechBrain → Granite → NeMo → Qwen → "
+        "pipeline → universal (trust_remote_code) → CTC only if applicable.",
     ),
     "transformers_pipeline": (
         "Transformers pipeline",
@@ -15,7 +16,9 @@ FAMILY_META: dict[str, tuple[str, str]] = {
     ),
     "universal": (
         "Universal speech-seq2seq",
-        "`AutoModelForSpeechSeq2Seq` (or `AutoModel` + `trust_remote_code`) + `generate()` + `decode()`.",
+        "`AutoModelForSpeechSeq2Seq` (or `AutoModel` + `trust_remote_code`) + `generate()` + `decode()`. "
+        "Use for custom Hub code (e.g. Cohere ASR). Extra pip deps: set Space secret "
+        "`FFASR_REMOTE_EXTRA_DEPS` (comma-separated) for remote jobs.",
     ),
     "granite_speech": (
         "IBM Granite speech (chat prompt)",

job_queue.py

@@ -62,6 +62,10 @@ class Job:
     error: str | None = None
     result: dict[str, Any] | None = None
     submission_notes: str = ""
+    extra_requirements: str = ""
+    custom_script: str = ""
+    is_gated: bool = False
+    run_custom_script: bool = False
     # Progress (not persisted; only meaningful while running)
     progress_done: int = 0
     progress_total: int = 0
@@ -85,6 +89,9 @@ _MAX_JOBS_TRACKED = 400
 _MAX_QUEUE_BACKLOG = 32
 _MAX_PENDING_MODERATION = 64
 _DEFAULT_REMOTE_MAX_CONCURRENT = 4
+_MAX_CUSTOM_SCRIPT_BYTES = 32 * 1024
+_MAX_REQUIREMENT_LINE_LEN = 200
+_MAX_REQUIREMENT_LINES = 50
 
 _JOBS_CSV_FIELDS = [
     "job_id",
@@ -95,11 +102,70 @@ _JOBS_CSV_FIELDS = [
     "updated_at",
     "error",
     "submission_notes",
+    "extra_requirements",
+    "custom_script_b64",
+    "is_gated",
+    "run_custom_script",
     "hf_remote_job_id",
     "remote_artifact_path",
 ]
 
 
+def parse_requirements_lines(text: str) -> list[str]:
+    """One package spec per line (requirements.txt style); ignores blanks and # comments."""
+    out: list[str] = []
+    for raw in (text or "").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#"):
+            continue
+        if len(line) > _MAX_REQUIREMENT_LINE_LEN:
+            line = line[:_MAX_REQUIREMENT_LINE_LEN]
+        out.append(line)
+        if len(out) >= _MAX_REQUIREMENT_LINES:
+            break
+    return out
+
+
+def sanitize_custom_script(text: str) -> str:
+    """Trim and cap custom script body for storage."""
+    s = (text or "").strip()
+    if not s:
+        return ""
+    enc = s.encode("utf-8")
+    if len(enc) > _MAX_CUSTOM_SCRIPT_BYTES:
+        enc = enc[:_MAX_CUSTOM_SCRIPT_BYTES]
+        s = enc.decode("utf-8", errors="ignore")
+    return s
+
+
+def _bool_to_csv(flag: bool) -> str:
+    return "1" if flag else "0"
+
+
+def _bool_from_csv(raw: str) -> bool:
+    return (raw or "").strip().lower() in ("1", "true", "yes", "on")
+
+
+def _encode_script_b64(script: str) -> str:
+    if not script:
+        return ""
+    import base64
+
+    return base64.b64encode(script.encode("utf-8")).decode("ascii")
+
+
+def _decode_script_b64(raw: str) -> str:
+    raw = (raw or "").strip()
+    if not raw:
+        return ""
+    import base64
+
+    try:
+        return base64.b64decode(raw.encode("ascii")).decode("utf-8")
+    except Exception:
+        return ""
+
+
 def _now_iso() -> str:
     return datetime.now(timezone.utc).isoformat()
 
@@ -167,6 +233,10 @@ def _persist_jobs() -> None:
                     "updated_at": j.updated_at or j.created_at,
                     "error": (j.error or "").replace("\n", " ")[:2000],
                     "submission_notes": (j.submission_notes or "").replace("\n", " ")[:4000],
+                    "extra_requirements": (j.extra_requirements or "").replace("\r\n", "\n")[:8000],
+                    "custom_script_b64": _encode_script_b64(j.custom_script or ""),
+                    "is_gated": _bool_to_csv(j.is_gated),
+                    "run_custom_script": _bool_to_csv(j.run_custom_script),
                     "hf_remote_job_id": (j.hf_remote_job_id or "").strip(),
                     "remote_artifact_path": (j.remote_artifact_path or "").strip(),
                 }
@@ -230,6 +300,10 @@ def _load_persisted_jobs_once() -> None:
                 continue
             err = (row.get("error") or "").strip() or None
             notes = (row.get("submission_notes") or "").strip()
+            extra_req = (row.get("extra_requirements") or "").strip()
+            script = _decode_script_b64(row.get("custom_script_b64") or "")
+            is_gated = _bool_from_csv(row.get("is_gated") or "")
+            run_custom = _bool_from_csv(row.get("run_custom_script") or "")
             created = (row.get("created_at") or _now_iso()).strip()
             updated = (row.get("updated_at") or created).strip()
             mid = (row.get("model_id") or "").strip()
@@ -258,6 +332,10 @@ def _load_persisted_jobs_once() -> None:
                 updated_at=updated,
                 error=err,
                 submission_notes=notes,
+                extra_requirements=extra_req,
+                custom_script=script,
+                is_gated=is_gated,
+                run_custom_script=run_custom,
                 hf_remote_job_id=hf_rid,
                 remote_artifact_path=art_path,
             )
@@ -400,6 +478,150 @@ def _merge_eval_result_to_leaderboard(
     save_raw_results(rows)
 
 
+def _load_artifact_json_from_bucket(artifact_path: str) -> dict:
+    """Download and parse a remote eval JSON artifact from the Hub bucket."""
+    from storage import STORAGE_BACKEND, download_bucket_file
+
+    if STORAGE_BACKEND != "hf_bucket":
+        raise RuntimeError("Artifact import requires STORAGE_BACKEND='hf_bucket'.")
+    local_path = download_bucket_file(artifact_path)
+    try:
+        with open(local_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    finally:
+        try:
+            os.unlink(local_path)
+        except Exception:
+            pass
+
+
+def _submission_notes_for_artifact_import(
+    data: dict, artifact_path: str, override: str
+) -> str:
+    notes = (override or "").strip()
+    if notes:
+        return notes[:4000]
+    space_job_id = str(data.get("job_id") or "").strip()
+    with _jobs_lock:
+        for j in _jobs.values():
+            if space_job_id and j.id == space_job_id:
+                return (j.submission_notes or "").strip()[:4000]
+            if (j.remote_artifact_path or "").strip() == artifact_path:
+                return (j.submission_notes or "").strip()[:4000]
+    return ""
+
+
+def _mark_job_done_for_artifact(
+    data: dict, artifact_path: str, result: dict
+) -> str | None:
+    """If a tracked queue job matches, mark it done. Returns matched job id or None."""
+    space_job_id = str(data.get("job_id") or "").strip()
+    matched: Job | None = None
+    with _jobs_lock:
+        for j in _jobs.values():
+            if space_job_id and j.id == space_job_id:
+                matched = j
+                break
+            if (j.remote_artifact_path or "").strip() == artifact_path:
+                matched = j
+                break
+        if matched is not None:
+            matched.status = JobStatus.done
+            matched.result = result
+            matched.error = None
+            if not (matched.remote_artifact_path or "").strip():
+                matched.remote_artifact_path = artifact_path
+            _touch(matched)
+    if matched is not None:
+        _persist_jobs()
+        return matched.id
+    return None
+
+
+def import_artifact_to_leaderboard(
+    artifact_ref: str,
+    secret: str,
+    *,
+    replace_existing: bool = False,
+    submission_notes: str = "",
+) -> tuple[bool, str]:
+    """
+    Moderator-only: load a bucket JSON artifact and merge its result into leaderboard.csv.
+
+    ``artifact_ref`` may be a file name (``abc123.json``), job id (``abc123``), or full bucket path.
+    """
+    ok, msg = _moderator_secret_ok(secret)
+    if not ok:
+        return False, msg
+
+    from evaluation.remote_artifact import extract_result_or_raise, normalize_artifact_bucket_path
+    from init import (
+        invalidate_results_cache,
+        leaderboard_row_from_eval_result,
+        load_raw_results,
+        normalize_legacy_csv_row,
+        save_raw_results,
+    )
+    import analytics
+
+    try:
+        artifact_path = normalize_artifact_bucket_path(artifact_ref)
+    except ValueError as e:
+        return False, str(e)
+
+    try:
+        data = _load_artifact_json_from_bucket(artifact_path)
+    except Exception as e:
+        return False, f"Could not load artifact <code>{_escape_html(artifact_path)}</code>: {e}"
+
+    try:
+        result = extract_result_or_raise(data)
+    except Exception as e:
+        return False, f"Artifact is not a successful evaluation: {e}"
+
+    model_id = str(result.get("model_id", "")).strip()
+    if not model_id:
+        return False, "Artifact result is missing model_id."
+
+    notes = _submission_notes_for_artifact_import(data, artifact_path, submission_notes)
+    rows = load_raw_results()
+    existing = [i for i, r in enumerate(rows) if (r.get("model_id") or "").strip() == model_id]
+
+    if existing and not replace_existing:
+        row = dict(rows[existing[0]])
+        normalize_legacy_csv_row(row)
+        score = analytics.far_field_score_for_row(row)
+        score_txt = f"{score:.2f}" if score is not None else "N/A"
+        return False, (
+            f"Model <code>{_escape_html(model_id)}</code> is already on the leaderboard "
+            f"(score {score_txt}). Enable <strong>Replace existing row</strong> to overwrite."
+        )
+
+    if existing and replace_existing:
+        for i in sorted(existing, reverse=True):
+            rows.pop(i)
+
+    submitted_at = _now_iso()
+    new_row = leaderboard_row_from_eval_result(result, submitted_at, submission_notes=notes)
+    normalize_legacy_csv_row(new_row)
+    rows.append(new_row)
+    _leaderboard_sort_rows_inplace(rows)
+    save_raw_results(rows)
+    invalidate_results_cache()
+
+    ff_score = analytics.far_field_score_for_row(new_row)
+    score_txt = f"{ff_score:.2f}" if ff_score is not None else "N/A"
+    action = "Replaced" if existing else "Added"
+    matched_job = _mark_job_done_for_artifact(data, artifact_path, result)
+    job_bit = f" Matched queue job <code>{_escape_html(matched_job)}</code> marked done." if matched_job else ""
+
+    return True, (
+        f"{action} <strong>{_escape_html(model_id)}</strong> from "
+        f"<code>{_escape_html(artifact_path)}</code>. "
+        f"Far-field score: <strong>{score_txt}</strong> / 100.{job_bit}"
+    )
+
+
 def _remote_collect_result(job_id: str, hf_id: str, jobs_token: str) -> dict:
     from evaluation.remote_artifact import extract_result_or_raise
     from storage import download_bucket_file
@@ -464,12 +686,21 @@ def _remote_dispatch_job(job_id: str, mid: str, fid: str, jobs_token: str) -> st
             _touch(j3)
     _persist_jobs()
 
+    with _jobs_lock:
+        j_dispatch = _jobs.get(job_id)
+        extra_req = (j_dispatch.extra_requirements or "") if j_dispatch else ""
+        custom_script = (j_dispatch.custom_script or "") if j_dispatch else ""
+        run_custom = bool(j_dispatch and j_dispatch.run_custom_script)
+
     info = remote_jobs.submit_eval_job(
         model_id=mid,
         family_id=fid,
         space_job_id=job_id,
         artifact_path=artifact_path,
         token=jobs_token,
+        extra_requirements=extra_req,
+        custom_script=custom_script,
+        run_custom_script=run_custom,
     )
     hf_id = info.id
     with _jobs_lock:
@@ -663,6 +894,10 @@ def enqueue(
     model_id: str,
     family_id: str,
     submission_notes: str = "",
+    *,
+    extra_requirements: str = "",
+    custom_script: str = "",
+    is_gated: bool = False,
 ) -> tuple[str, int, str | None, bool]:
     """
     Enqueue an evaluation job.
@@ -699,6 +934,12 @@ def enqueue(
     job_id = str(uuid.uuid4())[:8]
     created = _now_iso()
     notes_clean = (submission_notes or "").strip()[:4000]
+    try:
+        req_lines = parse_requirements_lines(extra_requirements)
+        extra_req_clean = "\n".join(req_lines)
+        script_clean = sanitize_custom_script(custom_script)
+    except Exception as e:
+        return "", 0, f"Invalid submission fields: {e}", False
 
     awaiting = moderation_active()
     status = JobStatus.pending_moderation if awaiting else JobStatus.queued
@@ -711,6 +952,10 @@ def enqueue(
         created_at=created,
         updated_at=created,
         submission_notes=notes_clean,
+        extra_requirements=extra_req_clean,
+        custom_script=script_clean,
+        is_gated=bool(is_gated),
+        run_custom_script=False,
     )
 
     with _jobs_lock:
@@ -732,7 +977,9 @@ def enqueue(
     return job_id, position, None, False
 
 
-def approve_job(job_id: str, secret: str) -> tuple[bool, str]:
+def approve_job(
+    job_id: str, secret: str, *, run_custom_script: bool = False
+) -> tuple[bool, str]:
     """Move a pending job into the execution queue (moderator only)."""
     if not moderation_active():
         return False, "Moderation is not active on this Space."
@@ -750,15 +997,24 @@ def approve_job(job_id: str, secret: str) -> tuple[bool, str]:
             return False, "Execution queue is full; try again in a moment."
 
         job.status = JobStatus.queued
+        if (job.custom_script or "").strip():
+            job.run_custom_script = bool(run_custom_script)
+        else:
+            job.run_custom_script = False
         _touch(job)
 
     _work_queue.put(job_id)
     _persist_jobs()
     _ensure_worker()
     max_n = remote_max_concurrent_jobs()
+    custom_note = ""
+    with _jobs_lock:
+        j = _jobs.get(job_id)
+        if j and j.run_custom_script and (j.custom_script or "").strip():
+            custom_note = " Custom script will run on the Hub Job."
     return True, (
         f"Approved job {job_id}. Up to {max_n} Hub Jobs may run in parallel; "
-        "this job starts when a slot is free."
+        f"this job starts when a slot is free.{custom_note}"
     )
 
 
@@ -955,22 +1211,84 @@ def moderation_list_html() -> str:
     for j in jobs:
         note = (j.submission_notes or "").strip()
         note_cell = _escape_html(note[:200] + ("…" if len(note) > 200 else "")) if note else "N/A"
+        gated = " <span style='color:#b45309'>[gated]</span>" if j.is_gated else ""
+        req_n = len(parse_requirements_lines(j.extra_requirements or ""))
+        req_bit = f"{req_n} extra req(s)" if req_n else ""
+        script_bit = "custom script" if (j.custom_script or "").strip() else ""
+        extras = ", ".join(x for x in (req_bit, script_bit) if x)
+        extras_cell = _escape_html(extras) if extras else "—"
         rows.append(
             f"<tr><td><code>{_escape_html(j.id)}</code></td>"
-            f"<td><code>{_escape_html(j.model_id)}</code></td>"
+            f"<td><code>{_escape_html(j.model_id)}</code>{gated}</td>"
             f"<td><code>{_escape_html(j.family_id)}</code></td>"
+            f"<td style='max-width:200px;font-size:0.85em'>{extras_cell}</td>"
             f"<td style='max-width:280px;font-size:0.9em'>{note_cell}</td>"
             f"<td>{_escape_html(j.created_at)}</td></tr>"
         )
     body = "".join(rows)
     return (
         "<table style='width:100%;border-collapse:collapse;font-size:0.95em'>"
-        "<thead><tr><th>Job ID</th><th>Model</th><th>Family</th><th>Notes</th>"
+        "<thead><tr><th>Job ID</th><th>Model</th><th>Family</th><th>Extras</th><th>Notes</th>"
         "<th>Submitted (UTC)</th></tr></thead>"
         f"<tbody>{body}</tbody></table>"
     )
 
 
+def next_up_html(limit: int = 5) -> str:
+    """Ordered list of models next in the approved execution queue (Submit tab)."""
+    try:
+        _ensure_worker()
+    except Exception as e:
+        return _worker_unavailable_html(e)
+    with _jobs_lock:
+        queued = [j for j in _jobs.values() if j.status == JobStatus.queued]
+    queued.sort(key=lambda j: j.created_at)
+    queued = queued[: max(1, int(limit))]
+    if not queued:
+        return (
+            "<div class='next-up-panel' style='font-size:0.9em;opacity:0.85'>"
+            "<p><em>No models are waiting in the evaluation queue.</em></p></div>"
+        )
+    items = "".join(
+        f"<li><code>{_escape_html(j.model_id)}</code> "
+        f"<span style='opacity:0.75'>(job {_escape_html(j.id)})</span></li>"
+        for j in queued
+    )
+    return (
+        "<div class='next-up-panel' style='font-size:0.9em'>"
+        f"<p><strong>Next models to evaluate</strong> ({len(queued)} shown):</p>"
+        f"<ol style='margin:0.25rem 0 0 1.1rem'>{items}</ol></div>"
+    ).replace("</div>", "</div>")
+
+
+def recent_jobs_for_render(limit: int = 30) -> list[dict[str, Any]]:
+    """Structured recent jobs for Gradio @gr.render rows (Retry / Remove)."""
+    with _jobs_lock:
+        items = list(_jobs.values())
+    items.sort(key=lambda j: j.updated_at or j.created_at, reverse=True)
+    out: list[dict[str, Any]] = []
+    for j in items[: max(1, int(limit))]:
+        err = (j.error or "").strip()
+        try:
+            hub = _hub_job_link_html(j.hf_remote_job_id)
+        except Exception:
+            hub = ""
+        out.append(
+            {
+                "id": j.id,
+                "model_id": j.model_id,
+                "status": j.status.value,
+                "error": err[:200] + ("…" if len(err) > 200 else ""),
+                "hub_link_html": hub,
+                "updated_at": (j.updated_at or j.created_at)[:19],
+                "can_retry": j.status == JobStatus.failed,
+                "can_remove": j.status != JobStatus.running,
+                "has_custom_script": bool((j.custom_script or "").strip()),
+            }
+        )
+    return out
+
+
 def recent_jobs_html(limit: int = 25, *, with_heading: bool = True) -> str:
     """Recent jobs with status (for spotting stuck or failed runs)."""
     with _jobs_lock:
@@ -1105,15 +1423,15 @@ def progress_html() -> str:
 
     if total <= 0:
         inner = (
-            "<div style='width:40%;height:100%;background:#4c8bf5;"
-            "background-image:linear-gradient(90deg,#4c8bf5,#8ab4ff,#4c8bf5);"
+            "<div style='width:40%;height:100%;background:#38BFA1;"
+            "background-image:linear-gradient(90deg,#38BFA1,#3DFFA3,#38BFA1);"
             "background-size:200% 100%;animation:ffasr-indet 1.6s linear infinite;'></div>"
         )
         pct_label = "preparing…"
     else:
         pct = max(0.0, min(100.0, 100.0 * done / total))
         inner = (
-            f"<div style='height:100%;width:{pct:.1f}%;background:#4c8bf5;"
+            f"<div style='height:100%;width:{pct:.1f}%;background:#38BFA1;"
             "transition:width 0.4s ease-out'></div>"
         )
         cond_txt = f"; current condition: <code>{_escape_html(cond)}</code>" if cond else ""

remote_jobs.py

@@ -44,6 +44,7 @@ _TRANSFORMERS_DEPS: list[str] = [
     "transformers @ git+https://github.com/huggingface/transformers.git",
     "torchcodec",
     "librosa",
+    "sentencepiece",
 ]
 
 _NEMO_DEPS: list[str] = [
@@ -96,29 +97,49 @@ def _needs_speechbrain_stack(model_id: str) -> bool:
     return m.startswith("speechbrain/") or "speechbrain" in m
 
 
+def _parse_extra_deps_env() -> list[str]:
+    raw = os.environ.get("FFASR_REMOTE_EXTRA_DEPS", "").strip()
+    if not raw:
+        return []
+    return [p.strip() for p in raw.split(",") if p.strip()]
+
+
 def _select_deps(model_id: str, family_id: str) -> list[str]:
     """Return uv dependency list for this model/family (core + backend-specific)."""
-    fid = (family_id or "auto").strip().lower()
-    if fid in ("transformers_seq2seq", "transformers_auto_remote", "cohere_asr"):
-        fid = "universal"
+    from backends.family_resolve import extra_deps_for_model, resolve_auto_family
+    from family_registry import _FAMILY_ALIASES
+
+    raw = (family_id or "auto").strip().lower()
+    fid = _FAMILY_ALIASES.get(raw, raw)
+    fid = resolve_auto_family(model_id, fid)
 
     if fid == "speechbrain":
-        return [*CORE_DEPS, *_SPEECHBRAIN_DEPS]
-    if fid == "nemo_asr":
-        return [*CORE_DEPS, *_NEMO_DEPS]
-    if fid in ("qwen_asr", "qwen3_asr"):
-        return [*CORE_DEPS, *_QWEN_DEPS]
-    if fid in ("transformers_pipeline", "universal", "granite_speech", "transformers_ctc"):
-        return [*CORE_DEPS, *_TRANSFORMERS_DEPS]
-
-    # auto: infer from model id
-    if _needs_nemo_stack(model_id):
-        return [*CORE_DEPS, *_NEMO_DEPS]
-    if _needs_qwen_asr_stack(model_id):
-        return [*CORE_DEPS, *_QWEN_DEPS]
-    if _needs_speechbrain_stack(model_id):
-        return [*CORE_DEPS, *_SPEECHBRAIN_DEPS]
-    return [*CORE_DEPS, *_TRANSFORMERS_DEPS]
+        base = [*CORE_DEPS, *_SPEECHBRAIN_DEPS]
+    elif fid == "nemo_asr":
+        base = [*CORE_DEPS, *_NEMO_DEPS]
+    elif fid in ("qwen_asr", "qwen3_asr"):
+        base = [*CORE_DEPS, *_QWEN_DEPS]
+    elif fid in ("transformers_pipeline", "universal", "granite_speech", "transformers_ctc"):
+        base = [*CORE_DEPS, *_TRANSFORMERS_DEPS]
+    elif _needs_nemo_stack(model_id):
+        base = [*CORE_DEPS, *_NEMO_DEPS]
+    elif _needs_qwen_asr_stack(model_id):
+        base = [*CORE_DEPS, *_QWEN_DEPS]
+    elif _needs_speechbrain_stack(model_id):
+        base = [*CORE_DEPS, *_SPEECHBRAIN_DEPS]
+    else:
+        base = [*CORE_DEPS, *_TRANSFORMERS_DEPS]
+
+    extras = extra_deps_for_model(model_id)
+    env_extras = _parse_extra_deps_env()
+    # Preserve order, dedupe.
+    seen: set[str] = set()
+    out: list[str] = []
+    for pkg in [*base, *extras, *env_extras]:
+        if pkg not in seen:
+            seen.add(pkg)
+            out.append(pkg)
+    return out
 
 
 def submit_eval_job(
@@ -128,6 +149,9 @@ def submit_eval_job(
     space_job_id: str,
     artifact_path: str,
     token: str | None,
+    extra_requirements: str = "",
+    custom_script: str = "",
+    run_custom_script: bool = False,
 ) -> JobInfo:
     """Start a Hub UV Job; returns initial ``JobInfo`` (may already be RUNNING)."""
     namespace = os.environ.get("FFASR_REMOTE_JOB_NAMESPACE", "").strip() or None
@@ -162,10 +186,36 @@ def submit_eval_job(
         )
 
     script = _worker_script_path()
-    if not os.path.isfile(script):
+    custom_script_path: str | None = None
+    if run_custom_script and (custom_script or "").strip():
+        import tempfile
+
+        fd, custom_script_path = tempfile.mkstemp(
+            prefix=f"ffasr_custom_{space_job_id}_", suffix=".py"
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                f.write(custom_script.strip())
+        except Exception:
+            os.unlink(custom_script_path)
+            raise
+        script = custom_script_path
+    elif not os.path.isfile(script):
         raise RuntimeError(f"Remote worker script not found: {script}")
 
     deps = _select_deps(model_id, family_id)
+    try:
+        from job_queue import parse_requirements_lines
+
+        extra_lines = parse_requirements_lines(extra_requirements)
+    except Exception:
+        extra_lines = []
+    if extra_lines:
+        seen = set(deps)
+        for pkg in extra_lines:
+            if pkg not in seen:
+                seen.add(pkg)
+                deps.append(pkg)
 
     env = {
         "FFASR_MODEL_ID": model_id,
@@ -186,25 +236,32 @@ def submit_eval_job(
 
     api = HfApi(token=jobs_tok)
     last_err: Exception | None = None
-    for attempt in range(3):
-        try:
-            return api.run_uv_job(
-                script=script,
-                dependencies=deps,
-                env=env,
-                secrets=secrets,
-                flavor=flavor,
-                timeout=timeout,
-                namespace=namespace,
-                python="3.12",
-                token=jobs_tok,
-            )
-        except Exception as e:
-            last_err = e
-            time.sleep(2.0 * (2**attempt))
-    if last_err is not None:
-        raise last_err
-    raise RuntimeError("submit_eval_job: unreachable")
+    try:
+        for attempt in range(3):
+            try:
+                return api.run_uv_job(
+                    script=script,
+                    dependencies=deps,
+                    env=env,
+                    secrets=secrets,
+                    flavor=flavor,
+                    timeout=timeout,
+                    namespace=namespace,
+                    python="3.12",
+                    token=jobs_tok,
+                )
+            except Exception as e:
+                last_err = e
+                time.sleep(2.0 * (2**attempt))
+        if last_err is not None:
+            raise last_err
+        raise RuntimeError("submit_eval_job: unreachable")
+    finally:
+        if custom_script_path and os.path.isfile(custom_script_path):
+            try:
+                os.unlink(custom_script_path)
+            except Exception:
+                pass
 
 
 def inspect_job_once(hf_job_id: str, *, token: str | None = None) -> JobInfo: