Align Space with manuscript figures

Dockerfile

@@ -4,6 +4,8 @@ COPY --from=ghcr.io/astral-sh/uv:0.4.20 /uv /bin/uv
 RUN useradd -m -u 1000 user
 ENV PATH="/home/user/.local/bin:$PATH"
 ENV UV_SYSTEM_PYTHON=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
 
 WORKDIR /app
 
@@ -13,4 +15,4 @@ RUN uv pip install -r requirements.txt
 COPY --chown=user . /app
 USER user
 
-CMD ["gunicorn", "app:server", "--workers", "4", "--bind", "0.0.0.0:7860"]
+CMD ["gunicorn", "app:server", "--workers", "2", "--threads", "2", "--timeout", "120", "--bind", "0.0.0.0:7860"]

README.md

@@ -1,17 +1,69 @@
 ---
-title: Neural Model Benchmark
+title: BEND-BCI Interactive Benchmark
 sdk: docker
 app_port: 7860
+short_description: Interactive BEND-BCI neural decoder benchmark
 ---
 
-# Neural Model Benchmark
+# BEND-BCI Interactive Benchmark
 
-Interactive dashboard for the Tang Lab neural model 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.
 
-The dashboard compares 23 methods across five datasets, with sortable decoding
-performance, robustness, cross-session alignment, neuron and trial influence,
-compute cost, and 3D latent-space views.
+The application keeps the benchmark's scientific organization explicit:
 
-The bundled files in `data/` are lightweight summary tables for interactive
-inspection. The full benchmark artifacts and reproduction workflow live in the
-main benchmark repository.
+- 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
+
+```bash
+python -m venv .venv
+.venv/bin/pip install -r requirements.txt
+.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.

assets/styles.css

@@ -1,280 +1,640 @@
+:root {
+  --ink: #17202a;
+  --muted: #607080;
+  --line: #d8e1e7;
+  --soft-line: #e9eef2;
+  --paper: #ffffff;
+  --canvas: #f4f6f8;
+  --prediction: #1565c0;
+  --robustness: #2e7d32;
+  --compute: #e65100;
+  --consistency: #007c91;
+  --feature: #6a51a3;
+  --trial: #6a1b9a;
+  --shadow: 0 12px 34px rgba(24, 43, 59, 0.075);
+  --radius: 12px;
+}
+
 * {
   box-sizing: border-box;
 }
 
+html {
+  scroll-behavior: smooth;
+}
+
 body {
   margin: 0;
-  background: #f4f6f7;
-  color: #17202a;
-  font-family: Inter, Arial, sans-serif;
+  background: var(--canvas);
+  color: var(--ink);
+  font-family: Arial, Helvetica, sans-serif;
+  font-size: 15px;
+  line-height: 1.5;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+}
+
+a {
+  color: #0b5da8;
+  text-underline-offset: 3px;
+}
+
+a:hover {
+  color: #083e70;
+}
+
+:focus-visible {
+  outline: 3px solid rgba(21, 101, 192, 0.34) !important;
+  outline-offset: 2px !important;
+}
+
+h1,
+h2,
+h3,
+p {
+  margin-top: 0;
 }
 
 .app-shell {
   min-height: 100vh;
-  padding: 18px 22px 28px;
+  padding: 20px 24px 34px;
 }
 
 .hero,
 .toolbar,
-.tabs {
-  max-width: 1560px;
-  margin-left: auto;
+.tabs,
+.provenance-footer {
+  width: min(100%, 1540px);
   margin-right: auto;
+  margin-left: auto;
 }
 
 .hero {
-  padding: 8px 2px 14px;
-  border-bottom: 1px solid #d8e1e7;
-}
-
-.hero-copy {
-  min-width: 0;
-}
-
-.eyebrow {
-  margin-bottom: 7px;
-  color: #526171;
-  font-size: 12px;
+  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;
+}
+
+.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: "";
+}
+
+.hero-copy,
+.hero-stat {
+  position: relative;
+  z-index: 1;
+}
+
+.eyebrow,
+.section-eyebrow {
+  font-size: 11px;
   font-weight: 800;
-  letter-spacing: 0;
+  letter-spacing: 0.105em;
   text-transform: uppercase;
 }
 
-h1,
-h2,
-h3,
-p {
-  margin-top: 0;
+.eyebrow {
+  margin-bottom: 10px;
+  color: #b9d7e7;
 }
 
 h1 {
-  margin-bottom: 8px;
-  font-size: 40px;
-  line-height: 1.05;
-  letter-spacing: 0;
-}
-
-h2 {
-  margin-bottom: 5px;
-  font-size: 20px;
-  letter-spacing: 0;
+  max-width: 900px;
+  margin-bottom: 12px;
+  font-size: clamp(34px, 4vw, 51px);
+  font-weight: 750;
+  line-height: 1.04;
+  letter-spacing: -0.035em;
 }
 
 .lede {
-  max-width: 840px;
-  margin-bottom: 0;
-  color: #526171;
-  font-size: 15px;
-  line-height: 1.45;
+  max-width: 960px;
+  margin-bottom: 18px;
+  color: #d6e4ec;
+  font-size: 16px;
+  line-height: 1.55;
 }
 
-.top-strip {
+.hero-links {
   display: flex;
-  gap: 10px;
-  align-items: stretch;
+  gap: 18px;
   flex-wrap: wrap;
 }
 
-.metric-card {
-  min-width: 145px;
-  padding: 12px 14px;
-  border: 1px solid #d8e1e7;
-  border-radius: 8px;
-  background: #ffffff;
+.hero-links a {
+  color: #ffffff;
+  font-size: 13px;
+  font-weight: 700;
+  text-decoration-color: rgba(255, 255, 255, 0.5);
 }
 
-.metric-label {
-  color: #607080;
+.hero-links a::after {
+  margin-left: 5px;
+  content: "↗";
   font-size: 11px;
-  font-weight: 800;
-  letter-spacing: 0;
-  text-transform: uppercase;
 }
 
-.metric-value {
-  margin-top: 7px;
-  color: #101820;
-  font-size: 22px;
+.hero-stat {
+  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;
-  line-height: 1.1;
 }
 
-.metric-detail {
-  margin-top: 6px;
-  color: #647383;
+.hero-stat-label {
+  color: #c9dce7;
   font-size: 12px;
-  line-height: 1.35;
+  line-height: 1.4;
 }
 
 .toolbar {
   position: sticky;
   top: 0;
-  z-index: 10;
+  z-index: 20;
   display: grid;
-  grid-template-columns: minmax(230px, 310px);
-  gap: 16px;
-  margin-top: 14px;
+  grid-template-columns: minmax(300px, 0.72fr) minmax(420px, 1.28fr);
+  gap: 18px;
+  margin-top: 16px;
   margin-bottom: 14px;
-  padding: 12px;
-  border: 1px solid #d8e1e7;
-  border-radius: 8px;
+  padding: 13px 16px 14px;
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
   background: rgba(255, 255, 255, 0.96);
-  box-shadow: 0 8px 24px rgba(18, 28, 38, 0.06);
-  backdrop-filter: blur(6px);
+  box-shadow: 0 10px 28px rgba(18, 38, 53, 0.09);
+  backdrop-filter: blur(10px);
+}
+
+.control {
+  min-width: 0;
 }
 
 .control label {
   display: block;
   margin-bottom: 6px;
   color: #344452;
-  font-size: 12px;
+  font-size: 11px;
   font-weight: 800;
-  letter-spacing: 0;
+  letter-spacing: 0.075em;
   text-transform: uppercase;
 }
 
+.control-help {
+  margin: 5px 1px 0;
+  color: #70808e;
+  font-size: 11px;
+  line-height: 1.25;
+}
+
+.Select-control,
+.select__control {
+  min-height: 39px;
+  border-color: #cbd5dd !important;
+  border-radius: 7px !important;
+  box-shadow: none !important;
+}
+
+.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;
+}
+
+.Select-placeholder,
+.Select-value-label,
+.Select-input,
+.Select-option {
+  font-size: 13px !important;
+}
+
 .Select--multi .Select-value {
-  margin-top: 3px;
+  margin-top: 4px;
+  border-color: #c9d9e7;
+  border-radius: 5px;
+  background: #edf5fb;
+  color: #154f7b;
 }
 
 .Select-multi-value-wrapper {
-  max-height: 86px;
+  max-height: 82px;
   overflow-y: auto;
 }
 
 .tabs {
-  border: 0;
+  display: flex;
+  flex-direction: row !important;
+  flex-wrap: nowrap;
+  overflow-x: auto;
+  border: 1px solid var(--line);
+  border-radius: 11px;
+  background: #ffffff;
+  box-shadow: 0 5px 16px rgba(24, 43, 59, 0.045);
+  scrollbar-width: thin;
+  -webkit-overflow-scrolling: touch;
 }
 
 .tab {
   display: flex !important;
+  flex: 1 0 auto !important;
+  width: auto !important;
   align-items: center !important;
   justify-content: center !important;
-  min-height: 44px;
-  padding: 11px 18px !important;
+  min-height: 50px;
+  padding: 12px 20px !important;
   border: 0 !important;
-  border-bottom: 2px solid transparent !important;
-  background: transparent !important;
-  color: #637381 !important;
-  font-size: 14px;
+  border-right: 1px solid #edf1f4 !important;
+  border-bottom: 3px solid transparent !important;
+  background: #ffffff !important;
+  color: #61717f !important;
+  font-size: 13px;
   font-weight: 700;
+  white-space: nowrap;
+}
+
+.tab:last-child {
+  border-right: 0 !important;
+}
+
+.tab:hover {
+  background: #f8fafb !important;
+  color: #213442 !important;
 }
 
 .tab-selected {
-  color: #12302f !important;
-  border-bottom-color: #1565C0 !important;
-  background: #ffffff !important;
+  border-bottom-color: var(--prediction) !important;
+  background: #f7fafc !important;
+  color: #102d41 !important;
 }
 
 .panel {
-  margin-top: 14px;
-  padding: 18px;
-  border: 1px solid #d8e1e7;
-  border-radius: 8px;
-  background: #ffffff;
+  position: relative;
+  margin-top: 16px;
+  overflow: hidden;
+  padding: 24px 26px 26px;
+  border: 1px solid var(--line);
+  border-top: 4px solid #71808d;
+  border-radius: var(--radius);
+  background: var(--paper);
+  box-shadow: var(--shadow);
+}
+
+.panel.axis-prediction {
+  border-top-color: var(--prediction);
+}
+
+.panel.axis-robustness {
+  border-top-color: var(--robustness);
+}
+
+.panel.axis-compute {
+  border-top-color: var(--compute);
+}
+
+.panel.axis-consistency {
+  border-top-color: var(--consistency);
+}
+
+.panel.axis-feature {
+  border-top-color: var(--feature);
+}
+
+.panel.axis-trial {
+  border-top-color: var(--trial);
+}
+
+.panel.axis-methods {
+  border-top-color: #455a64;
 }
 
 .panel-heading {
-  margin-bottom: 14px;
+  max-width: 1120px;
+  margin-bottom: 18px;
+}
+
+.section-eyebrow {
+  margin-bottom: 5px;
+  color: var(--muted);
+}
+
+.axis-prediction .section-eyebrow {
+  color: var(--prediction);
+}
+
+.axis-robustness .section-eyebrow {
+  color: var(--robustness);
+}
+
+.axis-compute .section-eyebrow {
+  color: var(--compute);
+}
+
+.axis-consistency .section-eyebrow {
+  color: var(--consistency);
+}
+
+.axis-feature .section-eyebrow {
+  color: var(--feature);
+}
+
+.axis-trial .section-eyebrow {
+  color: var(--trial);
+}
+
+h2 {
+  margin-bottom: 7px;
+  font-size: 23px;
+  font-weight: 750;
+  line-height: 1.2;
+  letter-spacing: -0.018em;
 }
 
 .panel-subtitle {
-  max-width: 980px;
+  max-width: 1080px;
   margin-bottom: 0;
-  color: #526171;
+  color: #526473;
   font-size: 13px;
-  line-height: 1.45;
+  line-height: 1.55;
 }
 
-.leaderboard-panel {
-  padding-top: 16px;
+.metric-strip {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(180px, 1fr));
+  gap: 11px;
+  margin-bottom: 14px;
 }
 
-.top-strip {
-  margin-bottom: 14px;
+.metric-card {
+  position: relative;
+  min-width: 0;
+  overflow: hidden;
+  padding: 15px 16px 14px;
+  border: 1px solid #dce4e9;
+  border-radius: 9px;
+  background: linear-gradient(180deg, #ffffff 0%, #fbfcfd 100%);
 }
 
-.leaderboard-grid {
-  display: grid;
-  grid-template-columns: minmax(560px, 1.08fr) minmax(360px, 0.92fr);
-  gap: 16px;
-  align-items: start;
+.metric-card::before {
+  position: absolute;
+  top: 0;
+  right: 0;
+  left: 0;
+  height: 3px;
+  background: #7b8995;
+  content: "";
 }
 
-.leaderboard-table-wrap,
-.consistency-table-wrap {
-  min-width: 0;
+.metric-card-prediction::before {
+  background: var(--prediction);
+}
+
+.metric-card-robustness::before {
+  background: var(--robustness);
+}
+
+.metric-card-compute::before {
+  background: var(--compute);
+}
+
+.metric-card-consistency::before {
+  background: var(--consistency);
 }
 
-.sort-state {
+.metric-card-feature::before {
+  background: var(--feature);
+}
+
+.metric-card-trial::before {
+  background: var(--trial);
+}
+
+.metric-label {
+  color: #657582;
+  font-size: 10px;
+  font-weight: 800;
+  letter-spacing: 0.075em;
+  text-transform: uppercase;
+}
+
+.metric-value {
+  margin-top: 7px;
+  overflow-wrap: anywhere;
+  color: #101820;
+  font-size: 20px;
+  font-weight: 800;
+  line-height: 1.15;
+}
+
+.metric-detail {
+  margin-top: 6px;
+  color: #647583;
+  font-size: 11px;
+  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: 30px;
-  margin: 0 0 8px;
-  padding: 6px 10px;
-  border: 1px solid #cfd8df;
-  border-radius: 6px;
+  min-height: 32px;
+  margin-bottom: 10px;
+  padding: 6px 11px;
+  border: 1px solid #d5e0e7;
   background: #f7fafb;
-  color: #344452;
-  font-size: 12px;
-  font-weight: 800;
-  line-height: 1.2;
+  color: #3f5260;
+  font-weight: 700;
 }
 
-.latent-grid {
-  display: grid;
-  grid-template-columns: minmax(360px, 0.42fr) minmax(620px, 1fr);
-  gap: 16px;
-  align-items: start;
+.coverage-note::before {
+  width: 7px;
+  height: 7px;
+  margin-right: 7px;
+  border-radius: 50%;
+  background: #5f7585;
+  content: "";
 }
 
-.latent-panel {
-  min-width: 0;
+.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;
+  border-left: 3px solid #6f8190;
+  background: #f6f8fa;
+  color: #445664;
+}
+
+.axis-consistency .method-note {
+  border-left-color: var(--consistency);
+}
+
+.axis-feature .method-note {
+  border-left-color: var(--feature);
 }
 
-.latent-color-control {
-  width: min(260px, 100%);
-  margin-bottom: 8px;
+.axis-trial .method-note {
+  border-left-color: var(--trial);
 }
 
 .chart-grid {
   display: grid;
-  gap: 16px;
+  gap: 18px;
   align-items: start;
 }
 
 .chart-grid.two {
-  grid-template-columns: repeat(2, minmax(320px, 1fr));
+  grid-template-columns: repeat(2, minmax(0, 1fr));
 }
 
-.table-hint {
-  margin: 10px 2px 0;
-  color: #647383;
-  font-size: 12px;
+.graph-box {
+  min-width: 0;
+  overflow: hidden;
+  border: 1px solid #e3e9ed;
+  border-radius: 9px;
+  background: #ffffff;
 }
 
-.details-table {
+.graph-box + .graph-box,
+.chart-grid + .graph-box,
+.graph-box + .chart-grid {
+  margin-top: 0;
+}
+
+.panel > .graph-box {
   margin-top: 12px;
-  border-top: 1px solid #e5ebef;
+}
+
+.chart-grid > .graph-box {
+  margin-top: 0;
+}
+
+.latent-graph {
+  margin-top: 14px !important;
+}
+
+.inline-controls {
+  display: grid;
+  grid-template-columns: minmax(240px, 420px) minmax(200px, 300px);
+  gap: 14px;
+  align-items: end;
+  margin-bottom: 12px;
+  padding: 13px 14px;
+  border: 1px solid #e0e6ea;
+  border-radius: 9px;
+  background: #fafbfc;
+}
+
+.details-table {
+  margin-top: 15px;
+  border: 1px solid #e1e7eb;
+  border-radius: 8px;
+  background: #ffffff;
 }
 
 .details-table summary {
   cursor: pointer;
-  padding: 12px 0 8px;
-  color: #344452;
-  font-size: 13px;
+  padding: 11px 14px;
+  color: #344a59;
+  font-size: 12px;
   font-weight: 800;
+  user-select: none;
+}
+
+.details-table summary:hover {
+  background: #f7f9fa;
+}
+
+.details-table[open] summary {
+  border-bottom: 1px solid #e5eaee;
 }
 
 .details-body {
-  padding-top: 4px;
+  padding: 9px;
+}
+
+.source-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  margin-top: 12px;
+  padding: 6px 10px;
+  border: 1px solid #cdd9e1;
+  border-radius: 6px;
+  background: #ffffff;
+  color: #355b77;
+  font-size: 11px;
+  font-weight: 750;
+  text-decoration: none;
+}
+
+.source-link::before {
+  content: "↓";
+  font-size: 13px;
+}
+
+.source-link:hover {
+  border-color: #93adbf;
+  background: #f4f8fa;
+}
+
+.download-grid {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+  margin-top: 4px;
+}
+
+.download-grid .source-link {
+  margin-top: 0;
+}
+
+.dash-table-container {
+  color: var(--ink);
 }
 
 .dash-table-container .dash-spreadsheet-container .dash-spreadsheet-inner th {
-  background: #f3f6f8 !important;
+  overflow: visible !important;
   padding: 0 !important;
   border-right: 1px solid #d8e1e7 !important;
-  overflow: visible !important;
+  background: #f3f6f8 !important;
 }
 
 .dash-table-container .dash-spreadsheet-container .dash-spreadsheet-inner th:last-child {
@@ -283,84 +643,231 @@ h2 {
 
 .dash-table-container .dash-spreadsheet-container .dash-spreadsheet-inner th.dash-header > div {
   display: flex !important;
+  gap: 7px !important;
   align-items: center !important;
   justify-content: flex-start !important;
-  gap: 8px !important;
-  min-height: 43px;
-  padding: 10px 12px !important;
+  min-height: 42px;
+  padding: 9px 10px !important;
 }
 
 .dash-table-container .dash-spreadsheet-container .dash-spreadsheet-inner .column-header-name {
   flex: 1 1 auto !important;
   min-width: 0;
-  color: #26323f;
-  line-height: 1.15;
+  color: #263844;
+  line-height: 1.2;
   white-space: normal;
 }
 
 .dash-table-container .dash-spreadsheet-container .dash-spreadsheet-inner .column-actions {
   order: -1;
-  flex: 0 0 auto !important;
   display: inline-flex !important;
+  flex: 0 0 auto !important;
   align-items: center;
-  justify-content: center;
 }
 
-.dash-table-container .dash-spreadsheet-container .dash-spreadsheet-inner .column-header--sort {
+.dash-table-container .dash-spreadsheet-container .dash-spreadsheet-inner .column-header--sort,
+.dash-table-container .dash-spreadsheet-container .dash-spreadsheet-inner .column-header--hide {
   display: inline-flex !important;
   align-items: center;
   justify-content: center;
-  width: 22px;
-  height: 22px;
+  width: 21px;
+  height: 21px;
   border: 1px solid #c7d3dc;
-  border-radius: 5px;
+  border-radius: 4px;
   background: #ffffff;
   color: #526171 !important;
-  font-size: 13px;
-  font-weight: 900;
-  line-height: 1;
+  font-size: 12px;
   opacity: 1 !important;
 }
 
 .dash-table-container .dash-spreadsheet-container .dash-spreadsheet-inner th:hover .column-header--sort {
-  border-color: #1565C0;
+  border-color: var(--prediction);
   background: #edf6ff;
-  color: #1565C0 !important;
+  color: var(--prediction) !important;
+}
+
+.dash-table-container .dash-filter input {
+  min-height: 29px;
+  padding: 5px 7px !important;
+  border: 1px solid #d5dee4 !important;
+  border-radius: 4px;
+  background: #ffffff !important;
+  font-family: Arial, Helvetica, sans-serif !important;
+  font-size: 11px !important;
 }
 
 .dash-table-container .previous-next-container {
   margin-top: 8px;
   color: #526171;
-  font-size: 12px;
+  font-size: 11px;
+}
+
+.dash-table-container .previous-next-container button {
+  border: 1px solid #d4dde3;
+  border-radius: 5px;
+  background: #ffffff;
+}
+
+.provenance-footer {
+  margin-top: 18px;
+  padding: 17px 20px;
+  border: 1px solid #d3dde4;
+  border-radius: 10px;
+  background: #edf2f5;
+  color: #4e606d;
+  font-size: 11px;
+  line-height: 1.55;
+}
+
+[data-dash-is-loading="true"] {
+  opacity: 0.56;
+  transition: opacity 140ms ease;
 }
 
 @media (max-width: 1180px) {
-  .hero,
-  .toolbar,
-  .leaderboard-grid,
-  .latent-grid,
-  .chart-grid.two {
+  .hero {
     grid-template-columns: 1fr;
+    gap: 22px;
+  }
+
+  .hero-stat {
+    max-width: 420px;
+  }
+
+  .metric-strip {
+    grid-template-columns: repeat(2, minmax(180px, 1fr));
   }
 
+  .chart-grid.two {
+    grid-template-columns: 1fr;
+  }
 }
 
-@media (max-width: 680px) {
+@media (max-width: 820px) {
   .app-shell {
+    padding: 12px 12px 24px;
+  }
+
+  .hero {
+    padding: 28px 24px;
+    border-radius: 13px;
+  }
+
+  .toolbar {
+    position: relative;
+    grid-template-columns: 1fr;
+    gap: 12px;
     padding: 12px;
   }
 
-  h1 {
-    font-size: 32px;
+  .tabs {
+    justify-content: flex-start;
+  }
+
+  .tab {
+    flex: 0 0 auto !important;
+    min-width: 148px;
   }
 
   .panel {
-    padding: 14px;
+    padding: 20px 17px;
+  }
+
+  .inline-controls {
+    grid-template-columns: 1fr;
+  }
+}
+
+@media (max-width: 560px) {
+  h1 {
+    font-size: 34px;
+  }
+
+  .lede {
+    font-size: 14px;
+  }
+
+  .hero-stat {
+    padding: 14px 15px;
+  }
+
+  .metric-strip {
+    grid-template-columns: 1fr;
+  }
+
+  .metric-card {
+    padding: 13px 14px;
+  }
+
+  h2 {
+    font-size: 20px;
+  }
+
+  .panel-subtitle,
+  .method-note {
+    font-size: 12px;
   }
 
   .tab {
-    padding-left: 10px !important;
-    padding-right: 10px !important;
-    font-size: 13px;
+    min-width: 134px;
+    padding-right: 12px !important;
+    padding-left: 12px !important;
+    font-size: 12px;
+  }
+
+  .details-body {
+    padding: 4px;
+  }
+
+  .source-link {
+    width: 100%;
+    justify-content: center;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  html {
+    scroll-behavior: auto;
+  }
+
+  *,
+  *::before,
+  *::after {
+    transition-duration: 0.01ms !important;
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+  }
+}
+
+@media print {
+  body,
+  .app-shell {
+    background: #ffffff;
+  }
+
+  .toolbar,
+  .tabs,
+  .source-link,
+  .hero-stat {
+    display: none !important;
+  }
+
+  .hero {
+    padding: 18px 0;
+    border: 0;
+    background: #ffffff;
+    box-shadow: none;
+    color: #000000;
+  }
+
+  .eyebrow,
+  .lede,
+  .hero-links a {
+    color: #333333;
+  }
+
+  .panel {
+    break-inside: avoid;
+    box-shadow: none;
   }
 }

data/consistency_summary.csv

@@ -35,7 +35,7 @@ marble,monkey,monkey,True,4,sub-C_ses-CO-20151104_behavior+ecephys;sub-J_ses-CO-
 marble,ratinabox,ratinabox,True,4,ratinabox_nav;ratinabox_nav_s123;ratinabox_nav_s456;ratinabox_nav_s789,3,0.5023447353328528,0.15119647919292642,12,direct_labels,per_session_whitening,100.0,100.0,benchmark_results/marble_cross_ratinabox_consistency.json
 marble,speech,speech_threshold_crossings,True,4,t12;t15;t16;t17,3,0.5995980059621582,0.4348672589667975,12,centroid,per_session_whitening,8.0,8.0,benchmark_results/marble_cross_speech_threshold_crossings_consistency.json
 neuro_behavior_conditioning,allen_neuropixels,allen_neuropixels,True,3,721123822;715093703;732592105,3,0.5341513273436873,0.3258140816630879,6,centroid,per_session_whitening,8.0,8.0,benchmark_results/neuro_behavior_conditioning_cross_allen_neuropixels_consistency.json
-neuro_behavior_conditioning,monkey,monkey,True,4,sub-C_ses-CO-20151104_behavior+ecephys;sub-J_ses-CO-20160405_behavior+ecephys;sub-M_ses-CO-20140203_behavior+ecephys;sub-T_ses-CO-20130819_behavior+ecephys,3,0.187690323745175,-0.22244557265455436,12,position_binned,per_session_whitening,80.0,8.0,benchmark_results/neuro_behavior_conditioning_cross_monkey_consistency.json
+neuro_behavior_conditioning,monkey,monkey,True,4,sub-C_ses-CO-20151104_behavior+ecephys;sub-J_ses-CO-20160405_behavior+ecephys;sub-M_ses-CO-20140203_behavior+ecephys;sub-T_ses-CO-20130819_behavior+ecephys,3,0.18909089587238706,-0.22025913182256643,12,position_binned,per_session_whitening,80.0,8.0,benchmark_results/neuro_behavior_conditioning_cross_monkey_consistency.json
 neuro_behavior_conditioning,ratinabox,ratinabox,True,4,ratinabox_nav;ratinabox_nav_s123;ratinabox_nav_s456;ratinabox_nav_s789,3,0.12144475733839015,-0.38850488980683845,12,direct_labels,per_session_whitening,100.0,100.0,benchmark_results/neuro_behavior_conditioning_cross_ratinabox_consistency.json
 neuro_behavior_conditioning,speech,speech_threshold_crossings,True,4,t12;t15;t16;t17,3,0.4050875872751732,-30679.955330283454,12,centroid,per_session_whitening,8.0,8.0,benchmark_results/neuro_behavior_conditioning_cross_speech_threshold_crossings_consistency.json
 pca,allen_neuropixels,allen_neuropixels,True,3,721123822;715093703;732592105,3,0.5668164187589818,0.3842947844321292,6,centroid,per_session_whitening,8.0,8.0,benchmark_results/pca_cross_allen_neuropixels_consistency.json

data/latent_trajectories.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cf78532b6d37c6a05f3f93baa348f45908d1eb6d6072aec26657423a69f499b5
-size 13882186
+oid sha256:d15a19b50d7dbc517b4bf5de60a550fda6870327e5e59fb4a5ec37f01921abf5
+size 16913534

data/release_manifest.json

@@ -0,0 +1,54 @@
+{
+  "figure_set": "Figures 2-5 and Supplementary Figures 1-27",
+  "latent_coordinate_spaces": [
+    "per_session_whitened_reference_aligned_3d"
+  ],
+  "manuscript_working_version": "manuscript_v7",
+  "schema_version": 1,
+  "source": "paper/results, active consistency embedding artifacts, and Figure 5 prediction sidecars",
+  "source_git_revision": "80def770609a52f45a835c6b62500b04cdc2b548",
+  "source_repository": "https://github.com/TangLab-UBC/behavior_benchmarking",
+  "source_worktree_dirty": true,
+  "tables": {
+    "clean_prediction_summary.csv": {
+      "rows": 115,
+      "sha256": "1be57a892d7033367897bb065ec75f7d6942d5b1a1970136f958df08cacb43df"
+    },
+    "consistency_summary.csv": {
+      "rows": 54,
+      "sha256": "7039c0d38c288576e39ea6a1147a41eb2d395559b1d9b1de1b14eac3b3801b7f"
+    },
+    "latent_samples.csv": {
+      "rows": 31140,
+      "sha256": "bb484c47b78bd7a7d0a2bfea94296e726aa80034f87368b32302aaba0c5aa622"
+    },
+    "latent_trajectories.csv": {
+      "rows": 75040,
+      "sha256": "d15a19b50d7dbc517b4bf5de60a550fda6870327e5e59fb4a5ec37f01921abf5"
+    },
+    "neuron_shap_summary.csv": {
+      "rows": 105,
+      "sha256": "a36430bdd193040c48e2ab9fd48570d9c37b9ad58025d8a02d2c84293c768389"
+    },
+    "robustness_summary.csv": {
+      "rows": 115,
+      "sha256": "6e67a53dd3f3629c1280609aaad3f3203a0c7ab4938bdedb05d0c207cfd6e98f"
+    },
+    "scalability_summary.csv": {
+      "rows": 115,
+      "sha256": "04838e17f653394e8d861b8698c66d907864bce44c3561343a8a6489021dbd23"
+    },
+    "trial_historical_trajectories.csv": {
+      "rows": 4725,
+      "sha256": "605373599d4bd46c1379ab99b791bd82060544843be8eb880a9f9bcb523d1cda"
+    },
+    "trial_shapley_retrain_summary.csv": {
+      "rows": 99,
+      "sha256": "069fcb01b5ebd3dd290553d9373a7c1a9841a390d08a30eb9cc024ed8eab7eb0"
+    },
+    "trial_shapley_summary.csv": {
+      "rows": 81,
+      "sha256": "bba3435afa6a0e2755d30199e995f53bfa33df8b7200b066ea9b575d6125133b"
+    }
+  }
+}

requirements.txt

@@ -1,5 +1,5 @@
-dash>=2.17,<5
-gunicorn>=22,<24
-numpy>=1.26,<3
-pandas>=2.1,<3
-plotly>=5.22,<7
+dash==4.4.0
+gunicorn==23.0.0
+numpy==2.4.2
+pandas==2.3.3
+plotly==6.9.0

validate_data.py

@@ -0,0 +1,592 @@
+#!/usr/bin/env python3
+"""Validate the bundled BEND-BCI Space tables and their paper provenance.
+
+The local checks run in the standalone Hugging Face Space.  Passing
+``--canonical-root`` additionally compares every manuscript-facing summary
+against ``paper/results`` in the main benchmark repository.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+from typing import Iterable
+
+import numpy as np
+import pandas as pd
+
+
+DATASETS = {
+    "monkey",
+    "allen_neuropixels",
+    "speech",
+    "mc_pacman",
+    "ratinabox",
+}
+CONSISTENCY_DATASETS = DATASETS - {"mc_pacman"}
+LATENT_COORDINATE_SPACE = "per_session_whitened_reference_aligned_3d"
+FIGURE5_TARGET_SESSION = "sub-C_ses-CO-20150716_behavior+ecephys"
+
+# Coverage is defined in manuscript v7 Supplementary Table 2.
+EXPECTED_COVERAGE = {
+    "clean_prediction_summary.csv": (115, 112),
+    "robustness_summary.csv": (115, 112),
+    "scalability_summary.csv": (115, 112),
+    "consistency_summary.csv": (54, 46),
+    "neuron_shap_summary.csv": (105, 105),
+    "trial_shapley_summary.csv": (81, 81),
+    "trial_shapley_retrain_summary.csv": (99, 99),
+}
+
+REQUIRED_COLUMNS = {
+    "clean_prediction_summary.csv": {
+        "model", "dataset", "status", "metric", "score", "decoder",
+    },
+    "robustness_summary.csv": {
+        "model", "dataset", "status", "metric", "noise_levels", "scores",
+        "raw_auc",
+    },
+    "scalability_summary.csv": {
+        "model", "dataset", "status", "training_time_sec",
+        "inference_time_sec", "peak_ram_gb", "peak_vram_gb",
+    },
+    "consistency_summary.csv": {
+        "model", "dataset", "is_active_model", "mean_r2", "n_sessions",
+        "sessions", "latent_dim", "scoring_modes", "normalizations",
+    },
+    "neuron_shap_summary.csv": {
+        "model", "dataset", "is_active_model", "auc", "spearman_corr",
+        "shap_mean_value", "shap_min_value", "shap_max_value",
+        "shap_fraction_positive", "shap_fraction_negative",
+    },
+    "trial_shapley_summary.csv": {
+        "model", "dataset", "is_active_model", "analysis", "perturbation_auc",
+        "rotation_angle_deg", "rotation_subspace_dim_spec",
+        "trial_selection_mode", "converged", "shapley_mean_value",
+        "shapley_min_value", "shapley_max_value",
+        "shapley_fraction_positive", "shapley_fraction_negative",
+    },
+    "trial_shapley_retrain_summary.csv": {
+        "analysis", "model", "is_active_model", "condition", "metric", "score",
+    },
+    "trial_historical_trajectories.csv": {
+        "model", "target_session", "trial_index", "trial_id",
+        "direction_index", "direction_label", "time_index", "target_x",
+        "target_y", "current_only_x", "current_only_y",
+        "historical_selected_x", "historical_selected_y", "current_only_r2",
+        "historical_selected_r2",
+    },
+    "latent_samples.csv": {
+        "model", "dataset", "session", "session_label", "x", "y", "z",
+        "condition", "trial_index", "time_index", "eval_time_index",
+        "coordinate_space", "reference_session", "alignment", "landmark_type",
+        "n_alignment_landmarks", "is_reference", "session_order",
+    },
+    "latent_trajectories.csv": {
+        "model", "dataset", "session", "session_label", "x", "y", "z",
+        "condition", "time_index", "eval_time_index", "n_points",
+        "coordinate_space", "reference_session", "alignment", "landmark_type",
+        "n_alignment_landmarks", "is_reference", "session_order",
+    },
+}
+
+UNIQUE_KEYS = {
+    "clean_prediction_summary.csv": ["model", "dataset"],
+    "robustness_summary.csv": ["model", "dataset"],
+    "scalability_summary.csv": ["model", "dataset"],
+    "consistency_summary.csv": ["model", "dataset"],
+    "neuron_shap_summary.csv": ["model", "dataset"],
+    "trial_shapley_summary.csv": ["model", "dataset"],
+    "trial_shapley_retrain_summary.csv": ["analysis", "model", "condition"],
+}
+
+CANONICAL_NAMES = {
+    "clean_prediction_summary.csv": "metrics_summary.csv",
+    "robustness_summary.csv": "robustness_summary.csv",
+    "scalability_summary.csv": "scalability_summary.csv",
+    "consistency_summary.csv": "consistency_summary.csv",
+    "neuron_shap_summary.csv": "neuron_shap_summary.csv",
+    "trial_shapley_summary.csv": "trial_shapley_summary.csv",
+    "trial_shapley_retrain_summary.csv": "trial_shapley_retrain_summary.csv",
+}
+
+
+class ValidationError(RuntimeError):
+    """Raised when Space data violates its manuscript-facing contract."""
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _active_mask(frame: pd.DataFrame) -> pd.Series:
+    if "status" in frame.columns:
+        return frame["status"].fillna("").eq("present")
+    if "is_active_model" in frame.columns:
+        return frame["is_active_model"].astype(str).str.lower().eq("true")
+    return pd.Series(True, index=frame.index)
+
+
+def _require(condition: bool, message: str, errors: list[str]) -> None:
+    if not condition:
+        errors.append(message)
+
+
+def _same_values(left: pd.DataFrame, right: pd.DataFrame) -> None:
+    pd.testing.assert_frame_equal(
+        left.reset_index(drop=True),
+        right.reset_index(drop=True),
+        check_dtype=False,
+        check_exact=True,
+        check_categorical=False,
+    )
+
+
+def _validate_latent_cell(
+    frame: pd.DataFrame,
+    *,
+    table_label: str,
+    model: str,
+    dataset: str,
+    sessions: list[str],
+    landmark_type: str,
+    errors: list[str],
+) -> None:
+    """Validate reference/alignment metadata for one method-dataset cell."""
+    cell = frame[
+        frame["model"].astype(str).eq(model)
+        & frame["dataset"].astype(str).eq(dataset)
+    ]
+    for session_order, session in enumerate(sessions):
+        session_rows = cell[cell["session"].astype(str).eq(session)]
+        if session_rows.empty:
+            errors.append(f"{table_label}: missing {model}/{dataset}/{session}")
+            continue
+
+        expected_reference = "true" if session_order == 0 else "false"
+        observed_reference = set(
+            session_rows["is_reference"].dropna().astype(str).str.lower()
+        )
+        _require(
+            observed_reference == {expected_reference},
+            f"{table_label}: {model}/{dataset}/{session} is_reference "
+            f"values {sorted(observed_reference)}",
+            errors,
+        )
+        expected_alignment = "identity" if session_order == 0 else "proper_similarity_procrustes"
+        observed_alignment = set(session_rows["alignment"].dropna().astype(str))
+        _require(
+            observed_alignment == {expected_alignment},
+            f"{table_label}: {model}/{dataset}/{session} alignment "
+            f"values {sorted(observed_alignment)}",
+            errors,
+        )
+        observed_reference_sessions = set(
+            session_rows["reference_session"].dropna().astype(str)
+        )
+        _require(
+            observed_reference_sessions == {sessions[0]},
+            f"{table_label}: {model}/{dataset}/{session} reference metadata "
+            f"{sorted(observed_reference_sessions)}",
+            errors,
+        )
+        observed_landmarks = set(session_rows["landmark_type"].dropna().astype(str))
+        _require(
+            observed_landmarks == {landmark_type},
+            f"{table_label}: {model}/{dataset}/{session} landmarks "
+            f"{sorted(observed_landmarks)}",
+            errors,
+        )
+        orders = pd.to_numeric(session_rows["session_order"], errors="coerce")
+        _require(
+            orders.notna().all()
+            and np.isfinite(orders.to_numpy()).all()
+            and orders.eq(session_order).all(),
+            f"{table_label}: {model}/{dataset}/{session} has invalid session_order",
+            errors,
+        )
+        landmark_counts = pd.to_numeric(
+            session_rows["n_alignment_landmarks"], errors="coerce"
+        )
+        _require(
+            landmark_counts.notna().all()
+            and np.isfinite(landmark_counts.to_numpy()).all()
+            and landmark_counts.ge(3).all(),
+            f"{table_label}: {model}/{dataset}/{session} has invalid landmark count",
+            errors,
+        )
+
+
+def validate_local(data_dir: Path) -> dict[str, pd.DataFrame]:
+    """Validate schemas, coverage, uniqueness, and fixed analysis conventions."""
+
+    frames: dict[str, pd.DataFrame] = {}
+    errors: list[str] = []
+
+    for name, columns in REQUIRED_COLUMNS.items():
+        path = data_dir / name
+        if not path.exists():
+            errors.append(f"missing required table: {path}")
+            continue
+        frame = pd.read_csv(path)
+        missing = sorted(columns - set(frame.columns))
+        _require(not missing, f"{name}: missing columns {missing}", errors)
+        if missing:
+            continue
+        frames[name] = frame
+
+    manifest_path = data_dir / "release_manifest.json"
+    if not manifest_path.exists():
+        errors.append(f"missing release manifest: {manifest_path}")
+    else:
+        try:
+            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError) as exc:
+            errors.append(f"invalid release manifest: {exc}")
+            manifest = {}
+        if not isinstance(manifest, dict):
+            errors.append("invalid release manifest: top-level value must be an object")
+            manifest = {}
+        raw_manifest_spaces = manifest.get("latent_coordinate_spaces", [])
+        if not isinstance(raw_manifest_spaces, list):
+            errors.append("release manifest: latent_coordinate_spaces must be a list")
+            raw_manifest_spaces = []
+        elif not all(isinstance(value, str) for value in raw_manifest_spaces):
+            errors.append("release manifest: coordinate-space values must be strings")
+            raw_manifest_spaces = []
+        manifest_spaces = set(raw_manifest_spaces)
+        _require(
+            manifest_spaces == {LATENT_COORDINATE_SPACE},
+            f"release manifest: coordinate spaces {sorted(manifest_spaces)}",
+            errors,
+        )
+        manifest_tables = manifest.get("tables", {})
+        if not isinstance(manifest_tables, dict):
+            errors.append("release manifest: tables must be an object")
+            manifest_tables = {}
+        for name in REQUIRED_COLUMNS:
+            entry = manifest_tables.get(name)
+            if not isinstance(entry, dict):
+                errors.append(f"release manifest: missing table entry {name}")
+                continue
+            path = data_dir / name
+            if not path.exists():
+                continue
+            expected_hash = entry.get("sha256")
+            actual_hash = _sha256(path)
+            _require(
+                expected_hash == actual_hash,
+                f"release manifest: SHA-256 mismatch for {name}",
+                errors,
+            )
+            if name in frames:
+                _require(
+                    entry.get("rows") == len(frames[name]),
+                    f"release manifest: row-count mismatch for {name}",
+                    errors,
+                )
+
+    for name, (n_rows, n_active) in EXPECTED_COVERAGE.items():
+        if name not in frames:
+            continue
+        frame = frames[name]
+        _require(len(frame) == n_rows, f"{name}: expected {n_rows} rows, found {len(frame)}", errors)
+        active = int(_active_mask(frame).sum())
+        _require(active == n_active, f"{name}: expected {n_active} available rows, found {active}", errors)
+
+    for name, keys in UNIQUE_KEYS.items():
+        if name not in frames or not set(keys).issubset(frames[name].columns):
+            continue
+        duplicates = frames[name].duplicated(keys, keep=False)
+        _require(not duplicates.any(), f"{name}: duplicate keys for {keys}", errors)
+
+    for name in ("clean_prediction_summary.csv", "robustness_summary.csv", "scalability_summary.csv"):
+        if name in frames:
+            observed = set(frames[name]["dataset"].dropna().astype(str))
+            _require(observed == DATASETS, f"{name}: dataset set is {sorted(observed)}", errors)
+
+    if "clean_prediction_summary.csv" in frames:
+        prediction = frames["clean_prediction_summary.csv"]
+        _require(prediction["model"].nunique() == 23, "prediction: expected 23 methods", errors)
+        metrics = set(prediction.loc[_active_mask(prediction), "metric"].dropna())
+        _require(metrics == {"accuracy", "r2"}, f"prediction: unexpected metrics {sorted(metrics)}", errors)
+
+    if "consistency_summary.csv" in frames:
+        consistency = frames["consistency_summary.csv"]
+        active = consistency.loc[_active_mask(consistency)]
+        observed = set(active["dataset"].dropna().astype(str))
+        _require(observed == CONSISTENCY_DATASETS, f"consistency: dataset set is {sorted(observed)}", errors)
+        norms = set(active["normalizations"].dropna().astype(str))
+        _require(norms == {"per_session_whitening"}, f"consistency: unexpected normalization {sorted(norms)}", errors)
+
+    if "neuron_shap_summary.csv" in frames:
+        feature = frames["neuron_shap_summary.csv"]
+        allen = feature[feature["dataset"].eq("allen_neuropixels")]
+        _require(not allen.empty and allen["spearman_corr"].notna().all(), "feature attribution: Allen Spearman values missing", errors)
+        other = feature[~feature["dataset"].eq("allen_neuropixels")]
+        _require(other["auc"].notna().all(), "feature attribution: ROC-AUC values missing", errors)
+        _require(feature["shap_min_value"].lt(0).any(), "feature attribution: signed negative values absent", errors)
+
+    if "trial_shapley_summary.csv" in frames:
+        trial = frames["trial_shapley_summary.csv"]
+        _require(set(trial["analysis"].dropna()) == {"subspace_rotation"}, "trial valuation: noncanonical analysis", errors)
+        angles = set(pd.to_numeric(trial["rotation_angle_deg"], errors="coerce").dropna())
+        _require(angles == {75.0}, f"trial valuation: rotation angles {sorted(angles)}", errors)
+        dims = set(trial["rotation_subspace_dim_spec"].dropna().astype(str))
+        _require(dims == {"full"}, f"trial valuation: subspace specs {sorted(dims)}", errors)
+        modes = set(trial["trial_selection_mode"].dropna().astype(str))
+        _require(modes == {"random"}, f"trial valuation: selection modes {sorted(modes)}", errors)
+        _require(trial["perturbation_auc"].notna().all(), "trial valuation: detection AUC missing", errors)
+        _require(trial["shapley_min_value"].lt(0).any(), "trial valuation: signed negative values absent", errors)
+
+    if "trial_shapley_retrain_summary.csv" in frames:
+        retrain = frames["trial_shapley_retrain_summary.csv"]
+        expected = {
+            "within_session_cleaning": {"mixed_full", "data_shapley", "oracle"},
+            "cross_session_old_trial_selection": {
+                "target_only", "all_sessions", "oldonly_dshap_negative_removal",
+            },
+        }
+        observed = {
+            analysis: set(group["condition"].dropna().astype(str))
+            for analysis, group in retrain.groupby("analysis")
+        }
+        _require(observed == expected, f"trial retraining: conditions {observed}", errors)
+
+    if "trial_historical_trajectories.csv" in frames:
+        historical = frames["trial_historical_trajectories.csv"]
+        _require(
+            len(historical) == 135 * 35,
+            "historical trajectories: expected 135 trials × 35 time bins",
+            errors,
+        )
+        keys = ["trial_index", "time_index"]
+        _require(
+            not historical.duplicated(keys, keep=False).any(),
+            f"historical trajectories: duplicate keys for {keys}",
+            errors,
+        )
+        _require(
+            set(historical["model"].dropna().astype(str)) == {"rnn"},
+            "historical trajectories: expected the Figure 5e RNN example",
+            errors,
+        )
+        _require(
+            set(historical["target_session"].dropna().astype(str))
+            == {FIGURE5_TARGET_SESSION},
+            "historical trajectories: unexpected target session",
+            errors,
+        )
+        _require(
+            historical["trial_index"].nunique() == 135
+            and historical["trial_id"].nunique() == 135,
+            "historical trajectories: expected 135 held-out trials and trial IDs",
+            errors,
+        )
+        time_counts = historical.groupby("trial_index")["time_index"].nunique()
+        _require(
+            len(time_counts) == 135 and time_counts.eq(35).all(),
+            "historical trajectories: every trial must contain 35 time bins",
+            errors,
+        )
+        direction_indices = pd.to_numeric(
+            historical["direction_index"], errors="coerce"
+        )
+        _require(
+            direction_indices.notna().all()
+            and set(direction_indices.astype(int)) == set(range(8)),
+            "historical trajectories: expected all eight reach directions",
+            errors,
+        )
+        for column in (
+            "target_x",
+            "target_y",
+            "current_only_x",
+            "current_only_y",
+            "historical_selected_x",
+            "historical_selected_y",
+            "current_only_r2",
+            "historical_selected_r2",
+        ):
+            values = pd.to_numeric(historical[column], errors="coerce")
+            _require(
+                values.notna().all() and np.isfinite(values.to_numpy()).all(),
+                f"historical trajectories: non-finite {column} values",
+                errors,
+            )
+        _require(
+            historical["current_only_r2"].nunique() == 1
+            and historical["historical_selected_r2"].nunique() == 1,
+            "historical trajectories: expected one R² value per condition",
+            errors,
+        )
+
+    for name in ("latent_samples.csv", "latent_trajectories.csv"):
+        if name not in frames:
+            continue
+        latent = frames[name]
+        observed = set(latent["dataset"].dropna().astype(str))
+        _require(observed.issubset(CONSISTENCY_DATASETS), f"{name}: unsupported datasets {sorted(observed - CONSISTENCY_DATASETS)}", errors)
+        for column in ("x", "y", "z"):
+            values = pd.to_numeric(latent[column], errors="coerce")
+            _require(
+                values.notna().all() and np.isfinite(values.to_numpy()).all(),
+                f"{name}: non-finite {column} values",
+                errors,
+            )
+        for column in (
+            "coordinate_space",
+            "reference_session",
+            "alignment",
+            "landmark_type",
+            "n_alignment_landmarks",
+            "is_reference",
+            "session_order",
+        ):
+            _require(
+                latent[column].notna().all(),
+                f"{name}: missing {column} values",
+                errors,
+            )
+        spaces = set(latent["coordinate_space"].dropna().astype(str))
+        _require(
+            spaces == {LATENT_COORDINATE_SPACE},
+            f"{name}: coordinate spaces {sorted(spaces)}",
+            errors,
+        )
+
+    if {
+        "consistency_summary.csv", "latent_samples.csv", "latent_trajectories.csv"
+    }.issubset(frames):
+        consistency = frames["consistency_summary.csv"]
+        consistency = consistency.loc[_active_mask(consistency)].copy()
+        samples = frames["latent_samples.csv"]
+        trajectories = frames["latent_trajectories.csv"]
+        expected_sample_sessions: set[tuple[str, str, str]] = set()
+        expected_trajectory_sessions: set[tuple[str, str, str]] = set()
+        for row in consistency.itertuples(index=False):
+            sessions = (
+                []
+                if pd.isna(row.sessions)
+                else [item.strip() for item in str(row.sessions).split(";") if item.strip()]
+            )
+            if not sessions:
+                errors.append(f"consistency: {row.model}/{row.dataset} has no sessions")
+                continue
+            try:
+                expected_n_sessions = int(row.n_sessions)
+            except (TypeError, ValueError):
+                expected_n_sessions = -1
+            _require(
+                len(sessions) == expected_n_sessions,
+                f"consistency: {row.model}/{row.dataset} lists {len(sessions)} "
+                f"sessions but n_sessions={row.n_sessions}",
+                errors,
+            )
+            expected_sample_sessions.update(
+                (str(row.model), str(row.dataset), session) for session in sessions
+            )
+            if str(row.dataset) != "ratinabox":
+                expected_trajectory_sessions.update(
+                    (str(row.model), str(row.dataset), session) for session in sessions
+                )
+            _validate_latent_cell(
+                samples,
+                table_label="latent samples",
+                model=str(row.model),
+                dataset=str(row.dataset),
+                sessions=sessions,
+                landmark_type=str(row.scoring_modes),
+                errors=errors,
+            )
+            if str(row.dataset) != "ratinabox":
+                _validate_latent_cell(
+                    trajectories,
+                    table_label="latent trajectories",
+                    model=str(row.model),
+                    dataset=str(row.dataset),
+                    sessions=sessions,
+                    landmark_type=str(row.scoring_modes),
+                    errors=errors,
+                )
+
+        observed_sample_sessions = set(
+            samples[["model", "dataset", "session"]].astype(str).itertuples(index=False, name=None)
+        )
+        observed_trajectory_sessions = set(
+            trajectories[["model", "dataset", "session"]].astype(str).itertuples(index=False, name=None)
+        )
+        _require(
+            observed_sample_sessions == expected_sample_sessions,
+            "latent samples: active consistency session coverage differs",
+            errors,
+        )
+        _require(
+            observed_trajectory_sessions == expected_trajectory_sessions,
+            "latent trajectories: applicable consistency session coverage differs",
+            errors,
+        )
+        _require(
+            len(observed_sample_sessions) == 173,
+            f"latent samples: expected 173 sessions, found {len(observed_sample_sessions)}",
+            errors,
+        )
+
+    if errors:
+        raise ValidationError("\n".join(f"- {item}" for item in errors))
+    return frames
+
+
+def validate_canonical(data_dir: Path, canonical_root: Path) -> None:
+    """Require Space summaries to equal the current paper result tables."""
+
+    results_dir = canonical_root / "paper" / "results"
+    errors: list[str] = []
+    for dashboard_name, paper_name in CANONICAL_NAMES.items():
+        dashboard_path = data_dir / dashboard_name
+        paper_path = results_dir / paper_name
+        if not dashboard_path.exists():
+            errors.append(f"missing dashboard table: {dashboard_path}")
+            continue
+        if not paper_path.exists():
+            errors.append(f"missing canonical table: {paper_path}")
+            continue
+        try:
+            _same_values(pd.read_csv(dashboard_path), pd.read_csv(paper_path))
+        except AssertionError as exc:
+            first_line = str(exc).splitlines()[0] if str(exc) else "values differ"
+            errors.append(f"{dashboard_name} != {paper_name}: {first_line}")
+    if errors:
+        raise ValidationError("\n".join(f"- {item}" for item in errors))
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--data-dir", type=Path, default=Path(__file__).resolve().parent / "data")
+    parser.add_argument(
+        "--canonical-root",
+        type=Path,
+        help="Main benchmark repository root; enables exact paper/results comparisons.",
+    )
+    return parser
+
+
+def main(argv: Iterable[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    frames = validate_local(args.data_dir)
+    if args.canonical_root is not None:
+        validate_canonical(args.data_dir, args.canonical_root.resolve())
+    print(f"Validated {len(frames)} BEND-BCI Space tables in {args.data_dir}")
+    if args.canonical_root is not None:
+        print("Canonical paper/results comparison passed")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())