feat(eeg,frontend): EEG fusion-flow test + Streamlit EEG form + real-artifact sanity

- tests/fusion/test_eeg_modality_flow.py: end-to-end EEG -> fusion `eeg`
modality flow (alzheimers feature spike lifts AD score; control profile
doesn't inflate it).
- tests/models/test_eeg_model_real.py: skip-if-absent sanity for the real
EEG joblib; runs automatically once the file lands at the canonical path.
- src/frontend/app.py: doctor MRI tab grows an EEG predict form
(comma-separated features) calling POST /predict/eeg. 503 surfaces as a
human-readable warning instead of a stack trace.

src/frontend/app.py

@@ -1414,6 +1414,47 @@ def _render_mri_tab() -> None:
                     if probs:
                         st.dataframe(probs, use_container_width=True, hide_index=True)
 
+    st.markdown("#### EEG Pretrained Classifier")
+    st.caption(
+        "Stub-able for the demo: drop a sklearn `predict_proba` joblib at "
+        "`data/processed/eeg_clf.joblib` (or set `EEG_CLF_ARTIFACT`). Default "
+        "labels are `(control, alzheimers)` — override via `EEG_CLF_LABELS`."
+    )
+    eeg_csv = st.text_area(
+        "EEG features (comma-separated)",
+        ",".join(["0.0"] * 16),
+        key="eeg_predict_features",
+        height=80,
+    )
+    if st.button("Predict EEG", key="eeg_predict"):
+        try:
+            features = [float(x.strip()) for x in eeg_csv.split(",") if x.strip()]
+        except ValueError:
+            st.error("EEG features must all be numeric.")
+        else:
+            payload = {"features": features}
+            with st.spinner("Running EEG classifier..."):
+                try:
+                    result = _post("/predict/eeg", payload, timeout=30.0)
+                except httpx.HTTPStatusError as e:
+                    if e.response.status_code == 503:
+                        st.warning(
+                            "EEG model artifact missing. Drop the trained joblib at "
+                            "`data/processed/eeg_clf.joblib` or set `EEG_CLF_ARTIFACT`."
+                        )
+                    else:
+                        st.error(f"EEG prediction failed (HTTP {e.response.status_code}): {e.response.text}")
+                except httpx.RequestError as e:
+                    st.error(f"Cannot reach FastAPI at {_API_URL}: {e!r}")
+                else:
+                    st.metric(
+                        label=result.get("label_text", "prediction"),
+                        value=f"{float(result.get('confidence', 0.0)) * 100:.1f}%",
+                    )
+                    probs = result.get("probabilities", [])
+                    if probs:
+                        st.dataframe(probs, use_container_width=True, hide_index=True)
+
 
 def _render_prediction_card(result: dict) -> None:
     """Editorial decision card: provenance · verdict · signals · SHAP."""

tests/fusion/test_eeg_modality_flow.py

@@ -0,0 +1,52 @@
+"""End-to-end: EEG classifier output flows into fusion as the `eeg` modality."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+
+from src.fusion import engine
+from src.fusion.types import (
+    FusionInput,
+    ModalityClassProb,
+    ModalityPrediction,
+)
+from src.models import eeg_model
+from tests.fixtures.build_dummy_eeg_clf import build as build_dummy_eeg
+
+
+def _eeg_pred_from_features(model, features: np.ndarray) -> ModalityPrediction:
+    raw = eeg_model.predict_features(model, features)
+    return ModalityPrediction(
+        label_text=raw["label_text"],
+        label=raw["label"],
+        confidence=raw["confidence"],
+        probabilities=[
+            ModalityClassProb(label_text=p["label_text"], probability=p["probability"])
+            for p in raw["probabilities"]
+        ],
+    )
+
+
+class TestEEGFusionFlow:
+    def test_alzheimers_eeg_lifts_alzheimers_disease_score(self, tmp_path: Path) -> None:
+        ckpt = build_dummy_eeg(tmp_path / "eeg.joblib", n_features=16)
+        model = eeg_model.load(ckpt)
+        eeg_pred = _eeg_pred_from_features(model, np.full((16,), 2.0, dtype=np.float32))
+
+        out = engine.fuse(FusionInput(eeg=eeg_pred))
+
+        alz = next(d for d in out.diseases if d.disease == "alzheimers")
+        assert alz.probability > 0.5
+        assert any(c.modality == "eeg" for c in alz.contributions)
+        assert "mri" in out.missing_inputs
+
+    def test_control_eeg_does_not_inflate_alzheimers(self, tmp_path: Path) -> None:
+        ckpt = build_dummy_eeg(tmp_path / "eeg.joblib", n_features=16)
+        model = eeg_model.load(ckpt)
+        eeg_pred = _eeg_pred_from_features(model, np.zeros((16,), dtype=np.float32))
+
+        out = engine.fuse(FusionInput(eeg=eeg_pred))
+
+        alz = next(d for d in out.diseases if d.disease == "alzheimers")
+        assert alz.probability < 0.5

tests/models/test_eeg_model_real.py

@@ -0,0 +1,23 @@
+"""Real-artifact EEG sanity. Skipped unless data/processed/eeg_clf.joblib exists."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from src.models import eeg_model
+
+
+REAL_CKPT = Path("data/processed/eeg_clf.joblib")
+
+
+@pytest.mark.skipif(not REAL_CKPT.exists(), reason="real EEG checkpoint not present")
+def test_real_eeg_checkpoint_loads_and_predicts():
+    model = eeg_model.load(REAL_CKPT)
+    n_features = int(getattr(model, "n_features_in_", 16))
+    features = np.zeros((n_features,), dtype=np.float32)
+    out = eeg_model.predict_features(model, features)
+    s = sum(p["probability"] for p in out["probabilities"])
+    assert abs(s - 1.0) < 1e-5
+    assert out["label_text"]