Refine public benchmark presentation

README.md

@@ -7,48 +7,15 @@ short_description: Interactive BEND-BCI neural decoder benchmark
 
 # BEND-BCI Interactive Benchmark
 
-This Space is the interactive companion to BEND-BCI (Benchmarking Neural
-Decoders for Brain-Computer Interfaces). It presents 23 evaluated methods on
-five primary tasks.
+BEND-BCI compares 23 neural decoding methods across predictive performance,
+robustness, computational cost and cross-recording latent consistency. This
+Space provides interactive results together with feature-attribution and
+trial-valuation analyses.
 
-The application keeps the benchmark's scientific organization explicit:
+Code, benchmark outputs and dataset preparation are available in the
+[BEND-BCI repository](https://github.com/TangLab-UBC/behavior_benchmarking).
 
-- decoder-selection measurements: held-out task prediction, robustness to
-  added count noise, computational cost, and cross-recording latent
-  consistency;
-- diagnostic assays: feature attribution and trial-level data valuation.
-
-Interactive matrices use within-dataset percentile ranks, with raw values and
-task-specific metrics retained on hover. Unavailable analyses remain visible
-as coverage limits and are not imputed.
-
-## Data and figure provenance
-
-The bundled tables in `data/` are synchronized from the canonical
-`paper/results/*.csv` exports in the
-[main BEND-BCI repository](https://github.com/TangLab-UBC/behavior_benchmarking).
-Each source table retains artifact paths for provenance.
-
-The interactive sections follow the current generated manuscript figures:
-
-- Figure 2: prediction, robustness, and computational cost;
-- Figure 3: cross-recording latent consistency;
-- Figure 4: feature-attribution validation;
-- Figure 5: Data Shapley trial valuation, retraining case studies, and the
-  held-out RNN historical-selection trajectory example.
-
-Latent display coordinates are exported after the same per-session whitening
-and matched-landmark display alignment used for Figure 3. The reported
-consistency value is symmetric alignment R²; it does not measure decoder
-transfer or identify a unique latent coordinate system.
-
-Feature and trial values remain signed. Feature-attribution validation is
-dataset-specific: Allen Neuropixels uses Spearman correlation with measured
-orientation selectivity, while the other primary tasks use their predefined
-ROC-AUC validation assays. Trial valuation reports corrupted-trial detection
-ROC-AUC using negative signed trial value as the detection score.
-
-## Local validation and launch
+## Run locally
 
 ```bash
 python -m venv .venv
@@ -56,14 +23,3 @@ python -m venv .venv
 .venv/bin/python validate_data.py
 .venv/bin/python app.py
 ```
-
-From a checkout nested inside the main benchmark repository, exact equality
-with the manuscript-facing tables can also be checked with:
-
-```bash
-.venv/bin/python validate_data.py --canonical-root ..
-```
-
-The complete artifacts, dataset preparation, benchmark execution, figure
-builders, and result-export workflow live in the main repository. The Space
-contains lightweight summaries intended for interactive inspection.

app.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 import re
 from pathlib import Path
 from typing import Iterable, Sequence
@@ -70,18 +69,18 @@ DISPLAY_NAMES = {
 
 DATASET_LABELS = {
     "monkey": "Macaque center-out reaching",
-    "allen_neuropixels": "Allen Neuropixels visual coding",
+    "allen_neuropixels": "Allen visual coding",
     "speech": "Attempted speech",
     "mc_pacman": "MC PacMan force decoding",
     "ratinabox": "RatInABox navigation",
 }
 
-DATASET_SHORT_LABELS = {
-    "monkey": "Macaque reaching",
-    "allen_neuropixels": "Allen visual coding",
-    "speech": "Attempted speech",
-    "mc_pacman": "MC PacMan",
-    "ratinabox": "RatInABox",
+DATASET_TICK_LABELS = {
+    "monkey": "Macaque<br>center-out reaching",
+    "allen_neuropixels": "Allen<br>visual coding",
+    "speech": "Attempted<br>speech",
+    "mc_pacman": "MC PacMan<br>force decoding",
+    "ratinabox": "RatInABox<br>navigation",
 }
 
 DATASET_DESCRIPTIONS = {
@@ -226,18 +225,10 @@ RATINABOX_SCALE = [
 TABLE_LABELS = {
     "method": "Method",
     "workflow": "Prediction workflow",
-    "readout": "Prediction/readout implementation",
     "hardware": "Primary hardware",
-    "prediction_status": "Prediction",
-    "robustness_status": "Robustness",
-    "compute_status": "Computational cost",
-    "consistency_status": "Latent consistency",
-    "feature_status": "Feature attribution",
-    "trial_status": "Trial valuation",
-    "coverage_notes": "Coverage notes",
     "task_score": "Held-out task score",
     "prediction_percentile": "Within-dataset percentile",
-    "robustness_auc": "Raw score-vs-noise AUC",
+    "robustness_auc": "Area under task-score-versus-noise curve",
     "training_time_sec": "Training time (s)",
     "inference_time_sec": "Inference time (s)",
     "peak_ram_gb": "Peak RAM (GB)",
@@ -252,28 +243,9 @@ TABLE_LABELS = {
     "validation_target": "Validation target",
     "validation_metric": "Validation metric",
     "validation_score": "Validation score",
-    "shap_mean_value": "Mean signed Kernel SHAP",
-    "shap_median_value": "Median signed Kernel SHAP",
-    "shap_min_value": "Minimum signed Kernel SHAP",
-    "shap_max_value": "Maximum signed Kernel SHAP",
-    "shap_fraction_positive": "Fraction positive",
-    "shap_fraction_negative": "Fraction negative",
     "corrupted_trial_auc": "Corrupted-trial ROC-AUC",
-    "iterations": "TMC permutations",
-    "converged": "Converged",
-    "final_error": "Final convergence error",
-    "perturbation_fraction": "Rotated-trial fraction",
-    "rotation_angle_deg": "Rotation angle (degrees)",
-    "rotation_subspace_dim_spec": "Rotation subspace",
-    "shapley_mean_value": "Mean signed Data Shapley",
-    "shapley_median_value": "Median signed Data Shapley",
-    "shapley_min_value": "Minimum signed Data Shapley",
-    "shapley_max_value": "Maximum signed Data Shapley",
-    "shapley_fraction_positive": "Fraction positive",
-    "shapley_fraction_negative": "Fraction negative",
     "mixed_full": "Mixed trials",
     "data_shapley": "After trial-value removal",
-    "oracle": "Oracle removal",
     "recovery": "Recovery ΔR²",
     "target_only": "Current session only",
     "all_sessions": "All-session pooling",
@@ -419,17 +391,6 @@ def load_historical_trajectories() -> pd.DataFrame:
     return frame.sort_values(["direction_index", "trial_index", "time_index"]).reset_index(drop=True)
 
 
-def load_release_manifest() -> dict:
-    path = DATA_DIR / "release_manifest.json"
-    if not path.exists():
-        return {}
-    try:
-        payload = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return {}
-    return payload if isinstance(payload, dict) else {}
-
-
 prediction = load_csv("clean_prediction_summary.csv")
 robustness = load_csv("robustness_summary.csv")
 consistency = load_csv("consistency_summary.csv")
@@ -440,7 +401,6 @@ trial_retrain = load_csv("trial_shapley_retrain_summary.csv")
 trial_historical_trajectories = load_historical_trajectories()
 latent_samples = load_csv("latent_samples.csv")
 latent_trajectories = load_csv("latent_trajectories.csv")
-release_manifest = load_release_manifest()
 
 
 def present_rows(df: pd.DataFrame) -> pd.DataFrame:
@@ -642,7 +602,7 @@ def metric_card(label: str, value: str, detail: str | None = None, accent: str =
     return html.Div(children, className=classes)
 
 
-def source_link(filename: str, label: str = "Download source CSV") -> html.A:
+def source_link(filename: str, label: str = "Download CSV") -> html.A:
     return html.A(
         label,
         href=f"/download/{filename}",
@@ -713,10 +673,10 @@ def figure_layout(
 def heatmap_layout(fig: go.Figure, *, height: int) -> go.Figure:
     figure_layout(fig, height=height)
     fig.update_layout(
-        margin=dict(l=54, r=28, t=126, b=58),
+        margin=dict(l=54, r=28, t=116, b=50),
         title=dict(y=0.985, yanchor="top", pad=dict(b=12)),
     )
-    fig.update_xaxes(tickangle=-28)
+    fig.update_xaxes(tickangle=0, tickfont=dict(size=10), automargin=True)
     return fig
 
 
@@ -737,98 +697,11 @@ def empty_figure(message: str, *, height: int = 360) -> go.Figure:
     return figure_layout(fig, height=height)
 
 
-def availability_note(available: int, configured: int, *, unsupported: int = 0) -> str:
-    message = f"Coverage: {available} of {configured} configured entries available"
-    if unsupported:
-        message += f"; {unsupported} selected method{'s' if unsupported != 1 else ''} outside this analysis"
-    return message if message.endswith(".") else message + "."
-
-
-def feature_coverage_note(dataset: str, models: Sequence[str] | None) -> str:
-    chosen = selected_models(models)
-    configured = [model for model in chosen if model in FEATURE_ELIGIBLE]
-    available = filter_models(active_rows(neuron_shap), chosen)
-    available = int(available["dataset"].astype(str).eq(str(dataset)).sum())
-    message = (
-        f"Main Figure 4 interface: {available} of {len(configured)} configured entries "
-        "available"
-    )
-    if "marble" in chosen:
-        message += f"; full attempted grid: {available} of {len(chosen)} available. "
-        if dataset == "allen_neuropixels":
-            message += (
-                "MARBLE exceeded the host-memory allocation before feature attribution."
-            )
-        else:
-            message += (
-                "MARBLE is outside the masked-input interface because masking changes its "
-                "transductive graph construction."
-            )
-    return message if message.endswith(".") else message + "."
-
-
-def intervention_coverage_note() -> str:
-    frame = active_rows(trial_retrain)
-    within = frame[frame["analysis"] == "within_session_cleaning"].pivot_table(
-        index="model", columns="condition", values="score", aggfunc="first"
-    )
-    historical = frame[
-        frame["analysis"] == "cross_session_old_trial_selection"
-    ].pivot_table(index="model", columns="condition", values="score", aggfunc="first")
-    removal_improved = int((within["data_shapley"] > within["mixed_full"]).sum())
-    historical_vs_current = int(
-        (historical["oldonly_dshap_negative_removal"] > historical["target_only"]).sum()
-    )
-    historical_vs_pooling = int(
-        (historical["oldonly_dshap_negative_removal"] > historical["all_sessions"]).sum()
-    )
-    return (
-        f"Full coverage: {len(within)} removal and {len(historical)} historical-selection "
-        f"entries. Removal improved {removal_improved}/{len(within)} methods "
-        f"(mean R² {within['mixed_full'].mean():.3f}→{within['data_shapley'].mean():.3f}); "
-        f"historical selection beat current-only training for "
-        f"{historical_vs_current}/{len(historical)} and pooling for "
-        f"{historical_vs_pooling}/{len(historical)} (means "
-        f"{historical['oldonly_dshap_negative_removal'].mean():.3f} vs "
-        f"{historical['target_only'].mean():.3f}/{historical['all_sessions'].mean():.3f}). "
-        "The removal comparison reuses the valuation split and is a controlled diagnostic, "
-        "not an independent generalization estimate."
-    )
-
-
-def row_exists(df: pd.DataFrame, model: str, dataset: str) -> bool:
-    if df.empty:
-        return False
-    return bool(
-        ((df["model"].astype(str) == model) & (df["dataset"].astype(str) == dataset)).any()
-    )
-
-
-def missing_reason(analysis: str, model: str, dataset: str) -> str:
-    specific = {
-        ("prediction", "marble", "allen_neuropixels"): "MARBLE graph/embedding construction exceeded the 192-GB host-memory allocation.",
-        ("prediction", "tndm", "speech"): "TNDM training returned non-finite relevant-prior/posterior KL values.",
-        ("prediction", "svc", "allen_neuropixels"): "Exact-kernel SVM fitting exceeded the 24-hour allocation.",
-        ("consistency", "marble", "allen_neuropixels"): "MARBLE graph/embedding construction exceeded the host-memory allocation.",
-        ("consistency", "tndm", "speech"): "TNDM training returned non-finite KL values before a representation was available.",
-        ("feature", "mint", "allen_neuropixels"): "The MATLAB-backed repeated masked-input procedure did not complete in the allocation.",
-        ("feature", "mint", "ratinabox"): "The MATLAB-backed repeated masked-input procedure did not complete in the allocation.",
-        ("feature", "svc", "allen_neuropixels"): "Exact-kernel SVM fitting exceeded the 24-hour allocation.",
-        ("feature", "svc", "mc_pacman"): "Repeated masked-input SVM/SVR evaluation exceeded the 24-hour allocation.",
-        ("feature", "svc", "ratinabox"): "Repeated masked-input SVM/SVR evaluation exceeded the 24-hour allocation.",
-        ("trial", "langevinflow_ccn", "allen_neuropixels"): "Repeated full-rank logistic coalition fits exceeded the execution allocation.",
-        ("trial", "marble", "allen_neuropixels"): "No Stage 1 representation was available after MARBLE exceeded host memory.",
-        ("trial", "tndm", "allen_neuropixels"): "Repeated causal-logistic coalition fits exceeded the execution allocation.",
-        ("trial", "tndm", "mc_pacman"): "Repeated causal-linear coalition fits exceeded the execution allocation.",
-    }
-    return specific.get((analysis, model, dataset), "No completed summary is available in this release.")
-
-
 def prediction_workflow(model: str, decoder: object, status: object) -> str:
     if str(status).lower() != "present":
         return "Unavailable"
     decoder_name = "" if decoder is None or pd.isna(decoder) else str(decoder)
-    direct_decoders = {
+    native_prediction_decoders = {
         "native",
         "dnn",
         "gru",
@@ -841,43 +714,18 @@ def prediction_workflow(model: str, decoder: object, status: object) -> str:
         "xgboost_classification",
         "xgboost_regression",
     }
-    if decoder_name in direct_decoders:
-        return "Predictions generated directly by trained model"
+    if decoder_name in native_prediction_decoders:
+        return "Native prediction output"
     # Manuscript v7 deliberately distinguishes LDNS task families: continuous
     # prediction uses the method recipe's ridge mapping on reconstructed rates
     # (alpha = 1e-6), while classification uses the standard logistic readout.
     if decoder_name in {"ridge", "logistic", "ldns_rate_sklearn_logistic"}:
-        return "Shared ridge/logistic readout"
+        return "Shared linear readout"
     if decoder_name in {"knn", "ole", "ldns_rate_sklearn_ridge"}:
-        return "Method-specific task mapping"
+        return "Author-style task readout"
     raise ValueError(f"Unrecognized prediction decoder for {model}: {decoder_name!r}")
 
 
-def readout_label(decoder: object) -> str:
-    if decoder is None or pd.isna(decoder):
-        return "Unavailable"
-    labels = {
-        "native": "Model-native output",
-        "ridge": "Ridge regression",
-        "logistic": "Logistic regression",
-        "knn": "k-nearest neighbors",
-        "ole": "Ordinary least squares",
-        "mint_pipeline": "MINT prediction pipeline",
-        "neds_e2e": "NEDS end-to-end head",
-        "dnn": "DNN task head",
-        "gru": "GRU task head",
-        "lstm": "LSTM task head",
-        "rnn": "RNN task head",
-        "svc": "Support-vector classifier",
-        "svr": "Support-vector regression",
-        "xgboost_classification": "XGBoost classifier",
-        "xgboost_regression": "XGBoost regressor",
-        "ldns_rate_sklearn_ridge": "Ridge on LDNS reconstructed rates",
-        "ldns_rate_sklearn_logistic": "Logistic regression on LDNS reconstructed rates",
-    }
-    return labels.get(str(decoder), str(decoder).replace("_", " "))
-
-
 def prediction_percentiles() -> pd.DataFrame:
     frame = present_rows(prediction)[["model", "dataset", "score"]].copy()
     frame["score"] = pd.to_numeric(frame["score"], errors="coerce")
@@ -931,7 +779,6 @@ def overview_frame(dataset: str, models: Sequence[str] | None) -> pd.DataFrame:
         lambda row: prediction_workflow(row["model"], row.get("decoder"), row.get("prediction_status_raw")),
         axis=1,
     )
-    frame["prediction_status"] = np.where(frame["task_score"].notna(), "Available", "Unavailable")
     frame.loc[frame["model"].isin(CPU_ONLY_MODELS), "peak_vram_gb"] = np.nan
     return round_numeric(frame)
 
@@ -947,7 +794,7 @@ def overview_cards(dataset: str, models: Sequence[str] | None) -> list[html.Div]
     cards = [
         metric_card(
             "Dataset",
-            DATASET_SHORT_LABELS.get(dataset, dataset),
+            DATASET_LABELS.get(dataset, dataset),
             DATASET_DESCRIPTIONS.get(dataset),
             "prediction",
         ),
@@ -970,14 +817,6 @@ def overview_cards(dataset: str, models: Sequence[str] | None) -> list[html.Div]
                 "prediction",
             )
         )
-    cards.append(
-        metric_card(
-            "Prediction coverage",
-            f"{len(available)}/{len(frame)}",
-            "Completed method–dataset entries in the current comparison.",
-            "prediction",
-        )
-    )
     return cards
 
 
@@ -1001,7 +840,7 @@ def prediction_ranking_figure(dataset: str, models: Sequence[str] | None) -> go.
             ),
         )
     )
-    fig.update_layout(title=f"{DATASET_SHORT_LABELS.get(dataset, dataset)} held-out prediction")
+    fig.update_layout(title="Held-out prediction")
     fig.update_xaxes(title=metric)
     fig.update_yaxes(title="", showgrid=False)
     return figure_layout(fig, height=max(440, 25 * len(frame) + 145))
@@ -1045,7 +884,7 @@ def percentile_heatmap(
     if eligible_models is not None:
         chosen = [model for model in chosen if model in eligible_models]
     if not chosen:
-        return empty_figure("None of the selected methods is configured for this analysis.")
+        return empty_figure("No results for this selection.")
     frame = values.copy()
     if frame.empty:
         return empty_figure(empty_message)
@@ -1073,23 +912,22 @@ def percentile_heatmap(
         index=ordered_models, columns=DATASETS
     )
     display_text = np.empty(percentile_matrix.shape, dtype=object)
-    customdata = np.empty((*percentile_matrix.shape, 3), dtype=object)
+    customdata = np.empty((*percentile_matrix.shape, 2), dtype=object)
     for row_index, model in enumerate(percentile_matrix.index):
         for column_index, dataset in enumerate(percentile_matrix.columns):
             percentile = percentile_matrix.iloc[row_index, column_index]
             raw_value = raw_matrix.iloc[row_index, column_index]
             metric = metric_matrix.iloc[row_index, column_index]
             available = pd.notna(raw_value)
-            display_text[row_index, column_index] = "×" if not available else f"{percentile:.0f}"
+            display_text[row_index, column_index] = "" if not available else f"{percentile:.0f}"
             customdata[row_index, column_index, 0] = (
-                "Unavailable" if not available else f"{float(raw_value):.4f}"
+                "" if not available else f"{float(raw_value):.4f}"
             )
-            customdata[row_index, column_index, 1] = "Unavailable" if pd.isna(metric) else str(metric)
-            customdata[row_index, column_index, 2] = "Available" if available else "Unavailable"
+            customdata[row_index, column_index, 1] = "" if pd.isna(metric) else str(metric)
     fig = go.Figure(
         go.Heatmap(
             z=percentile_matrix.to_numpy(dtype=float),
-            x=[DATASET_SHORT_LABELS[dataset] for dataset in percentile_matrix.columns],
+            x=[DATASET_TICK_LABELS[dataset] for dataset in percentile_matrix.columns],
             y=[model_label(model) for model in percentile_matrix.index],
             text=display_text,
             texttemplate="%{text}",
@@ -1102,8 +940,7 @@ def percentile_heatmap(
             hovertemplate=(
                 "Method=%{y}<br>Dataset=%{x}<br>"
                 "Within-dataset percentile=%{z:.1f}<br>"
-                "Raw value=%{customdata[0]}<br>Metric=%{customdata[1]}<br>"
-                "Status=%{customdata[2]}<extra></extra>"
+                "Raw value=%{customdata[0]}<br>Metric=%{customdata[1]}<extra></extra>"
             ),
             hoverongaps=False,
         )
@@ -1112,12 +949,12 @@ def percentile_heatmap(
     if len(missing_rows):
         fig.add_trace(
             go.Scatter(
-                x=[DATASET_SHORT_LABELS[percentile_matrix.columns[index]] for index in missing_columns],
+                x=[DATASET_TICK_LABELS[percentile_matrix.columns[index]] for index in missing_columns],
                 y=[model_label(percentile_matrix.index[index]) for index in missing_rows],
                 mode="markers",
-                marker=dict(symbol="x", size=9, color="#7A858E", line=dict(width=1)),
+                marker=dict(symbol="x", size=8, color="#8A949C", line=dict(width=1)),
                 showlegend=False,
-                hovertemplate="Method=%{y}<br>Dataset=%{x}<br>Status=Unavailable<extra></extra>",
+                hoverinfo="skip",
             )
         )
     fig.update_layout(title=title)
@@ -1132,7 +969,7 @@ def prediction_heatmap(models: Sequence[str] | None) -> go.Figure:
     return percentile_heatmap(
         values,
         models,
-        title="Prediction across tasks (within-dataset percentiles; raw scores on hover)",
+        title="Prediction across tasks",
         colorscale=PREDICTION_SCALE,
         raw_column="score",
         metric_column="metric_label",
@@ -1191,29 +1028,18 @@ def robustness_figure(dataset: str, models: Sequence[str] | None) -> go.Figure:
                 marker=dict(size=6, symbol=index % 8),
                 customdata=np.repeat(row.robustness_auc, len(levels)),
                 hovertemplate=(
-                    f"Method={row.method}<br>Additive count-noise λ=%{{x:.1f}}<br>"
-                    "Task score=%{y:.4f}<br>Raw score-vs-noise AUC=%{customdata:.4f}<extra></extra>"
+                    f"Method={row.method}<br>Input-noise level λ=%{{x:.1f}}<br>"
+                    "Task score=%{y:.4f}<br>Area under task-score-versus-noise curve=%{customdata:.4f}<extra></extra>"
                 ),
             )
         )
     metric = metric_name(frame["metric"].dropna().iloc[0])
     fig.update_layout(
-        title=f"{DATASET_SHORT_LABELS.get(dataset, dataset)} robustness to noisy neural inputs",
+        title="Robustness",
         hovermode="closest",
         showlegend=len(frame) <= 12,
     )
-    if len(frame) > 12:
-        fig.add_annotation(
-            text="Use the method comparison control to isolate curves; every curve is named on hover.",
-            x=0,
-            y=1.08,
-            xref="paper",
-            yref="paper",
-            showarrow=False,
-            xanchor="left",
-            font=dict(size=11, color=MUTED_COLOR),
-        )
-    fig.update_xaxes(title="Additive Poisson count-noise level λ", tickvals=[0, 0.2, 0.4, 0.6, 0.8])
+    fig.update_xaxes(title="Input-noise level λ", tickvals=[0, 0.2, 0.4, 0.6, 0.8])
     fig.update_yaxes(title=metric)
     return figure_layout(fig, height=540, legend_below=len(frame) <= 12)
 
@@ -1261,12 +1087,12 @@ def compute_figures(
         )
     )
     runtime.update_layout(
-        title=f"{DATASET_SHORT_LABELS.get(dataset, dataset)} training and inference time",
+        title="Training and inference time",
         barmode="group",
     )
     runtime.update_xaxes(title="Elapsed time (seconds, log scale)", type="log")
     runtime.update_yaxes(title="", showgrid=False)
-    figure_layout(runtime, height=max(470, 27 * len(frame) + 155))
+    figure_layout(runtime, height=max(470, 27 * len(frame) + 155), legend_below=True)
 
     memory = go.Figure()
     memory.add_trace(
@@ -1290,12 +1116,12 @@ def compute_figures(
         )
     )
     memory.update_layout(
-        title=f"{DATASET_SHORT_LABELS.get(dataset, dataset)} peak RAM and GPU memory",
+        title="Peak memory",
         barmode="group",
     )
     memory.update_xaxes(title="Memory (GB)")
     memory.update_yaxes(title="", showgrid=False)
-    figure_layout(memory, height=max(470, 27 * len(frame) + 155))
+    figure_layout(memory, height=max(470, 27 * len(frame) + 155), legend_below=True)
 
     table = frame[
         [
@@ -1350,22 +1176,11 @@ def feature_frame(dataset: str, models: Sequence[str] | None) -> pd.DataFrame:
 
 def feature_figures(
     dataset: str, models: Sequence[str] | None
-) -> tuple[go.Figure, go.Figure, pd.DataFrame]:
+) -> tuple[go.Figure, pd.DataFrame]:
     frame = feature_frame(dataset, models)
     if frame.empty:
-        columns = [
-            "method",
-            "validation_target",
-            "validation_metric",
-            "validation_score",
-            "shap_mean_value",
-            "shap_median_value",
-            "shap_min_value",
-            "shap_max_value",
-            "shap_fraction_positive",
-            "shap_fraction_negative",
-        ]
-        return empty_figure("No feature-attribution validation result is available."), empty_figure("No signed Kernel SHAP summary is available."), pd.DataFrame(columns=columns)
+        columns = ["method", "validation_target", "validation_metric", "validation_score"]
+        return empty_figure("No results for this selection."), pd.DataFrame(columns=columns)
     score_column, target, metric, reference = feature_spec(dataset)
     validation = frame.dropna(subset=["validation_score"]).sort_values(
         ["validation_score", "model_order"], ascending=[True, False]
@@ -1388,57 +1203,16 @@ def feature_figures(
             annotation_position="top",
         )
     validation_fig.update_layout(
-        title=f"{DATASET_SHORT_LABELS.get(dataset, dataset)} feature-attribution validation"
+        title="Feature-attribution validation"
     )
     validation_fig.update_xaxes(title=metric)
     validation_fig.update_yaxes(title="", showgrid=False)
     figure_layout(validation_fig, height=max(430, 25 * len(validation) + 145))
 
-    signed = frame.dropna(subset=["shap_mean_value"]).sort_values(
-        ["shap_mean_value", "model_order"], ascending=[True, False]
-    )
-    signed_colors = [FEATURE_COLOR if value >= 0 else NEGATIVE_COLOR for value in signed["shap_mean_value"]]
-    signed_fig = go.Figure(
-        go.Bar(
-            x=signed["shap_mean_value"],
-            y=signed["method"],
-            orientation="h",
-            marker=dict(color=signed_colors),
-            customdata=np.stack(
-                [
-                    signed["shap_median_value"],
-                    signed["shap_min_value"],
-                    signed["shap_max_value"],
-                    signed["shap_fraction_positive"],
-                ],
-                axis=-1,
-            ),
-            hovertemplate=(
-                "Method=%{y}<br>Mean signed value=%{x:.5g}<br>"
-                "Median=%{customdata[0]:.5g}<br>Range=[%{customdata[1]:.5g}, %{customdata[2]:.5g}]<br>"
-                "Fraction positive=%{customdata[3]:.3f}<extra></extra>"
-            ),
-        )
+    columns = ["method", "validation_target", "validation_metric", "validation_score"]
+    return validation_fig, round_numeric(
+        frame[columns].sort_values("validation_score", ascending=False)
     )
-    signed_fig.add_vline(x=0, line_color="#6F7882", line_width=1)
-    signed_fig.update_layout(title="Signed global Kernel SHAP summary")
-    signed_fig.update_xaxes(title="Mean signed contribution to task score")
-    signed_fig.update_yaxes(title="", showgrid=False)
-    figure_layout(signed_fig, height=max(430, 25 * len(signed) + 145))
-
-    columns = [
-        "method",
-        "validation_target",
-        "validation_metric",
-        "validation_score",
-        "shap_mean_value",
-        "shap_median_value",
-        "shap_min_value",
-        "shap_max_value",
-        "shap_fraction_positive",
-        "shap_fraction_negative",
-    ]
-    return validation_fig, signed_fig, round_numeric(frame[columns].sort_values("validation_score", ascending=False))
 
 
 def feature_heatmap(models: Sequence[str] | None) -> go.Figure:
@@ -1460,7 +1234,7 @@ def feature_heatmap(models: Sequence[str] | None) -> go.Figure:
     return percentile_heatmap(
         values,
         models,
-        title="Feature-attribution validation across tasks (within-dataset percentiles)",
+        title="Feature validation across tasks",
         colorscale=FEATURE_SCALE,
         raw_column="validation_score",
         metric_column="metric_label",
@@ -1478,9 +1252,6 @@ def trial_frame(dataset: str, models: Sequence[str] | None) -> pd.DataFrame:
     frame = add_method_columns(frame)
     frame["method"] = frame["model"].map(lambda model: dataset_model_label(model, dataset))
     frame = frame.rename(columns={"perturbation_auc": "corrupted_trial_auc"})
-    frame["converged"] = frame["converged"].fillna(False).astype(str).str.lower().map(
-        {"true": "Yes", "1": "Yes", "false": "No", "0": "No"}
-    ).fillna("No")
     return round_numeric(frame)
 
 
@@ -1491,29 +1262,13 @@ def trial_detection_figure(dataset: str, models: Sequence[str] | None) -> go.Fig
     frame = frame.dropna(subset=["corrupted_trial_auc"]).sort_values(
         ["corrupted_trial_auc", "model_order"], ascending=[True, False]
     )
-    patterns = ["" if value == "Yes" else "/" for value in frame["converged"]]
     fig = go.Figure(
         go.Bar(
             x=frame["corrupted_trial_auc"],
             y=frame["method"],
             orientation="h",
-            marker=dict(color=TRIAL_COLOR, pattern=dict(shape=patterns)),
-            customdata=np.stack(
-                [
-                    frame["converged"],
-                    frame["iterations"],
-                    frame["final_error"],
-                    frame["shapley_mean_value"],
-                    frame["shapley_fraction_positive"],
-                ],
-                axis=-1,
-            ),
-            hovertemplate=(
-                "Method=%{y}<br>Corrupted-trial ROC-AUC=%{x:.4f}<br>"
-                "Converged=%{customdata[0]}<br>Permutations=%{customdata[1]:.0f}<br>"
-                "Final error=%{customdata[2]:.4f}<br>Mean signed trial value=%{customdata[3]:.5g}<br>"
-                "Fraction positive=%{customdata[4]:.3f}<extra></extra>"
-            ),
+            marker=dict(color=TRIAL_COLOR),
+            hovertemplate="Method=%{y}<br>Corrupted-trial ROC-AUC=%{x:.4f}<extra></extra>",
         )
     )
     fig.add_vline(
@@ -1524,7 +1279,7 @@ def trial_detection_figure(dataset: str, models: Sequence[str] | None) -> go.Fig
         annotation_position="top",
     )
     fig.update_layout(
-        title=f"{DATASET_SHORT_LABELS.get(dataset, dataset)} corrupted-trial detection"
+        title="Corrupted-trial detection"
     )
     fig.update_xaxes(title="ROC-AUC from negative trial value")
     fig.update_yaxes(title="", showgrid=False)
@@ -1537,7 +1292,7 @@ def trial_heatmap(models: Sequence[str] | None) -> go.Figure:
     return percentile_heatmap(
         values,
         models,
-        title="Corrupted-trial detection across tasks (within-dataset percentiles)",
+        title="Trial detection across tasks",
         colorscale=TRIAL_SCALE,
         raw_column="perturbation_auc",
         metric_column="metric_label",
@@ -1579,10 +1334,8 @@ def equality_bounds(*series: pd.Series) -> tuple[float, float]:
     return float(values.min() - padding), float(values.max() + padding)
 
 
-def trial_retrain_figures(
-    models: Sequence[str] | None,
-) -> tuple[go.Figure, go.Figure, go.Figure, pd.DataFrame]:
-    within, historical = retrain_frames(models)
+def trial_retrain_figures() -> tuple[go.Figure, go.Figure, go.Figure, pd.DataFrame]:
+    within, historical = retrain_frames(None)
     if within.empty:
         removal = empty_figure("No macaque within-session removal summary is available.")
         relation = empty_figure("No detection-versus-recovery summary is available.")
@@ -1600,11 +1353,11 @@ def trial_retrain_figures(
                     size=10,
                     line=dict(color="#FFFFFF", width=1),
                 ),
-                customdata=np.stack([within["method"], within["oracle"], within["recovery"]], axis=-1),
+                customdata=np.stack([within["method"], within["recovery"]], axis=-1),
                 hovertemplate=(
                     "Method=%{customdata[0]}<br>Mixed trials R²=%{x:.4f}<br>"
-                    "After trial-value removal R²=%{y:.4f}<br>Oracle removal R²=%{customdata[1]:.4f}<br>"
-                    "Recovery ΔR²=%{customdata[2]:+.4f}<extra></extra>"
+                    "After trial-value removal R²=%{y:.4f}<br>"
+                    "Recovery ΔR²=%{customdata[1]:+.4f}<extra></extra>"
                 ),
             )
         )
@@ -1626,9 +1379,9 @@ def trial_retrain_figures(
             bgcolor="rgba(255,255,255,0.88)",
             font=dict(size=12, color="#2E7D32" if removal_change >= 0 else NEGATIVE_COLOR),
         )
-        removal.update_layout(title="Macaque trial-value-guided removal")
-        removal.update_xaxes(title="Before filtering: mixed-trial test R²", range=[lower, upper])
-        removal.update_yaxes(title="After negative-value removal: test R²", range=[lower, upper])
+        removal.update_layout(title="Trial-value-guided removal")
+        removal.update_xaxes(title="Before removal: test R²", range=[lower, upper])
+        removal.update_yaxes(title="After removal: test R²", range=[lower, upper])
         figure_layout(removal, height=480)
 
         detection = active_rows(trial_shapley)
@@ -1683,7 +1436,7 @@ def trial_retrain_figures(
                 if pd.notna(rho)
                 else f"n = {len(relation_frame)}; select at least two methods for correlation"
             )
-            if not models and pd.notna(rho):
+            if pd.notna(rho):
                 relation_text += "<br>one-sided permutation P = 0.035"
             relation.add_annotation(
                 text=relation_text,
@@ -1697,9 +1450,9 @@ def trial_retrain_figures(
                 bgcolor="rgba(255,255,255,0.85)",
                 font=dict(size=12),
             )
-            relation.update_layout(title="Detection signal versus recovery after removal", showlegend=False)
-            relation.update_xaxes(title="Corrupted-trial detection ROC-AUC")
-            relation.update_yaxes(title="Recovery after removal (ΔR²)")
+            relation.update_layout(title="Detection and recovery", showlegend=False)
+            relation.update_xaxes(title="Detection ROC-AUC")
+            relation.update_yaxes(title="Recovery (ΔR²)")
             figure_layout(relation, height=480)
 
     if historical.empty:
@@ -1742,17 +1495,17 @@ def trial_retrain_figures(
             bgcolor="rgba(255,255,255,0.88)",
             font=dict(size=12, color="#2E7D32" if historical_change >= 0 else NEGATIVE_COLOR),
         )
-        historical_fig.update_layout(title="Same-subject historical-trial selection")
-        historical_fig.update_xaxes(title="Current-session trials only: test R²", range=[lower, upper])
+        historical_fig.update_layout(title="Historical-trial selection")
+        historical_fig.update_xaxes(title="Current-session test R²", range=[lower, upper])
         historical_fig.update_yaxes(
-            title="Add nonnegative-valued historical trials: test R²",
+            title="Selected historical trials: test R²",
             range=[lower, upper],
         )
         figure_layout(historical_fig, height=480)
 
     table = within[
-        [column for column in ["model", "method", "mixed_full", "data_shapley", "oracle", "recovery"] if column in within]
-    ].copy() if not within.empty else pd.DataFrame(columns=["model", "method", "mixed_full", "data_shapley", "oracle", "recovery"])
+        [column for column in ["model", "method", "mixed_full", "data_shapley", "recovery"] if column in within]
+    ].copy() if not within.empty else pd.DataFrame(columns=["model", "method", "mixed_full", "data_shapley", "recovery"])
     historical_columns = ["model", "target_only", "all_sessions", "historical_selected"]
     if not historical.empty:
         table = table.merge(historical[historical_columns], on="model", how="outer")
@@ -1761,14 +1514,7 @@ def trial_retrain_figures(
     return removal, relation, historical_fig, round_numeric(table)
 
 
-def historical_trajectory_figure(models: Sequence[str] | None) -> go.Figure:
-    if models and "rnn" not in set(models):
-        return empty_figure(
-            "The Figure 5e held-out trajectory example uses RNN. "
-            "Include RNN in Compare methods or clear the method filter.",
-            height=430,
-        )
-
+def historical_trajectory_figure() -> go.Figure:
     frame = trial_historical_trajectories.copy()
     current_r2 = float(frame["current_only_r2"].iloc[0])
     historical_r2 = float(frame["historical_selected_r2"].iloc[0])
@@ -1784,7 +1530,7 @@ def historical_trajectory_figure(models: Sequence[str] | None) -> go.Figure:
         (
             "historical_selected_x",
             "historical_selected_y",
-            f"Current + nonnegative-valued historical trials<br>R² = {historical_r2:.2f}",
+            f"Selected historical trials<br>R² = {historical_r2:.2f}",
             0.64,
             2.5,
         ),
@@ -1901,7 +1647,7 @@ def historical_trajectory_figure(models: Sequence[str] | None) -> go.Figure:
 
     figure_layout(fig, height=510, legend_below=True)
     fig.update_layout(
-        title="Held-out target-session trajectories (RNN)",
+        title="Held-out trajectories · RNN",
         margin=dict(l=28, r=28, t=76, b=118),
         legend=dict(
             orientation="h",
@@ -1988,6 +1734,11 @@ def add_latent_color_columns(df: pd.DataFrame, dataset: str, color_mode: str) ->
 
 
 def latent_space_figure(dataset: str, model: str | None, color_mode: str) -> go.Figure:
+    if dataset == "mc_pacman":
+        return empty_figure(
+            "Cross-recording consistency is not available for this dataset.",
+            height=500,
+        )
     if not model:
         return empty_figure("Select an available method to view aligned coordinates.", height=500)
     samples = latent_samples[
@@ -1995,7 +1746,7 @@ def latent_space_figure(dataset: str, model: str | None, color_mode: str) -> go.
         & (latent_samples["model"].astype(str) == str(model))
     ].copy()
     if samples.empty:
-        return empty_figure("Figure 3-aligned display coordinates are unavailable for this entry.", height=500)
+        return empty_figure("No results for this selection.", height=500)
     for column in ["x", "y", "z"]:
         samples[column] = pd.to_numeric(samples[column], errors="coerce")
     samples = add_latent_color_columns(samples, dataset, color_mode).dropna(subset=["x", "y", "z"])
@@ -2140,9 +1891,9 @@ def latent_space_figure(dataset: str, model: str | None, color_mode: str) -> go.
         fig.update_layout(
             **{
                 scene_id: dict(
-                    xaxis=dict(title="Aligned dim. 1", range=[-extent, extent], showgrid=False, zeroline=False, showticklabels=False),
-                    yaxis=dict(title="Aligned dim. 2", range=[-extent, extent], showgrid=False, zeroline=False, showticklabels=False),
-                    zaxis=dict(title="Aligned dim. 3", range=[-extent, extent], showgrid=False, zeroline=False, showticklabels=False),
+                    xaxis=dict(range=[-extent, extent], visible=False),
+                    yaxis=dict(range=[-extent, extent], visible=False),
+                    zaxis=dict(range=[-extent, extent], visible=False),
                     aspectmode="cube",
                     bgcolor="#FFFFFF",
                     camera=dict(eye=dict(x=1.5, y=1.4, z=1.0)),
@@ -2155,15 +1906,25 @@ def latent_space_figure(dataset: str, model: str | None, color_mode: str) -> go.
         & (score_rows["model"].astype(str) == str(model))
     ]
     score = pd.to_numeric(score_rows.get("mean_r2"), errors="coerce").dropna()
-    suffix = "" if score.empty else f" · latent-consistency R² = {float(score.iloc[0]):.3f}"
+    title = model_label(model)
+    if not score.empty:
+        title += f" · R² = {float(score.iloc[0]):.3f}"
     fig.update_layout(
-        title=f"{model_label(model)} Figure 3-aligned representations{suffix}",
-        height=760 if rows > 1 else 540,
+        title=title,
+        height=700 if rows > 1 else 500,
         paper_bgcolor="#FFFFFF",
         plot_bgcolor="#FFFFFF",
-        margin=dict(l=8, r=8, t=82, b=105),
+        margin=dict(l=8, r=8, t=72, b=88),
         font=dict(family="Arial, Helvetica, sans-serif", size=12, color=TEXT_COLOR),
-        legend=dict(orientation="h", yanchor="top", y=-0.07, xanchor="left", x=0, title=condition_name),
+        legend=dict(
+            orientation="h",
+            yanchor="top",
+            y=-0.04,
+            xanchor="center",
+            x=0.5,
+            entrywidth=46,
+            entrywidthmode="pixels",
+        ),
     )
     fig.for_each_annotation(lambda annotation: annotation.update(font=dict(size=12, color="#526171")))
     return fig
@@ -2191,7 +1952,7 @@ def consistency_figures(
     frame = consistency_frame(dataset, models)
     if frame.empty:
         message = (
-            "Cross-recording latent consistency is not defined for MC PacMan."
+            "Cross-recording consistency is not available for this dataset."
             if dataset == "mc_pacman"
             else "No latent-consistency result is available for this selection."
         )
@@ -2212,8 +1973,8 @@ def consistency_figures(
             ),
         )
     )
-    bar_fig.update_layout(title=f"{DATASET_SHORT_LABELS.get(dataset, dataset)} latent consistency")
-    bar_fig.update_xaxes(title="Symmetric linear-alignment R²", range=[0, 1.02])
+    bar_fig.update_layout(title="Latent consistency")
+    bar_fig.update_xaxes(title="Latent-consistency R²", range=[0, 1.02])
     bar_fig.update_yaxes(title="", showgrid=False)
     figure_layout(bar_fig, height=max(400, 27 * len(bar) + 145))
     columns = ["method", "latent_consistency_r2", "n_recordings", "latent_dim", "n_pairwise"]
@@ -2235,11 +1996,11 @@ def consistency_heatmap(models: Sequence[str] | None) -> go.Figure:
     for row in range(pivot.shape[0]):
         for column in range(pivot.shape[1]):
             value = pivot.iloc[row, column]
-            text[row, column] = "×" if pd.isna(value) else f"{value:.2f}"
+            text[row, column] = "" if pd.isna(value) else f"{value:.2f}"
     fig = go.Figure(
         go.Heatmap(
             z=pivot.to_numpy(dtype=float),
-            x=[DATASET_SHORT_LABELS[dataset] for dataset in pivot.columns],
+            x=[DATASET_TICK_LABELS[dataset] for dataset in pivot.columns],
             y=[model_label(model) for model in pivot.index],
             text=text,
             texttemplate="%{text}",
@@ -2255,149 +2016,20 @@ def consistency_heatmap(models: Sequence[str] | None) -> go.Figure:
     if len(missing_rows):
         fig.add_trace(
             go.Scatter(
-                x=[DATASET_SHORT_LABELS[pivot.columns[index]] for index in missing_columns],
+                x=[DATASET_TICK_LABELS[pivot.columns[index]] for index in missing_columns],
                 y=[model_label(pivot.index[index]) for index in missing_rows],
                 mode="markers",
-                marker=dict(symbol="x", size=9, color="#7A858E", line=dict(width=1)),
+                marker=dict(symbol="x", size=8, color="#8A949C", line=dict(width=1)),
                 showlegend=False,
-                hovertemplate="Method=%{y}<br>Dataset=%{x}<br>Status=Unavailable<extra></extra>",
+                hoverinfo="skip",
             )
         )
-    fig.update_layout(title="Cross-recording latent consistency across tasks")
+    fig.update_layout(title="Latent consistency across tasks")
     fig.update_xaxes(title="", side="top", showgrid=False)
     fig.update_yaxes(title="", showgrid=False)
     return heatmap_layout(fig, height=max(470, 27 * len(pivot) + 180))
 
 
-def analysis_status(model: str, dataset: str, analysis: str) -> tuple[str, str]:
-    if analysis == "prediction":
-        available = row_exists(present_rows(prediction), model, dataset)
-        return ("Available", "") if available else ("Unavailable", missing_reason(analysis, model, dataset))
-    if analysis == "robustness":
-        available = row_exists(present_rows(robustness), model, dataset)
-        return ("Available", "") if available else ("Unavailable", missing_reason("prediction", model, dataset))
-    if analysis == "compute":
-        available = row_exists(present_rows(scalability), model, dataset)
-        return ("Available", "") if available else ("Unavailable", missing_reason("prediction", model, dataset))
-    if analysis == "consistency":
-        if dataset == "mc_pacman":
-            return "Not defined", "MC PacMan has no cross-recording consistency cohort."
-        if model not in CONSISTENCY_ELIGIBLE:
-            return "Not supported", "No predefined common three-dimensional representation for this analysis."
-        available = row_exists(active_rows(consistency), model, dataset)
-        return ("Available", "") if available else ("Unavailable", missing_reason(analysis, model, dataset))
-    if analysis == "feature":
-        if model == "marble":
-            if dataset == "allen_neuropixels":
-                return (
-                    "Unavailable",
-                    "MARBLE exceeded the host-memory allocation before feature attribution.",
-                )
-            return (
-                "Not supported",
-                "Masked-input evaluation changes MARBLE's transductive graph construction.",
-            )
-        if model not in FEATURE_ELIGIBLE:
-            return "Not supported", "No predefined feature-attribution interface."
-        available = row_exists(active_rows(neuron_shap), model, dataset)
-        return ("Available", "") if available else ("Unavailable", missing_reason(analysis, model, dataset))
-    if analysis == "trial":
-        if model not in TRIAL_ELIGIBLE:
-            return "Not supported", "The fixed-output/lightweight-rescoring Data Shapley rule is unavailable for this method."
-        available = row_exists(active_rows(trial_shapley), model, dataset)
-        return ("Available", "") if available else ("Unavailable", missing_reason(analysis, model, dataset))
-    raise ValueError(f"Unknown analysis: {analysis}")
-
-
-def methods_frame(dataset: str, models: Sequence[str] | None) -> pd.DataFrame:
-    rows = []
-    for model in selected_models(models):
-        pred_rows = prediction[
-            (prediction["model"].astype(str) == model)
-            & (prediction["dataset"].astype(str) == str(dataset))
-        ]
-        pred = pred_rows.iloc[0] if not pred_rows.empty else pd.Series(dtype=object)
-        statuses = {}
-        notes = []
-        for analysis in ["prediction", "robustness", "compute", "consistency", "feature", "trial"]:
-            status, note = analysis_status(model, dataset, analysis)
-            statuses[analysis] = status
-            if note and status != "Available":
-                notes.append(f"{TABLE_LABELS.get(analysis + '_status', analysis.title())}: {note}")
-        rows.append(
-            {
-                "method": model_label(model),
-                "workflow": prediction_workflow(model, pred.get("decoder"), pred.get("status")),
-                "readout": readout_label(pred.get("decoder")),
-                "hardware": "CPU" if model in CPU_ONLY_MODELS else "GPU",
-                "prediction_status": statuses["prediction"],
-                "robustness_status": statuses["robustness"],
-                "compute_status": statuses["compute"],
-                "consistency_status": statuses["consistency"],
-                "feature_status": statuses["feature"],
-                "trial_status": statuses["trial"],
-                "coverage_notes": " ".join(notes) if notes else "Complete for configured analyses.",
-                "model_order": MODEL_INDEX[model],
-            }
-        )
-    return pd.DataFrame(rows).sort_values("model_order").drop(columns="model_order")
-
-
-def coverage_cards(dataset: str, models: Sequence[str] | None) -> list[html.Div]:
-    chosen = selected_models(models)
-    cards = []
-    specs = [
-        ("Prediction", "prediction", set(MODELS), "prediction"),
-        ("Robustness", "robustness", set(MODELS), "robustness"),
-        ("Computational cost", "compute", set(MODELS), "compute"),
-        ("Latent consistency", "consistency", CONSISTENCY_ELIGIBLE, "consistency"),
-        ("Feature attribution", "feature", FEATURE_ELIGIBLE, "feature"),
-        ("Trial valuation", "trial", TRIAL_ELIGIBLE, "trial"),
-    ]
-    accents = {
-        "prediction": "prediction",
-        "robustness": "robustness",
-        "compute": "compute",
-        "consistency": "consistency",
-        "feature": "feature",
-        "trial": "trial",
-    }
-    for label, analysis, eligible, accent in specs:
-        if analysis == "consistency" and dataset == "mc_pacman":
-            cards.append(metric_card(label, "Not defined", "No cross-recording cohort.", accents[accent]))
-            continue
-        configured = [model for model in chosen if model in eligible]
-        available = sum(analysis_status(model, dataset, analysis)[0] == "Available" for model in configured)
-        unsupported = len(chosen) - len(configured)
-        detail = f"{len(configured)} configured"
-        if unsupported:
-            detail += f"; {unsupported} outside analysis"
-        cards.append(metric_card(label, f"{available}/{len(configured)}", detail, accents[accent]))
-    return cards
-
-
-def release_detail() -> str:
-    stable_parts = []
-    manuscript_version = release_manifest.get("manuscript_working_version")
-    figure_set = release_manifest.get("figure_set")
-    if manuscript_version:
-        version_label = str(manuscript_version).replace("_", " ")
-        stable_parts.append(
-            version_label
-            if version_label.lower().startswith("manuscript ")
-            else f"manuscript {version_label}"
-        )
-    if figure_set:
-        stable_parts.append(str(figure_set))
-    if stable_parts:
-        return " Release alignment: " + "; ".join(stable_parts) + "."
-    for key in ["generated_at", "release_date", "created_at", "timestamp"]:
-        value = release_manifest.get(key)
-        if value:
-            return f" Release manifest: {value}."
-    return ""
-
-
 app = Dash(__name__, title="BEND-BCI Interactive Benchmark")
 server = app.server
 
@@ -2415,39 +2047,41 @@ app.layout = html.Div(
             [
                 html.Div(
                     [
-                        html.Div("Tang Lab · Interactive companion to Figures 2–5", className="eyebrow"),
-                        html.H1("BEND-BCI Interactive Benchmark"),
-                        html.P(
-                            "Compare held-out task prediction, robustness to noisy neural inputs, computational cost and cross-recording latent consistency across 23 neural decoding methods. Feature attribution and trial valuation are reported as separate validation-checked diagnostics.",
-                            className="lede",
-                        ),
+                        html.A("BEND-BCI", href="#", className="site-brand"),
                         html.Nav(
                             [
                                 html.A(
-                                    "Benchmark repository",
+                                    "Code & data",
                                     href="https://github.com/TangLab-UBC/behavior_benchmarking",
                                     target="_blank",
                                     rel="noopener noreferrer",
                                 ),
-                                html.A(
-                                    "Hugging Face Space",
-                                    href="https://huggingface.co/spaces/Tang-Lab/benchdash",
-                                    target="_blank",
-                                    rel="noopener noreferrer",
+                                html.Span(
+                                    ["Paper", html.Small("coming soon")],
+                                    className="nav-placeholder",
+                                    title="Manuscript link will be added on release.",
+                                ),
+                                html.Span(
+                                    ["Submit a model", html.Small("planned")],
+                                    className="nav-placeholder",
+                                    title="A model-submission workflow is planned.",
                                 ),
                             ],
                             className="hero-links",
-                            **{"aria-label": "Project links"},
+                            **{"aria-label": "Resources"},
                         ),
                     ],
-                    className="hero-copy",
+                    className="site-nav",
                 ),
                 html.Div(
                     [
-                        html.Span("Six reported views", className="hero-stat-value"),
-                        html.Span("Four selection measurements + two diagnostics", className="hero-stat-label"),
+                        html.H1("Neural decoder selection beyond held-out performance"),
+                        html.P(
+                            "Interactive results for 23 methods across motor, visual, speech and spatial decoding tasks.",
+                            className="lede",
+                        ),
                     ],
-                    className="hero-stat",
+                    className="hero-copy",
                 ),
             ],
             className="hero",
@@ -2469,26 +2103,26 @@ app.layout = html.Div(
                 ),
                 html.Div(
                     [
-                        html.Label("Compare methods", htmlFor="method-filter"),
+                        html.Label("Methods", htmlFor="method-filter"),
                         dcc.Dropdown(
                             id="method-filter",
                             options=[{"label": model_label(model), "value": model} for model in FIGURE_MODEL_ORDER],
                             value=[],
                             multi=True,
-                            placeholder="All 23 methods",
+                            placeholder="All methods",
                         ),
-                        html.Div("Leave empty to show all methods.", className="control-help"),
                     ],
                     className="control method-control",
                 ),
             ],
             className="toolbar",
         ),
-        dcc.Tabs(
-            id="tabs",
-            value="overview",
-            className="tabs",
-            children=[
+        html.Main(
+            dcc.Tabs(
+                id="tabs",
+                value="overview",
+                className="tabs",
+                children=[
                 dcc.Tab(
                     label="Overview",
                     value="overview",
@@ -2496,35 +2130,34 @@ app.layout = html.Div(
                     selected_className="tab tab-selected",
                     children=[
                         panel(
-                            "Held-out task prediction",
+                            "Predictive performance",
                             html.Div(id="overview-cards", className="metric-strip"),
-                            html.Div(id="overview-coverage", className="coverage-note"),
                             html.Div(
                                 [
                                     graph_box("prediction-ranking", "Raw held-out prediction scores for the selected dataset."),
-                                    graph_box("prediction-heatmap", "Within-dataset prediction percentiles across five tasks."),
+                                    graph_box(
+                                        "prediction-heatmap",
+                                        "Within-dataset prediction percentiles across five tasks.",
+                                        class_name="heatmap-graph",
+                                    ),
                                 ],
                                 className="chart-grid two",
                             ),
-                            details_table("View and filter prediction rows", dataframe_table("overview-table", page_size=23)),
+                            details_table("View data", dataframe_table("overview-table", page_size=23)),
                             source_link("clean_prediction_summary.csv"),
-                            eyebrow="Figure 2 · Prediction",
-                            subtitle="Raw accuracy and R² remain visible within each task. The cross-task matrix uses within-dataset percentiles, with the raw task-specific value and metric on hover.",
+                            subtitle="Raw task scores are shown by dataset; the cross-dataset view uses within-dataset percentiles.",
                             class_name="axis-prediction",
                         ),
                         panel(
-                            "Robustness to noisy neural inputs",
-                            html.Div(id="robustness-coverage", className="coverage-note"),
-                            graph_box("robustness-curve", "Task score as additive Poisson count-noise level increases."),
-                            details_table("View and filter robustness rows", dataframe_table("robustness-table", page_size=23)),
+                            "Robustness to noisy inputs",
+                            graph_box("robustness-curve", "Task score as input-noise level increases."),
+                            details_table("View data", dataframe_table("robustness-table", page_size=23)),
                             source_link("robustness_summary.csv"),
-                            eyebrow="Figure 2 · Robustness",
-                            subtitle="The trained model and targets are held fixed while additive Poisson count noise is applied to test inputs at λ = 0, 0.2, 0.4, 0.6 and 0.8. The reported summary is the raw task-score-versus-noise area; it is unbounded, may be negative and is not normalized to λ = 0.",
+                            subtitle="Performance as controlled noise is added to held-out neural inputs.",
                             class_name="axis-robustness",
                         ),
                         panel(
                             "Computational cost",
-                            html.Div(id="compute-coverage", className="coverage-note"),
                             html.Div(
                                 [
                                     graph_box("runtime-bars", "Training and complete-held-out-split inference times."),
@@ -2532,10 +2165,9 @@ app.layout = html.Div(
                                 ],
                                 className="chart-grid two",
                             ),
-                            details_table("View and filter computational-cost rows", dataframe_table("compute-table", page_size=23)),
+                            details_table("View data", dataframe_table("compute-table", page_size=23)),
                             source_link("scalability_summary.csv"),
-                            eyebrow="Figure 2 · Supplementary Figure 11",
-                            subtitle="Figure 2 reports the macaque-reaching resource block; the other selected datasets are per-dataset extensions reported in Supplementary Figure 11. Training time includes required training-side representation extraction and readout fitting. Inference time is one complete pass over the held-out split, including readout prediction and excluding metric calculation. CPU-only methods have no GPU-memory value.",
+                            subtitle="Training time, inference time, RAM and GPU memory under the benchmark protocol.",
                             class_name="axis-compute",
                         ),
                     ],
@@ -2547,13 +2179,12 @@ app.layout = html.Div(
                     selected_className="tab tab-selected",
                     children=[
                         panel(
-                            "Cross-recording latent consistency",
-                            html.Div(id="consistency-coverage", className="coverage-note"),
+                            "Representation consistency across recordings",
                             html.Div(
                                 [
                                     html.Div(
                                         [
-                                            html.Label("Representation", htmlFor="consistency-method"),
+                                            html.Label("Method", htmlFor="consistency-method"),
                                             dcc.Dropdown(id="consistency-method", clearable=False),
                                         ],
                                         className="control",
@@ -2569,25 +2200,21 @@ app.layout = html.Div(
                                 ],
                                 className="inline-controls",
                             ),
-                            html.Div(
-                                [
-                                    html.Strong("Display-coordinate note: "),
-                                    "Representations are centered and whitened within recording and transformed into the Figure 3 display frame. The displayed coordinates illustrate matched structure; the reported symmetric R² is computed from bidirectional intercept-free linear alignment of task landmarks.",
-                                ],
-                                className="method-note",
-                            ),
-                            graph_box("latent-space", "Figure 3-aligned latent representations for each recording.", class_name="latent-graph"),
+                            graph_box("latent-space", "Aligned latent representations for each recording.", class_name="latent-graph"),
                             html.Div(
                                 [
                                     graph_box("consistency-bars", "Latent-consistency R-squared for the selected dataset."),
-                                    graph_box("consistency-heatmap", "Latent-consistency R-squared across four tasks."),
+                                    graph_box(
+                                        "consistency-heatmap",
+                                        "Latent-consistency R-squared across four tasks.",
+                                        class_name="heatmap-graph",
+                                    ),
                                 ],
                                 className="chart-grid two",
                             ),
-                            details_table("View and filter latent-consistency rows", dataframe_table("consistency-table", page_size=12)),
+                            details_table("View data", dataframe_table("consistency-table", page_size=12)),
                             source_link("consistency_summary.csv"),
-                            eyebrow="Figure 3",
-                            subtitle="Latent consistency asks whether matched task-defined landmarks are linearly alignable across sessions, participants or independent simulations. It does not measure decoder transfer or identify a unique latent coordinate system.",
+                            subtitle="Plots show whitened latent spaces aligned to a common display frame. Consistency measures linear alignment of matched task landmarks across recordings, participants or simulations.",
                             class_name="axis-consistency",
                         )
                     ],
@@ -2600,27 +2227,24 @@ app.layout = html.Div(
                     children=[
                         panel(
                             "Feature-attribution validation",
-                            html.Div(id="feature-coverage", className="coverage-note"),
                             html.Div(
                                 [
                                     graph_box("feature-validation-bars", "Feature-attribution validation metric for the selected dataset."),
-                                    graph_box("feature-signed-bars", "Mean signed global Kernel SHAP values for the selected dataset."),
+                                    graph_box(
+                                        "feature-heatmap",
+                                        "Within-dataset feature-attribution validation percentiles across tasks.",
+                                        class_name="heatmap-graph",
+                                    ),
                                 ],
                                 className="chart-grid two",
                             ),
-                            graph_box("feature-heatmap", "Within-dataset feature-attribution validation percentiles across tasks."),
                             html.Div(
-                                [
-                                    html.Strong("Metric interpretation: "),
-                                    html.Span(id="feature-definition"),
-                                    " Validation scores and signed contribution summaries are distinct quantities. Signed values are preserved throughout; no absolute-value ranking is applied.",
-                                ],
+                                html.Span(id="feature-definition"),
                                 className="method-note",
                             ),
-                            details_table("View validation and signed Kernel SHAP summaries", dataframe_table("feature-table", page_size=23)),
+                            details_table("View data", dataframe_table("feature-table", page_size=23)),
                             source_link("neuron_shap_summary.csv"),
-                            eyebrow="Figure 4",
-                            subtitle="Global Kernel SHAP estimates each neural feature’s signed contribution to the task score. Dataset-specific validation tests agreement with a constructed control, known simulated feature class or independently measured biological tuning proxy.",
+                            subtitle="Agreement with predefined, dataset-specific validation targets.",
                             class_name="axis-feature",
                         )
                     ],
@@ -2632,32 +2256,31 @@ app.layout = html.Div(
                     selected_className="tab tab-selected",
                     children=[
                         panel(
-                            "Controlled corrupted-trial detection",
-                            html.Div(id="trial-coverage", className="coverage-note"),
-                            html.Div(id="trial-convergence", className="convergence-note"),
+                            "Corrupted-trial detection",
                             html.Div(
                                 [
                                     graph_box("trial-detection-bars", "Corrupted-trial detection ROC-AUC for the selected dataset."),
-                                    graph_box("trial-heatmap", "Within-dataset corrupted-trial detection percentiles across tasks."),
+                                    graph_box(
+                                        "trial-heatmap",
+                                        "Within-dataset corrupted-trial detection percentiles across tasks.",
+                                        class_name="heatmap-graph",
+                                    ),
                                 ],
                                 className="chart-grid two",
                             ),
                             html.Div(
                                 [
-                                    html.Strong("Controlled assay: "),
-                                    "Approximately one third of training trials were rotated by 75° in the full population-activity space while targets were unchanged. ROC-AUC uses negative trial value as the corruption-detection score. Hatched bars did not meet the TMC convergence threshold; they remain visible and are not counted as missing.",
+                                    "One third of training trials were rotated 75° in population-activity space while targets were unchanged. ROC-AUC uses negative trial value as the detection score.",
                                 ],
                                 className="method-note",
                             ),
-                            details_table("View detection, convergence and signed Data Shapley summaries", dataframe_table("trial-table", page_size=23)),
+                            details_table("View data", dataframe_table("trial-table", page_size=23)),
                             source_link("trial_shapley_summary.csv"),
-                            eyebrow="Figure 5a",
-                            subtitle="Data Shapley assigns each candidate training trial a signed marginal contribution to a specified held-out decoding utility. Values are model-, readout-, split- and metric-specific.",
+                            subtitle="ROC-AUC measures whether lower trial values identify training trials with rotated neural activity.",
                             class_name="axis-trial",
                         ),
                         panel(
-                            "Macaque intervention case studies",
-                            html.Div(intervention_coverage_note(), className="method-note caveat-note"),
+                            "Macaque center-out reaching training-data interventions",
                             html.Div(
                                 [
                                     graph_box("trial-removal", "Held-out R-squared before and after trial-value-guided corrupted-trial removal."),
@@ -2671,69 +2294,32 @@ app.layout = html.Div(
                                 "Held-out RNN target-session trajectories for ground truth, current-session training, and nonnegative-valued historical-trial selection.",
                                 class_name="historical-trajectory-graph",
                             ),
-                            details_table("View within-session removal and historical-selection rows", dataframe_table("trial-retrain-table", page_size=17)),
+                            details_table("View data", dataframe_table("trial-retrain-table", page_size=17)),
                             html.Div(
                                 [
-                                    source_link("trial_shapley_retrain_summary.csv", "Intervention summary CSV"),
-                                    source_link("trial_historical_trajectories.csv", "Figure 5e trajectory CSV"),
+                                    source_link("trial_shapley_retrain_summary.csv", "Summary CSV"),
+                                    source_link("trial_historical_trajectories.csv", "RNN trajectory CSV"),
                                 ],
                                 className="download-grid panel-downloads",
                             ),
-                            eyebrow="Figure 5b–e",
-                            subtitle="The within-session case study removes negative-valued corrupted trials and retrains each decoder. The historical-selection case study retains current-session trials and adds nonnegative-valued trials from earlier sessions in a shared M1 feature space.",
+                            subtitle="Removing negative-valued trials improved 13 of 17 methods (mean R² 0.775→0.797). Selecting nonnegative-valued historical trials raised mean held-out R² to 0.617, versus 0.532 for current-only training and 0.546 for all-session pooling.",
                             class_name="axis-trial",
                         ),
                     ],
                 ),
-                dcc.Tab(
-                    label="Methods & coverage",
-                    value="methods",
-                    className="tab",
-                    selected_className="tab tab-selected",
-                    children=[
-                        panel(
-                            "Prediction workflows and analysis coverage",
-                            html.Div(id="coverage-cards", className="metric-strip coverage-cards"),
-                            html.Div(
-                                [
-                                    html.Strong("Prediction workflows: "),
-                                    "Each method–dataset cell follows one of three paper-defined paths: predictions generated directly by the trained model, a method-specific mapping from learned outputs to benchmark targets, or a shared ridge/logistic readout on fixed model outputs. The exact path and implementation can vary by dataset.",
-                                ],
-                                className="method-note",
-                            ),
-                            dataframe_table("methods-table", page_size=23, max_height="760px"),
-                            html.Div(
-                                [
-                                    html.Strong("Coverage terminology: "),
-                                    "Available means a completed summary is bundled. Unavailable means a configured analysis did not produce a completed result. Not supported means the method was outside a predefined analysis interface. Not defined means the dataset has no corresponding analysis cohort.",
-                                ],
-                                className="method-note",
-                            ),
-                            html.Div(
-                                [
-                                    source_link("clean_prediction_summary.csv", "Prediction CSV"),
-                                    source_link("robustness_summary.csv", "Robustness CSV"),
-                                    source_link("consistency_summary.csv", "Consistency CSV"),
-                                    source_link("scalability_summary.csv", "Cost CSV"),
-                                    source_link("neuron_shap_summary.csv", "Feature-attribution CSV"),
-                                    source_link("trial_shapley_summary.csv", "Trial-valuation CSV"),
-                                    source_link("trial_shapley_retrain_summary.csv", "Intervention CSV"),
-                                ],
-                                className="download-grid",
-                            ),
-                            eyebrow="Methods and provenance",
-                            subtitle="Coverage is shown per method and selected dataset. Unsupported and failed entries remain explicit so chart denominators can be interpreted.",
-                            class_name="axis-methods",
-                        )
-                    ],
-                ),
-            ],
+                ],
+            ),
+            className="main-content",
         ),
         html.Footer(
             [
-                html.Strong("Data provenance. "),
-                "Dashboard tables are synchronized from the paper/results exports used to generate the current Figures 2–5 and Supplementary Figures. Latent coordinates are Figure-3-aligned display coordinates exported from the same analysis artifacts; display transforms do not change the reported consistency scores.",
-                release_detail(),
+                html.Span("BEND-BCI · Tang Lab"),
+                html.A(
+                    "Code & data",
+                    href="https://github.com/TangLab-UBC/behavior_benchmarking",
+                    target="_blank",
+                    rel="noopener noreferrer",
+                ),
             ],
             className="provenance-footer",
         ),
@@ -2744,16 +2330,13 @@ app.layout = html.Div(
 
 @app.callback(
     Output("overview-cards", "children"),
-    Output("overview-coverage", "children"),
     Output("overview-table", "columns"),
     Output("overview-table", "data"),
     Output("prediction-ranking", "figure"),
     Output("prediction-heatmap", "figure"),
-    Output("robustness-coverage", "children"),
     Output("robustness-curve", "figure"),
     Output("robustness-table", "columns"),
     Output("robustness-table", "data"),
-    Output("compute-coverage", "children"),
     Output("runtime-bars", "figure"),
     Output("memory-bars", "figure"),
     Output("compute-table", "columns"),
@@ -2774,9 +2357,8 @@ def update_overview(dataset: str, models: list[str] | None):
         "inference_time_sec",
         "peak_ram_gb",
         "peak_vram_gb",
-        "prediction_status",
     ]
-    overview_table = frame.sort_values(
+    overview_table = frame.dropna(subset=["task_score"]).sort_values(
         ["task_score", "model_order"],
         ascending=[False, True],
         na_position="last",
@@ -2793,22 +2375,15 @@ def update_overview(dataset: str, models: list[str] | None):
         "robustness_auc", ascending=False
     )
     runtime, memory, compute_table = compute_figures(dataset, models)
-    chosen = selected_models(models)
-    prediction_available = int(frame["task_score"].notna().sum())
-    robustness_available = len(robustness_table)
-    compute_available = len(compute_table)
     return (
         overview_cards(dataset, models),
-        availability_note(prediction_available, len(chosen)),
         column_defs(overview_columns),
         records(round_numeric(overview_table)),
         prediction_ranking_figure(dataset, models),
         prediction_heatmap(models),
-        availability_note(robustness_available, len(chosen)),
         robustness_figure(dataset, models),
         column_defs(robustness_columns),
         records(round_numeric(robustness_table)),
-        availability_note(compute_available, len(chosen)),
         runtime,
         memory,
         column_defs(compute_table.columns),
@@ -2840,17 +2415,14 @@ def update_latent_color_control(dataset: str):
     Output("consistency-method", "options"),
     Output("consistency-method", "value"),
     Output("consistency-method", "disabled"),
-    Output("consistency-coverage", "children"),
     Input("dataset-filter", "value"),
     Input("method-filter", "value"),
     State("consistency-method", "value"),
 )
 def update_consistency_selector(dataset: str, models: list[str] | None, current: str | None):
     dataset = dataset or DATASETS[0]
-    chosen = selected_models(models)
-    eligible = [model for model in chosen if model in CONSISTENCY_ELIGIBLE]
     if dataset == "mc_pacman":
-        return [], None, True, "Not defined for MC PacMan: no cross-recording consistency cohort is configured."
+        return [], None, True
     frame = consistency_frame(dataset, models)
     latent_pairs = set(zip(latent_samples["model"].astype(str), latent_samples["dataset"].astype(str)))
     available = []
@@ -2862,8 +2434,7 @@ def update_consistency_selector(dataset: str, models: list[str] | None, current:
         ]
     options = [{"label": model_label(model), "value": model} for model in available]
     value = current if current in available else (available[0] if available else None)
-    note = availability_note(len(available), len(eligible), unsupported=len(chosen) - len(eligible))
-    return options, value, not bool(options), note
+    return options, value, not bool(options)
 
 
 @app.callback(
@@ -2895,10 +2466,8 @@ def update_consistency(
 
 
 @app.callback(
-    Output("feature-coverage", "children"),
     Output("feature-definition", "children"),
     Output("feature-validation-bars", "figure"),
-    Output("feature-signed-bars", "figure"),
     Output("feature-heatmap", "figure"),
     Output("feature-table", "columns"),
     Output("feature-table", "data"),
@@ -2907,21 +2476,26 @@ def update_consistency(
 )
 def update_feature(dataset: str, models: list[str] | None):
     dataset = dataset or DATASETS[0]
-    chosen = selected_models(models)
-    eligible = [model for model in chosen if model in FEATURE_ELIGIBLE]
-    frame = feature_frame(dataset, models)
-    validation_fig, signed_fig, table = feature_figures(dataset, models)
-    _column, target, metric, reference = feature_spec(dataset)
-    definition = f"{metric} quantifies agreement with {target.lower()}."
-    if reference == 0.5:
-        definition += " Chance ROC-AUC is 0.5."
+    validation_fig, table = feature_figures(dataset, models)
+    _column, _target, _metric, _reference = feature_spec(dataset)
+    if dataset == "allen_neuropixels":
+        definition = (
+            "Spearman’s ρ measures association with drifting-gratings orientation "
+            "selectivity, a biological proxy."
+        )
+    elif dataset == "ratinabox":
+        definition = (
+            "ROC-AUC measures whether place cells rank above head-direction and speed "
+            "cells. Chance ROC-AUC is 0.5."
+        )
     else:
-        definition += " Larger positive values indicate closer agreement; this proxy is not causal ground truth."
+        definition = (
+            "ROC-AUC measures whether recorded neural features rank above appended "
+            "synthetic controls. Chance ROC-AUC is 0.5."
+        )
     return (
-        feature_coverage_note(dataset, models),
         definition,
         validation_fig,
-        signed_fig,
         feature_heatmap(models),
         column_defs(table.columns),
         records(table),
@@ -2929,8 +2503,6 @@ def update_feature(dataset: str, models: list[str] | None):
 
 
 @app.callback(
-    Output("trial-coverage", "children"),
-    Output("trial-convergence", "children"),
     Output("trial-detection-bars", "figure"),
     Output("trial-heatmap", "figure"),
     Output("trial-table", "columns"),
@@ -2946,43 +2518,13 @@ def update_feature(dataset: str, models: list[str] | None):
 )
 def update_trial(dataset: str, models: list[str] | None):
     dataset = dataset or DATASETS[0]
-    chosen = selected_models(models)
-    eligible = [model for model in chosen if model in TRIAL_ELIGIBLE]
     frame = trial_frame(dataset, models)
-    table_columns = [
-        "method",
-        "corrupted_trial_auc",
-        "converged",
-        "iterations",
-        "final_error",
-        "perturbation_fraction",
-        "rotation_angle_deg",
-        "rotation_subspace_dim_spec",
-        "shapley_mean_value",
-        "shapley_median_value",
-        "shapley_min_value",
-        "shapley_max_value",
-        "shapley_fraction_positive",
-        "shapley_fraction_negative",
-    ]
+    table_columns = ["method", "corrupted_trial_auc"]
     table = frame[[column for column in table_columns if column in frame.columns]].sort_values(
         "corrupted_trial_auc", ascending=False
     ) if not frame.empty else pd.DataFrame(columns=table_columns)
-    all_trial = active_rows(trial_shapley)
-    converged_mask = all_trial["converged"].fillna(False).astype(str).str.lower().isin({"true", "1", "yes"})
-    converged = int(converged_mask.sum())
-    nonconverged = int(len(all_trial) - converged)
-    selected_converged = int((frame.get("converged", pd.Series(dtype=str)) == "Yes").sum())
-    selected_nonconverged = int(len(frame) - selected_converged)
-    removal, relation, historical, retrain_table = trial_retrain_figures(models)
+    removal, relation, historical, retrain_table = trial_retrain_figures()
     return (
-        availability_note(len(frame), len(eligible), unsupported=len(chosen) - len(eligible)),
-        (
-            f"Selected view: {selected_converged}/{len(frame)} summaries converged; "
-            f"{selected_nonconverged}/{len(frame)} did not. Bundled release overall: "
-            f"{converged}/{len(all_trial)} converged and {nonconverged}/{len(all_trial)} did not. "
-            "A non-converged summary remains visible when selected and is not treated as missing."
-        ),
         trial_detection_figure(dataset, models),
         trial_heatmap(models),
         column_defs(table.columns),
@@ -2990,24 +2532,10 @@ def update_trial(dataset: str, models: list[str] | None):
         removal,
         relation,
         historical,
-        historical_trajectory_figure(models),
+        historical_trajectory_figure(),
         column_defs(retrain_table.columns),
         records(retrain_table),
     )
 
-
-@app.callback(
-    Output("coverage-cards", "children"),
-    Output("methods-table", "columns"),
-    Output("methods-table", "data"),
-    Input("dataset-filter", "value"),
-    Input("method-filter", "value"),
-)
-def update_methods(dataset: str, models: list[str] | None):
-    dataset = dataset or DATASETS[0]
-    table = methods_frame(dataset, models)
-    return coverage_cards(dataset, models), column_defs(table.columns), records(table)
-
-
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=7860, debug=False)

assets/styles.css

@@ -1,18 +1,18 @@
 :root {
-  --ink: #17202a;
-  --muted: #607080;
-  --line: #d8e1e7;
-  --soft-line: #e9eef2;
+  --ink: #142535;
+  --muted: #60717f;
+  --line: #dce3e8;
+  --soft-line: #edf1f4;
   --paper: #ffffff;
-  --canvas: #f4f6f8;
+  --canvas: #f7f8f9;
   --prediction: #1565c0;
   --robustness: #2e7d32;
   --compute: #e65100;
   --consistency: #007c91;
   --feature: #6a51a3;
   --trial: #6a1b9a;
-  --shadow: 0 12px 34px rgba(24, 43, 59, 0.075);
-  --radius: 12px;
+  --shadow: 0 5px 18px rgba(24, 43, 59, 0.055);
+  --radius: 10px;
 }
 
 * {
@@ -27,7 +27,7 @@ body {
   margin: 0;
   background: var(--canvas);
   color: var(--ink);
-  font-family: Arial, Helvetica, sans-serif;
+  font-family: Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
   font-size: 15px;
   line-height: 1.5;
   text-rendering: optimizeLegibility;
@@ -57,50 +57,47 @@ p {
 
 .app-shell {
   min-height: 100vh;
-  padding: 20px 24px 34px;
+  padding: 0 28px 34px;
 }
 
 .hero,
 .toolbar,
 .tabs,
 .provenance-footer {
-  width: min(100%, 1540px);
+  width: min(100%, 1380px);
   margin-right: auto;
   margin-left: auto;
 }
 
 .hero {
-  position: relative;
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) minmax(210px, 280px);
-  gap: 36px;
-  align-items: end;
-  overflow: hidden;
-  padding: 36px 40px 34px;
-  border: 1px solid #173f59;
-  border-radius: 16px;
-  background:
-    radial-gradient(circle at 92% 12%, rgba(86, 180, 233, 0.18), transparent 34%),
-    linear-gradient(130deg, #10283a 0%, #12364b 63%, #154960 100%);
-  box-shadow: 0 18px 44px rgba(15, 39, 56, 0.16);
-  color: #ffffff;
+  padding-bottom: 32px;
+  border-bottom: 1px solid var(--line);
 }
 
-.hero::after {
-  position: absolute;
-  right: -68px;
-  bottom: -104px;
-  width: 310px;
-  height: 310px;
-  border: 1px solid rgba(255, 255, 255, 0.09);
-  border-radius: 50%;
-  content: "";
+.site-nav {
+  display: flex;
+  min-height: 68px;
+  align-items: center;
+  justify-content: space-between;
+  gap: 24px;
+  border-bottom: 1px solid var(--soft-line);
 }
 
-.hero-copy,
-.hero-stat {
-  position: relative;
-  z-index: 1;
+.site-brand {
+  color: #12334a;
+  font-size: 18px;
+  font-weight: 800;
+  letter-spacing: -0.015em;
+  text-decoration: none;
+}
+
+.site-brand:hover {
+  color: #12334a;
+}
+
+.hero-copy {
+  max-width: 980px;
+  padding-top: 46px;
 }
 
 .eyebrow,
@@ -117,33 +114,34 @@ p {
 }
 
 h1 {
-  max-width: 900px;
-  margin-bottom: 12px;
-  font-size: clamp(34px, 4vw, 51px);
-  font-weight: 750;
-  line-height: 1.04;
-  letter-spacing: -0.035em;
+  max-width: 960px;
+  margin-bottom: 14px;
+  font-size: clamp(34px, 4.1vw, 50px);
+  font-weight: 760;
+  line-height: 1.08;
+  letter-spacing: -0.032em;
 }
 
 .lede {
-  max-width: 960px;
-  margin-bottom: 18px;
-  color: #d6e4ec;
-  font-size: 16px;
-  line-height: 1.55;
+  max-width: 820px;
+  margin-bottom: 0;
+  color: #526777;
+  font-size: 17px;
+  line-height: 1.6;
 }
 
 .hero-links {
   display: flex;
-  gap: 18px;
+  gap: 22px;
+  align-items: center;
   flex-wrap: wrap;
 }
 
 .hero-links a {
-  color: #ffffff;
+  color: #244d69;
   font-size: 13px;
-  font-weight: 700;
-  text-decoration-color: rgba(255, 255, 255, 0.5);
+  font-weight: 680;
+  text-decoration: none;
 }
 
 .hero-links a::after {
@@ -152,42 +150,42 @@ h1 {
   font-size: 11px;
 }
 
-.hero-stat {
+.nav-placeholder {
   display: flex;
-  flex-direction: column;
-  gap: 4px;
-  padding: 18px 20px;
-  border: 1px solid rgba(255, 255, 255, 0.18);
-  border-radius: 12px;
-  background: rgba(255, 255, 255, 0.075);
-  backdrop-filter: blur(8px);
-}
-
-.hero-stat-value {
-  font-size: 18px;
-  font-weight: 800;
+  gap: 7px;
+  align-items: center;
+  color: #586b79;
+  font-size: 13px;
+  font-weight: 650;
 }
 
-.hero-stat-label {
-  color: #c9dce7;
-  font-size: 12px;
+.nav-placeholder small {
+  padding: 2px 6px;
+  border: 1px solid #d5dde3;
+  border-radius: 999px;
+  background: #ffffff;
+  color: #71808b;
+  font-size: 9px;
+  font-weight: 750;
+  letter-spacing: 0.035em;
   line-height: 1.4;
+  text-transform: uppercase;
 }
 
 .toolbar {
   position: sticky;
-  top: 0;
+  top: 10px;
   z-index: 20;
   display: grid;
   grid-template-columns: minmax(300px, 0.72fr) minmax(420px, 1.28fr);
   gap: 18px;
-  margin-top: 16px;
+  margin-top: 18px;
   margin-bottom: 14px;
   padding: 13px 16px 14px;
   border: 1px solid var(--line);
   border-radius: var(--radius);
   background: rgba(255, 255, 255, 0.96);
-  box-shadow: 0 10px 28px rgba(18, 38, 53, 0.09);
+  box-shadow: 0 5px 18px rgba(18, 38, 53, 0.07);
   backdrop-filter: blur(10px);
 }
 
@@ -205,46 +203,31 @@ h1 {
   text-transform: uppercase;
 }
 
-.control-help {
-  margin: 5px 1px 0;
-  color: #70808e;
-  font-size: 11px;
-  line-height: 1.25;
-}
-
-.Select-control,
-.select__control {
+.dash-dropdown-grid-container {
   min-height: 39px;
-  border-color: #cbd5dd !important;
-  border-radius: 7px !important;
-  box-shadow: none !important;
+  border: 1px solid #cbd5dd;
+  border-radius: 7px;
+  background: #ffffff;
+  box-shadow: none;
 }
 
-.is-focused:not(.is-open) > .Select-control {
-  border-color: var(--prediction) !important;
-  box-shadow: 0 0 0 3px rgba(21, 101, 192, 0.16) !important;
+.dash-dropdown:focus-within .dash-dropdown-grid-container {
+  border-color: var(--prediction);
+  box-shadow: 0 0 0 3px rgba(21, 101, 192, 0.14);
 }
 
-.Select-placeholder,
-.Select-value-label,
-.Select-input,
-.Select-option {
-  font-size: 13px !important;
+.dash-dropdown-value,
+.dash-dropdown-value-item,
+.dash-dropdown-trigger {
+  font-size: 13px;
 }
 
-.Select--multi .Select-value {
-  margin-top: 4px;
+.dash-dropdown-value-item {
   border-color: #c9d9e7;
   border-radius: 5px;
-  background: #edf5fb;
   color: #154f7b;
 }
 
-.Select-multi-value-wrapper {
-  max-height: 82px;
-  overflow-y: auto;
-}
-
 .tabs {
   display: flex;
   flex-direction: row !important;
@@ -295,9 +278,9 @@ h1 {
   position: relative;
   margin-top: 16px;
   overflow: hidden;
-  padding: 24px 26px 26px;
+  padding: 25px 27px 27px;
   border: 1px solid var(--line);
-  border-top: 4px solid #71808d;
+  border-top: 3px solid #71808d;
   border-radius: var(--radius);
   background: var(--paper);
   box-shadow: var(--shadow);
@@ -333,7 +316,7 @@ h1 {
 
 .panel-heading {
   max-width: 1120px;
-  margin-bottom: 18px;
+  margin-bottom: 20px;
 }
 
 .section-eyebrow {
@@ -367,7 +350,7 @@ h1 {
 
 h2 {
   margin-bottom: 7px;
-  font-size: 23px;
+  font-size: 22px;
   font-weight: 750;
   line-height: 1.2;
   letter-spacing: -0.018em;
@@ -383,7 +366,7 @@ h2 {
 
 .metric-strip {
   display: grid;
-  grid-template-columns: repeat(4, minmax(180px, 1fr));
+  grid-template-columns: repeat(3, minmax(180px, 1fr));
   gap: 11px;
   margin-bottom: 14px;
 }
@@ -456,44 +439,12 @@ h2 {
   line-height: 1.4;
 }
 
-.coverage-note,
-.convergence-note,
 .method-note {
   border-radius: 8px;
   font-size: 12px;
   line-height: 1.5;
 }
 
-.coverage-note {
-  display: inline-flex;
-  align-items: center;
-  min-height: 32px;
-  margin-bottom: 10px;
-  padding: 6px 11px;
-  border: 1px solid #d5e0e7;
-  background: #f7fafb;
-  color: #3f5260;
-  font-weight: 700;
-}
-
-.coverage-note::before {
-  width: 7px;
-  height: 7px;
-  margin-right: 7px;
-  border-radius: 50%;
-  background: #5f7585;
-  content: "";
-}
-
-.convergence-note {
-  margin: 0 0 12px;
-  padding: 9px 12px;
-  border: 1px solid #e4d5eb;
-  background: #faf7fc;
-  color: #5b4169;
-  font-weight: 700;
-}
-
 .method-note {
   margin: 12px 0;
   padding: 11px 13px;
@@ -709,31 +660,29 @@ h2 {
 }
 
 .provenance-footer {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 18px;
   margin-top: 18px;
-  padding: 17px 20px;
-  border: 1px solid #d3dde4;
-  border-radius: 10px;
-  background: #edf2f5;
-  color: #4e606d;
-  font-size: 11px;
+  padding: 18px 2px 4px;
+  border-top: 1px solid var(--line);
+  color: #62727e;
+  font-size: 12px;
   line-height: 1.55;
 }
 
+.provenance-footer a {
+  font-weight: 700;
+  text-decoration: none;
+}
+
 [data-dash-is-loading="true"] {
   opacity: 0.56;
   transition: opacity 140ms ease;
 }
 
 @media (max-width: 1180px) {
-  .hero {
-    grid-template-columns: 1fr;
-    gap: 22px;
-  }
-
-  .hero-stat {
-    max-width: 420px;
-  }
-
   .metric-strip {
     grid-template-columns: repeat(2, minmax(180px, 1fr));
   }
@@ -745,12 +694,27 @@ h2 {
 
 @media (max-width: 820px) {
   .app-shell {
-    padding: 12px 12px 24px;
+    padding: 0 14px 24px;
   }
 
   .hero {
-    padding: 28px 24px;
-    border-radius: 13px;
+    padding-bottom: 25px;
+  }
+
+  .site-nav {
+    min-height: 62px;
+  }
+
+  .hero-copy {
+    padding-top: 34px;
+  }
+
+  .hero-links {
+    gap: 14px;
+  }
+
+  .nav-placeholder small {
+    display: none;
   }
 
   .toolbar {
@@ -776,21 +740,47 @@ h2 {
   .inline-controls {
     grid-template-columns: 1fr;
   }
+
+  .heatmap-graph,
+  .latent-graph {
+    overflow-x: auto;
+  }
+
+  .heatmap-graph > div,
+  .latent-graph > div {
+    min-width: 660px;
+  }
 }
 
 @media (max-width: 560px) {
+  .site-nav {
+    align-items: flex-start;
+    padding: 15px 0;
+  }
+
+  .site-brand {
+    padding-top: 1px;
+  }
+
+  .hero-links {
+    flex-direction: column;
+    gap: 4px;
+    align-items: flex-end;
+  }
+
+  .hero-links a,
+  .nav-placeholder {
+    font-size: 11px;
+  }
+
   h1 {
-    font-size: 34px;
+    font-size: 32px;
   }
 
   .lede {
     font-size: 14px;
   }
 
-  .hero-stat {
-    padding: 14px 15px;
-  }
-
   .metric-strip {
     grid-template-columns: 1fr;
   }
@@ -847,16 +837,13 @@ h2 {
 
   .toolbar,
   .tabs,
-  .source-link,
-  .hero-stat {
+  .source-link {
     display: none !important;
   }
 
   .hero {
     padding: 18px 0;
-    border: 0;
     background: #ffffff;
-    box-shadow: none;
     color: #000000;
   }