docs: add Day 2 EEG MNE+ICA pipeline plan

Add a comprehensive implementation plan for NeuroBridge Day 2: an EEG pipeline using MNE + ICA. The new markdown (docs/superpowers/plans/2026-04-30-day2-eeg-mne-ica-pipeline.md) specifies goals, architecture, public API (is_valid_epoch, bandpass_filter, remove_artifacts_with_ica, compute_features_from_epoch, extract_features_from_recording, run_pipeline), tech stack, file layout, TDD tasks (fixture, unit tests, feature implementation, orchestrator/CLI), expected behavior, logging, determinism requirements, Parquet output schema, and a Definition of Done checklist. The document provides step-by-step tasks and expected test outcomes to guide development and verification.

docs/superpowers/plans/2026-04-30-day2-eeg-mne-ica-pipeline.md

@@ -0,0 +1,1281 @@
+# NeuroBridge Day 2 — EEG MNE+ICA Pipeline Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Insider One Hackathon Day 2 — ship a production-grade EEG pipeline that loads raw recordings, bandpass-filters, removes EOG artifacts via ICA, slices into epochs, computes per-band PSD + statistical features, flattens to a 2D table, and persists as Parquet.
+
+**Architecture:** Modular `src/pipelines/eeg_pipeline.py` mirroring Day 1's BBB four-public-function pattern: a small validity primitive (`is_valid_epoch`), three pure transformers (`bandpass_filter`, `remove_artifacts_with_ica`, `compute_features_from_epoch`), one DataFrame-emitting layer (`extract_features_from_recording`), and one I/O orchestrator (`run_pipeline`). All logging goes through `src.core.logger.get_logger`. Output is Parquet per AGENTS.md §6. Tests use a deterministic synthetic `mne.io.RawArray` fixture so the suite stays under 5 s on a laptop.
+
+**Tech Stack:** Python 3.10–3.12, `mne==1.7.1`, NumPy, SciPy (`scipy.stats.skew`, `kurtosis`), Pandas, PyArrow, Pytest.
+
+---
+
+## File Structure
+
+| Path | Responsibility |
+|---|---|
+| `src/pipelines/eeg_pipeline.py` | Public API (`is_valid_epoch`, `bandpass_filter`, `remove_artifacts_with_ica`, `compute_features_from_epoch`, `extract_features_from_recording`, `run_pipeline`) + `DEFAULT_INPUT` / `DEFAULT_OUTPUT` + `__main__` CLI. |
+| `tests/pipelines/test_eeg_pipeline.py` | Unit + integration tests; one class per public function. |
+| `tests/fixtures/eeg_sample.fif` | Deterministic synthetic Raw (5 ch, 256 Hz, 10 s) with seeded sine signals + EOG-like blinks; built once on disk via a tiny build script. |
+| `tests/fixtures/build_eeg_fixture.py` | Standalone script that regenerates `eeg_sample.fif` from a fixed seed; committed alongside the .fif so anyone can reproduce. |
+| `AGENTS.md` | Update §1 pipeline table row for EEG to "Shipped". |
+| `README.md` | Update Status table EEG row to "Shipped"; bump test count. |
+
+The `eeg_pipeline.py` module is expected to land at ~250–280 lines after Task 7. We do not split into submodules at this stage — Day 1's BBB pattern works well at this size.
+
+---
+
+## Public API contract (defined here so tasks reference one source of truth)
+
+```python
+EEG_BANDS: dict[str, tuple[float, float]] = {
+    "delta": (1.0, 4.0),
+    "theta": (4.0, 8.0),
+    "alpha": (8.0, 13.0),
+    "beta":  (13.0, 30.0),
+    "gamma": (30.0, 40.0),
+}
+STATS: tuple[str, ...] = ("mean", "std", "var", "skew", "kurtosis")
+
+def is_valid_epoch(epoch: np.ndarray) -> bool: ...
+def bandpass_filter(raw: mne.io.BaseRaw, l_freq: float = 1.0, h_freq: float = 40.0) -> mne.io.BaseRaw: ...
+def remove_artifacts_with_ica(
+    raw: mne.io.BaseRaw,
+    eog_ch_name: str | None = None,
+    n_components: int = 15,
+    random_state: int = 97,
+) -> mne.io.BaseRaw: ...
+def compute_features_from_epoch(epoch: np.ndarray, sfreq: float) -> np.ndarray: ...
+def extract_features_from_recording(
+    raw: mne.io.BaseRaw,
+    epoch_duration_s: float = 2.0,
+    eog_ch_name: str | None = None,
+    n_components: int = 15,
+    random_state: int = 97,
+) -> pd.DataFrame: ...
+def run_pipeline(
+    input_path: Path = DEFAULT_INPUT,
+    output_path: Path = DEFAULT_OUTPUT,
+    epoch_duration_s: float = 2.0,
+    eog_ch_name: str | None = None,
+    n_components: int = 15,
+    random_state: int = 97,
+) -> None: ...
+```
+
+Per-epoch feature vector shape: `(n_channels * (len(EEG_BANDS) + len(STATS)),)` = `n_channels * 10` floats. For 4 EEG channels → 40 features per epoch. Column names: `feat_<channel_name>_psd_<band>` and `feat_<channel_name>_<stat>` — alphabetical and deterministic given a fixed channel order.
+
+---
+
+## Task 1: EEG Test Fixture (deterministic synthetic .fif)
+
+**Files:**
+- Create: `tests/fixtures/build_eeg_fixture.py`
+- Create: `tests/fixtures/eeg_sample.fif` (regenerated by the script above)
+
+- [ ] **Step 1: Write the fixture-builder script**
+
+Create `/Users/mertgungor/Desktop/hackathon/tests/fixtures/build_eeg_fixture.py`:
+```python
+"""Generate a deterministic synthetic MNE Raw fixture for EEG pipeline tests.
+
+The fixture is committed to the repo alongside this script so test runs are
+reproducible without re-running the script. Re-run only if the contract changes.
+
+Channels: 4 EEG (Cz, Pz, O1, O2) + 1 EOG (EOG061).
+Sampling rate: 256 Hz. Duration: 10 s.
+Synthetic content: a 10 Hz alpha sine on each EEG channel, plus a 1.5 Hz EOG
+"blink" injected on EOG061 and bleed-through on the frontal-most EEG channel
+(Cz) so ICA has something to detect.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import mne
+import numpy as np
+
+
+def build() -> Path:
+    rng = np.random.default_rng(seed=42)
+    sfreq = 256.0
+    duration_s = 10.0
+    n_samples = int(sfreq * duration_s)
+    t = np.arange(n_samples) / sfreq
+
+    # Base alpha (10 Hz) + small white noise on every EEG channel.
+    eeg_alpha = np.sin(2 * np.pi * 10.0 * t)
+    eeg_noise = rng.standard_normal((4, n_samples)) * 1e-6
+    eeg = (eeg_alpha[None, :] * 1e-5) + eeg_noise
+
+    # EOG blink: low-frequency square-ish pulse train at ~1.5 Hz.
+    eog_pulse = (np.sin(2 * np.pi * 1.5 * t) > 0.95).astype(float) * 1e-4
+
+    # Bleed EOG into Cz (channel 0) so ICA finds an EOG-correlated component.
+    eeg[0] += 0.3 * eog_pulse
+
+    data = np.vstack([eeg, eog_pulse[None, :]])  # shape: (5, n_samples)
+
+    info = mne.create_info(
+        ch_names=["Cz", "Pz", "O1", "O2", "EOG061"],
+        sfreq=sfreq,
+        ch_types=["eeg", "eeg", "eeg", "eeg", "eog"],
+    )
+    raw = mne.io.RawArray(data, info, verbose="ERROR")
+
+    out = Path(__file__).parent / "eeg_sample.fif"
+    raw.save(out, overwrite=True, verbose="ERROR")
+    return out
+
+
+if __name__ == "__main__":
+    p = build()
+    print(f"Wrote {p}")
+```
+
+- [ ] **Step 2: Run the script to generate the .fif**
+
+```bash
+cd /Users/mertgungor/Desktop/hackathon
+source .venv312/bin/activate
+python tests/fixtures/build_eeg_fixture.py
+```
+Expected: prints `Wrote .../tests/fixtures/eeg_sample.fif`. File size ~50 KB.
+
+- [ ] **Step 3: Sanity-check the fixture**
+
+```bash
+python -c "
+import mne
+raw = mne.io.read_raw_fif('tests/fixtures/eeg_sample.fif', preload=True, verbose='ERROR')
+print('ch_names:', raw.ch_names)
+print('sfreq:', raw.info['sfreq'])
+print('n_times:', raw.n_times)
+print('eog channel present:', 'EOG061' in raw.ch_names)
+"
+```
+Expected:
+```
+ch_names: ['Cz', 'Pz', 'O1', 'O2', 'EOG061']
+sfreq: 256.0
+n_times: 2560
+eog channel present: True
+```
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add tests/fixtures/build_eeg_fixture.py tests/fixtures/eeg_sample.fif
+git commit -m "test(eeg): add deterministic synthetic Raw fixture (5 ch, 256 Hz, 10 s)"
+```
+
+---
+
+## Task 2: `is_valid_epoch` (TDD)
+
+**Files:**
+- Create: `tests/pipelines/test_eeg_pipeline.py` (new)
+- Create: `src/pipelines/eeg_pipeline.py` (new)
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `/Users/mertgungor/Desktop/hackathon/tests/pipelines/test_eeg_pipeline.py`:
+```python
+"""Unit + integration tests for the EEG pipeline."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from src.pipelines.eeg_pipeline import is_valid_epoch
+
+
+FIXTURE = Path(__file__).parent.parent / "fixtures" / "eeg_sample.fif"
+
+
+class TestIsValidEpoch:
+    def test_accepts_2d_finite_array(self) -> None:
+        epoch = np.zeros((4, 256), dtype=np.float64)
+        assert is_valid_epoch(epoch) is True
+
+    def test_rejects_wrong_dimension(self) -> None:
+        assert is_valid_epoch(np.zeros((4,))) is False
+        assert is_valid_epoch(np.zeros((4, 256, 2))) is False
+
+    def test_rejects_nan(self) -> None:
+        epoch = np.zeros((4, 256))
+        epoch[0, 10] = np.nan
+        assert is_valid_epoch(epoch) is False
+
+    def test_rejects_inf(self) -> None:
+        epoch = np.zeros((4, 256))
+        epoch[1, 5] = np.inf
+        assert is_valid_epoch(epoch) is False
+
+    def test_rejects_empty(self) -> None:
+        assert is_valid_epoch(np.zeros((0, 256))) is False
+        assert is_valid_epoch(np.zeros((4, 0))) is False
+
+    def test_rejects_non_array(self) -> None:
+        assert is_valid_epoch([[1, 2, 3]]) is False
+        assert is_valid_epoch(None) is False
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+```bash
+pytest tests/pipelines/test_eeg_pipeline.py -v
+```
+Expected: collection failure on `from src.pipelines.eeg_pipeline import is_valid_epoch` → `ModuleNotFoundError`.
+
+- [ ] **Step 3: Write the implementation**
+
+Create `/Users/mertgungor/Desktop/hackathon/src/pipelines/eeg_pipeline.py`:
+```python
+"""EEG (electroencephalography) pipeline.
+
+Loads raw recordings (FIF/EDF), bandpass-filters, removes EOG artifacts via
+ICA, slices into fixed-duration epochs, computes per-band PSD + statistical
+features, flattens to a 2D table, and writes a model-ready Parquet at
+`data/processed/eeg_features.parquet`.
+
+Follows the Data Readiness contract in AGENTS.md §4 and the Parquet storage
+convention in §6: schema validity, domain validity (drop NaN/inf epochs with
+a logged WARNING), determinism (seeded ICA + sklearn RNG), traceability
+(in/out/dropped counts at INFO), and idempotent overwrite output.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from src.core.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def is_valid_epoch(epoch: object) -> bool:
+    """Return True iff `epoch` is a non-empty 2-D float array with no NaN/inf.
+
+    Used to drop corrupted segments before feature extraction. Defensive
+    against the full set of garbage we expect from real recordings: lists,
+    None, NaN/inf samples, zero-sized arrays.
+    """
+    if not isinstance(epoch, np.ndarray):
+        return False
+    if epoch.ndim != 2:
+        return False
+    if epoch.size == 0:
+        return False
+    if not np.all(np.isfinite(epoch)):
+        return False
+    return True
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+```bash
+pytest tests/pipelines/test_eeg_pipeline.py -v
+```
+Expected: **6 PASS** in `TestIsValidEpoch`. Total suite: 36 (30 prior + 6).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/pipelines/test_eeg_pipeline.py src/pipelines/eeg_pipeline.py
+git commit -m "feat(eeg): add is_valid_epoch guard for NaN/inf/shape/dtype"
+```
+
+---
+
+## Task 3: `bandpass_filter` (TDD)
+
+**Files:**
+- Modify: `tests/pipelines/test_eeg_pipeline.py`
+- Modify: `src/pipelines/eeg_pipeline.py`
+
+- [ ] **Step 1: Append the failing tests**
+
+Update the merged import at the top of `tests/pipelines/test_eeg_pipeline.py`. Replace:
+```python
+from src.pipelines.eeg_pipeline import is_valid_epoch
+```
+with:
+```python
+import mne
+
+from src.pipelines.eeg_pipeline import (
+    bandpass_filter,
+    is_valid_epoch,
+)
+```
+
+Append at the end of `tests/pipelines/test_eeg_pipeline.py`:
+```python
+
+
+class TestBandpassFilter:
+    def _load(self) -> mne.io.BaseRaw:
+        return mne.io.read_raw_fif(FIXTURE, preload=True, verbose="ERROR")
+
+    def test_returns_raw_instance(self) -> None:
+        raw = self._load()
+        out = bandpass_filter(raw, l_freq=1.0, h_freq=40.0)
+        assert isinstance(out, mne.io.BaseRaw)
+
+    def test_preserves_shape(self) -> None:
+        raw = self._load()
+        n_ch_before, n_t_before = raw.get_data().shape
+        out = bandpass_filter(raw, l_freq=1.0, h_freq=40.0)
+        assert out.get_data().shape == (n_ch_before, n_t_before)
+
+    def test_attenuates_dc_component(self) -> None:
+        """A bandpass with l_freq=1.0 must remove a DC offset."""
+        raw = self._load()
+        # Inject a large DC offset on every channel.
+        data = raw.get_data() + 1e-3
+        raw_dc = mne.io.RawArray(data, raw.info, verbose="ERROR")
+        out = bandpass_filter(raw_dc, l_freq=1.0, h_freq=40.0)
+        # Mean on each channel should be near zero (much smaller than 1e-3).
+        assert np.all(np.abs(out.get_data().mean(axis=1)) < 1e-4)
+
+    def test_does_not_mutate_input(self) -> None:
+        raw = self._load()
+        original_mean = raw.get_data().mean()
+        _ = bandpass_filter(raw, l_freq=1.0, h_freq=40.0)
+        assert raw.get_data().mean() == pytest.approx(original_mean, rel=1e-12)
+```
+
+- [ ] **Step 2: Run tests; they MUST fail**
+
+```bash
+pytest tests/pipelines/test_eeg_pipeline.py::TestBandpassFilter -v
+```
+Expected: 4 FAILS with `cannot import name 'bandpass_filter'`.
+
+- [ ] **Step 3: Implement `bandpass_filter`**
+
+Append to `/Users/mertgungor/Desktop/hackathon/src/pipelines/eeg_pipeline.py`:
+```python
+import mne
+
+
+def bandpass_filter(
+    raw: mne.io.BaseRaw,
+    l_freq: float = 1.0,
+    h_freq: float = 40.0,
+) -> mne.io.BaseRaw:
+    """Apply a non-mutating bandpass filter to an MNE Raw.
+
+    Default 1–40 Hz removes drift below 1 Hz and high-frequency noise / line
+    artifacts above 40 Hz. Returns a copy; the input `raw` is unchanged.
+
+    Args:
+        raw: Loaded `mne.io.BaseRaw` (call `.load_data()` first if from disk).
+        l_freq: Low-cut frequency in Hz.
+        h_freq: High-cut frequency in Hz.
+
+    Returns:
+        A filtered copy of `raw`.
+    """
+    out = raw.copy()
+    out.filter(l_freq=l_freq, h_freq=h_freq, picks="all", verbose="ERROR")
+    logger.info("Bandpass filter applied: %.1f-%.1f Hz", l_freq, h_freq)
+    return out
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+```bash
+pytest tests/pipelines/test_eeg_pipeline.py -v
+```
+Expected: 10 PASS (6 prior EEG + 4 bandpass).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/pipelines/test_eeg_pipeline.py src/pipelines/eeg_pipeline.py
+git commit -m "feat(eeg): add non-mutating bandpass_filter (default 1-40 Hz)"
+```
+
+---
+
+## Task 4: `remove_artifacts_with_ica` (TDD)
+
+**Files:**
+- Modify: `tests/pipelines/test_eeg_pipeline.py`
+- Modify: `src/pipelines/eeg_pipeline.py`
+
+- [ ] **Step 1: Append the failing tests**
+
+Extend the merged test import tuple:
+```python
+from src.pipelines.eeg_pipeline import (
+    bandpass_filter,
+    is_valid_epoch,
+    remove_artifacts_with_ica,
+)
+```
+
+Append:
+```python
+
+
+class TestRemoveArtifactsWithIca:
+    def _load(self) -> mne.io.BaseRaw:
+        return mne.io.read_raw_fif(FIXTURE, preload=True, verbose="ERROR")
+
+    def test_returns_raw_instance(self) -> None:
+        raw = bandpass_filter(self._load(), l_freq=1.0, h_freq=40.0)
+        out = remove_artifacts_with_ica(
+            raw, eog_ch_name="EOG061", n_components=4, random_state=97,
+        )
+        assert isinstance(out, mne.io.BaseRaw)
+
+    def test_preserves_shape(self) -> None:
+        raw = bandpass_filter(self._load(), l_freq=1.0, h_freq=40.0)
+        before = raw.get_data().shape
+        out = remove_artifacts_with_ica(
+            raw, eog_ch_name="EOG061", n_components=4, random_state=97,
+        )
+        assert out.get_data().shape == before
+
+    def test_reduces_eog_correlation_on_frontal_channel(self) -> None:
+        """ICA must reduce correlation between EOG and Cz (the bleed channel)."""
+        raw = bandpass_filter(self._load(), l_freq=1.0, h_freq=40.0)
+        before = raw.get_data()
+        cz_idx = raw.ch_names.index("Cz")
+        eog_idx = raw.ch_names.index("EOG061")
+        corr_before = abs(np.corrcoef(before[cz_idx], before[eog_idx])[0, 1])
+
+        out = remove_artifacts_with_ica(
+            raw, eog_ch_name="EOG061", n_components=4, random_state=97,
+        )
+        after = out.get_data()
+        corr_after = abs(np.corrcoef(after[cz_idx], after[eog_idx])[0, 1])
+        # Allow for noise — but the dominant EOG bleed must be reduced.
+        assert corr_after < corr_before
+
+    def test_no_eog_channel_is_a_noop(self) -> None:
+        """Without an EOG reference, ICA can't auto-reject — should pass through."""
+        raw = bandpass_filter(self._load(), l_freq=1.0, h_freq=40.0)
+        out = remove_artifacts_with_ica(
+            raw, eog_ch_name=None, n_components=4, random_state=97,
+        )
+        # Identical shape; data approximately equal (no rejection happened).
+        assert out.get_data().shape == raw.get_data().shape
+        np.testing.assert_allclose(
+            out.get_data(), raw.get_data(), rtol=1e-6, atol=1e-12
+        )
+
+    def test_is_deterministic_with_seed(self) -> None:
+        raw = bandpass_filter(self._load(), l_freq=1.0, h_freq=40.0)
+        a = remove_artifacts_with_ica(
+            raw, eog_ch_name="EOG061", n_components=4, random_state=97,
+        )
+        b = remove_artifacts_with_ica(
+            raw, eog_ch_name="EOG061", n_components=4, random_state=97,
+        )
+        np.testing.assert_allclose(a.get_data(), b.get_data(), rtol=1e-12, atol=1e-15)
+```
+
+- [ ] **Step 2: Run tests; they MUST fail**
+
+```bash
+pytest tests/pipelines/test_eeg_pipeline.py::TestRemoveArtifactsWithIca -v
+```
+Expected: 5 FAILS with `cannot import name 'remove_artifacts_with_ica'`.
+
+- [ ] **Step 3: Implement `remove_artifacts_with_ica`**
+
+Append to `src/pipelines/eeg_pipeline.py`:
+```python
+from mne.preprocessing import ICA
+
+
+def remove_artifacts_with_ica(
+    raw: mne.io.BaseRaw,
+    eog_ch_name: str | None = None,
+    n_components: int = 15,
+    random_state: int = 97,
+) -> mne.io.BaseRaw:
+    """Remove EOG-like artifacts using MNE's ICA + EOG correlation.
+
+    Fits an ICA decomposition on `raw`, finds components whose time courses
+    correlate with the named EOG channel via `find_bads_eog`, marks them as
+    "bad" and reconstructs the signal without them. Returns a copy; the
+    input `raw` is unchanged.
+
+    If `eog_ch_name` is None or no bad components are found, returns a
+    copy of `raw` unchanged. This keeps the function safe to call on
+    recordings without an EOG reference.
+
+    Args:
+        raw: Loaded, ideally bandpass-filtered, `mne.io.BaseRaw`.
+        eog_ch_name: Name of the EOG channel for correlation-based detection.
+            None disables auto-rejection.
+        n_components: Number of ICA components. For small recordings, MNE
+            will silently cap this at the rank of the data.
+        random_state: Seed for ICA's underlying solver. Required for §4
+            Determinism.
+
+    Returns:
+        A copy of `raw` with EOG-correlated ICA components removed.
+    """
+    out = raw.copy()
+    if eog_ch_name is None or eog_ch_name not in out.ch_names:
+        logger.info("ICA skipped: no EOG channel reference provided")
+        return out
+
+    # Cap n_components at the rank of the data to avoid solver complaints
+    # on small synthetic fixtures.
+    n_eeg = len(mne.pick_types(out.info, eeg=True, meg=False))
+    safe_n = min(n_components, max(n_eeg - 1, 1))
+
+    ica = ICA(
+        n_components=safe_n,
+        random_state=random_state,
+        max_iter="auto",
+        method="fastica",
+        verbose="ERROR",
+    )
+    ica.fit(out, picks="eeg", verbose="ERROR")
+    bad_idx, _ = ica.find_bads_eog(out, ch_name=eog_ch_name, verbose="ERROR")
+    ica.exclude = list(bad_idx)
+    logger.info(
+        "ICA fit: n_components=%d, EOG-correlated rejected=%d",
+        safe_n, len(ica.exclude),
+    )
+    ica.apply(out, verbose="ERROR")
+    return out
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+```bash
+pytest tests/pipelines/test_eeg_pipeline.py -v
+```
+Expected: 15 PASS (10 prior + 5 ICA).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/pipelines/test_eeg_pipeline.py src/pipelines/eeg_pipeline.py
+git commit -m "feat(eeg): add remove_artifacts_with_ica with EOG correlation rejection"
+```
+
+---
+
+## Task 5: `compute_features_from_epoch` (TDD)
+
+**Files:**
+- Modify: `tests/pipelines/test_eeg_pipeline.py`
+- Modify: `src/pipelines/eeg_pipeline.py`
+
+- [ ] **Step 1: Append the failing tests**
+
+Extend the merged test import tuple:
+```python
+from src.pipelines.eeg_pipeline import (
+    bandpass_filter,
+    compute_features_from_epoch,
+    is_valid_epoch,
+    remove_artifacts_with_ica,
+)
+```
+Also add at the top of the test file (after the existing imports), the band/stat constants for assertions:
+```python
+EEG_BANDS = ("delta", "theta", "alpha", "beta", "gamma")
+STATS = ("mean", "std", "var", "skew", "kurtosis")
+```
+
+Append:
+```python
+
+
+class TestComputeFeaturesFromEpoch:
+    def test_returns_1d_float_array(self) -> None:
+        epoch = np.random.default_rng(0).standard_normal((4, 256))
+        out = compute_features_from_epoch(epoch, sfreq=256.0)
+        assert isinstance(out, np.ndarray)
+        assert out.ndim == 1
+        assert out.dtype == np.float64
+
+    def test_feature_count_matches_contract(self) -> None:
+        """Each channel contributes len(EEG_BANDS) PSD features + len(STATS) stats."""
+        n_channels = 4
+        epoch = np.random.default_rng(0).standard_normal((n_channels, 256))
+        out = compute_features_from_epoch(epoch, sfreq=256.0)
+        expected = n_channels * (len(EEG_BANDS) + len(STATS))
+        assert out.shape == (expected,)
+
+    def test_alpha_band_dominates_for_alpha_signal(self) -> None:
+        """Pure 10 Hz sine on 1 channel should put most PSD power in alpha (8-13 Hz)."""
+        sfreq = 256.0
+        t = np.arange(int(sfreq * 2.0)) / sfreq
+        signal = np.sin(2 * np.pi * 10.0 * t)[None, :]  # (1, n_samples)
+        out = compute_features_from_epoch(signal, sfreq=sfreq)
+        # Layout for n_channels=1: [psd_delta, psd_theta, psd_alpha, psd_beta, psd_gamma, mean, std, var, skew, kurtosis]
+        psd_block = out[: len(EEG_BANDS)]
+        alpha_idx = EEG_BANDS.index("alpha")
+        assert psd_block[alpha_idx] == psd_block.max()
+
+    def test_finite_output(self) -> None:
+        epoch = np.random.default_rng(0).standard_normal((4, 256))
+        out = compute_features_from_epoch(epoch, sfreq=256.0)
+        assert np.all(np.isfinite(out))
+
+    def test_deterministic_for_same_input(self) -> None:
+        epoch = np.random.default_rng(0).standard_normal((4, 256))
+        a = compute_features_from_epoch(epoch, sfreq=256.0)
+        b = compute_features_from_epoch(epoch, sfreq=256.0)
+        np.testing.assert_array_equal(a, b)
+```
+
+- [ ] **Step 2: Run tests; they MUST fail**
+
+```bash
+pytest tests/pipelines/test_eeg_pipeline.py::TestComputeFeaturesFromEpoch -v
+```
+Expected: 5 FAILS with `cannot import name 'compute_features_from_epoch'`.
+
+- [ ] **Step 3: Implement features**
+
+Append to `src/pipelines/eeg_pipeline.py`:
+```python
+from scipy import signal as scipy_signal
+from scipy import stats as scipy_stats
+
+
+EEG_BANDS: dict[str, tuple[float, float]] = {
+    "delta": (1.0, 4.0),
+    "theta": (4.0, 8.0),
+    "alpha": (8.0, 13.0),
+    "beta":  (13.0, 30.0),
+    "gamma": (30.0, 40.0),
+}
+STATS: tuple[str, ...] = ("mean", "std", "var", "skew", "kurtosis")
+
+
+def _band_power(freqs: np.ndarray, psd: np.ndarray, lo: float, hi: float) -> float:
+    """Mean PSD value within the [lo, hi) frequency band."""
+    mask = (freqs >= lo) & (freqs < hi)
+    if not mask.any():
+        return 0.0
+    return float(psd[mask].mean())
+
+
+def compute_features_from_epoch(epoch: np.ndarray, sfreq: float) -> np.ndarray:
+    """Compute PSD-band + statistical features for one epoch.
+
+    Per channel, the feature block is:
+      [psd_delta, psd_theta, psd_alpha, psd_beta, psd_gamma,
+       mean, std, var, skew, kurtosis]
+    Channels are stacked in their input order. The resulting 1-D vector has
+    length `n_channels * (len(EEG_BANDS) + len(STATS))`.
+
+    PSD is computed with Welch's method (`scipy.signal.welch`) at the
+    epoch's sample rate. Higher moments use `scipy.stats` with default
+    bias correction.
+
+    Args:
+        epoch: A 2-D array shape (n_channels, n_samples).
+        sfreq: Sampling rate in Hz.
+
+    Returns:
+        A 1-D `np.ndarray` of dtype float64.
+    """
+    n_channels, n_samples = epoch.shape
+    nperseg = min(256, n_samples)
+    feats: list[float] = []
+    for ch in range(n_channels):
+        x = epoch[ch]
+        freqs, psd = scipy_signal.welch(x, fs=sfreq, nperseg=nperseg)
+        for _band, (lo, hi) in EEG_BANDS.items():
+            feats.append(_band_power(freqs, psd, lo, hi))
+        feats.append(float(np.mean(x)))
+        feats.append(float(np.std(x)))
+        feats.append(float(np.var(x)))
+        feats.append(float(scipy_stats.skew(x)))
+        feats.append(float(scipy_stats.kurtosis(x)))
+    return np.asarray(feats, dtype=np.float64)
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+```bash
+pytest tests/pipelines/test_eeg_pipeline.py -v
+```
+Expected: 20 PASS (15 prior + 5 features).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/pipelines/test_eeg_pipeline.py src/pipelines/eeg_pipeline.py
+git commit -m "feat(eeg): add compute_features_from_epoch (PSD bands + 5 statistics)"
+```
+
+---
+
+## Task 6: `extract_features_from_recording` (TDD — flatten to 2D table)
+
+**Files:**
+- Modify: `tests/pipelines/test_eeg_pipeline.py`
+- Modify: `src/pipelines/eeg_pipeline.py`
+
+- [ ] **Step 1: Append the failing tests**
+
+Extend the merged test import tuple:
+```python
+from src.pipelines.eeg_pipeline import (
+    bandpass_filter,
+    compute_features_from_epoch,
+    extract_features_from_recording,
+    is_valid_epoch,
+    remove_artifacts_with_ica,
+)
+```
+Also add `import pandas as pd` at the top of the test file (in the third-party block, alphabetical: numpy → pandas → pytest).
+
+Append:
+```python
+
+
+class TestExtractFeaturesFromRecording:
+    def _load(self) -> mne.io.BaseRaw:
+        return mne.io.read_raw_fif(FIXTURE, preload=True, verbose="ERROR")
+
+    def test_returns_dataframe(self) -> None:
+        raw = self._load()
+        df = extract_features_from_recording(
+            raw, epoch_duration_s=2.0, eog_ch_name="EOG061",
+            n_components=4, random_state=97,
+        )
+        assert isinstance(df, pd.DataFrame)
+
+    def test_row_count_matches_epochs(self) -> None:
+        """10 s recording / 2 s epoch = 5 epochs."""
+        raw = self._load()
+        df = extract_features_from_recording(
+            raw, epoch_duration_s=2.0, eog_ch_name="EOG061",
+            n_components=4, random_state=97,
+        )
+        assert len(df) == 5
+
+    def test_column_naming_is_deterministic_and_explicit(self) -> None:
+        raw = self._load()
+        df = extract_features_from_recording(
+            raw, epoch_duration_s=2.0, eog_ch_name="EOG061",
+            n_components=4, random_state=97,
+        )
+        # 4 EEG channels: Cz, Pz, O1, O2 (EOG channel is excluded from features).
+        for ch in ("Cz", "Pz", "O1", "O2"):
+            for band in EEG_BANDS:
+                assert f"feat_{ch}_psd_{band}" in df.columns
+            for stat in STATS:
+                assert f"feat_{ch}_{stat}" in df.columns
+
+    def test_no_feat_for_eog_channel(self) -> None:
+        raw = self._load()
+        df = extract_features_from_recording(
+            raw, epoch_duration_s=2.0, eog_ch_name="EOG061",
+            n_components=4, random_state=97,
+        )
+        assert not any("EOG061" in c for c in df.columns)
+
+    def test_all_features_finite_float64(self) -> None:
+        raw = self._load()
+        df = extract_features_from_recording(
+            raw, epoch_duration_s=2.0, eog_ch_name="EOG061",
+            n_components=4, random_state=97,
+        )
+        feat_cols = [c for c in df.columns if c.startswith("feat_")]
+        assert all(df[c].dtype == np.float64 for c in feat_cols)
+        assert df[feat_cols].notna().all().all()
+        assert np.isfinite(df[feat_cols].to_numpy()).all()
+
+    def test_drops_invalid_epochs_with_warning(self, caplog) -> None:
+        """If an epoch contains NaN, it is logged and dropped."""
+        raw = self._load()
+        # Inject a NaN into the last 2-second window so that exactly one epoch
+        # fails `is_valid_epoch`.
+        data = raw.get_data().copy()
+        data[0, -10] = np.nan
+        bad_raw = mne.io.RawArray(data, raw.info, verbose="ERROR")
+        df = extract_features_from_recording(
+            bad_raw, epoch_duration_s=2.0, eog_ch_name="EOG061",
+            n_components=4, random_state=97,
+        )
+        # 5 epochs minus 1 dropped = 4
+        assert len(df) == 4
+```
+
+- [ ] **Step 2: Run tests; they MUST fail**
+
+```bash
+pytest tests/pipelines/test_eeg_pipeline.py::TestExtractFeaturesFromRecording -v
+```
+Expected: 6 FAILS with `cannot import name 'extract_features_from_recording'`.
+
+- [ ] **Step 3: Implement the recording-level extractor**
+
+Add `import pandas as pd` to the third-party imports block at the top of `src/pipelines/eeg_pipeline.py` (alphabetical: numpy → pandas → others).
+
+Append:
+```python
+def _build_feature_columns(eeg_ch_names: list[str]) -> list[str]:
+    """Generate the deterministic, alphabetical-by-channel column ordering."""
+    cols: list[str] = []
+    for ch in eeg_ch_names:
+        for band in EEG_BANDS:
+            cols.append(f"feat_{ch}_psd_{band}")
+        for stat in STATS:
+            cols.append(f"feat_{ch}_{stat}")
+    return cols
+
+
+def extract_features_from_recording(
+    raw: mne.io.BaseRaw,
+    epoch_duration_s: float = 2.0,
+    eog_ch_name: str | None = None,
+    n_components: int = 15,
+    random_state: int = 97,
+) -> pd.DataFrame:
+    """Run the EEG pipeline on a Raw and return a 2-D feature DataFrame.
+
+    Steps:
+      1. Bandpass filter (1-40 Hz).
+      2. ICA-based EOG artifact rejection (skipped if `eog_ch_name` is None).
+      3. Slice into fixed-duration epochs.
+      4. Drop any epoch with NaN/inf samples (logged WARNING).
+      5. Compute features per epoch and stack into a DataFrame whose columns
+         are `feat_<channel>_psd_<band>` and `feat_<channel>_<stat>`.
+
+    Args:
+        raw: Loaded `mne.io.BaseRaw` (must be `.load_data()`'d).
+        epoch_duration_s: Length of each epoch in seconds.
+        eog_ch_name: Name of EOG reference channel for ICA. None disables ICA.
+        n_components: Cap on ICA components.
+        random_state: Seed for ICA's solver (determinism).
+
+    Returns:
+        A `pd.DataFrame` with one row per valid epoch and `n_eeg_channels *
+        (len(EEG_BANDS) + len(STATS))` `feat_*` columns.
+    """
+    filtered = bandpass_filter(raw, l_freq=1.0, h_freq=40.0)
+    cleaned = remove_artifacts_with_ica(
+        filtered,
+        eog_ch_name=eog_ch_name,
+        n_components=n_components,
+        random_state=random_state,
+    )
+
+    sfreq = float(cleaned.info["sfreq"])
+    n_samples_per_epoch = int(round(epoch_duration_s * sfreq))
+    eeg_picks = mne.pick_types(cleaned.info, eeg=True, meg=False, eog=False)
+    eeg_names = [cleaned.ch_names[i] for i in eeg_picks]
+    data = cleaned.get_data(picks=eeg_picks)  # shape (n_eeg, n_times)
+    n_eeg, n_times = data.shape
+    n_total_epochs = n_times // n_samples_per_epoch
+
+    feature_cols = _build_feature_columns(eeg_names)
+    rows: list[np.ndarray] = []
+    invalid_indices: list[int] = []
+    for ep in range(n_total_epochs):
+        start = ep * n_samples_per_epoch
+        end = start + n_samples_per_epoch
+        epoch = data[:, start:end]
+        if not is_valid_epoch(epoch):
+            invalid_indices.append(ep)
+            continue
+        rows.append(compute_features_from_epoch(epoch, sfreq=sfreq))
+
+    n_dropped = len(invalid_indices)
+    if n_dropped:
+        display = invalid_indices[:10]
+        suffix = (
+            f"... (+{n_dropped - 10} more)" if n_dropped > 10 else ""
+        )
+        logger.warning(
+            "Dropping %d/%d epochs with invalid samples (indices=%s%s)",
+            n_dropped, n_total_epochs, display, suffix,
+        )
+
+    if not rows:
+        logger.info(
+            "Feature extraction complete: in=%d, out=0, dropped=%d (%.2f%%)",
+            n_total_epochs, n_dropped,
+            100.0 * n_dropped / max(n_total_epochs, 1),
+        )
+        return pd.DataFrame(columns=feature_cols).astype(np.float64)
+
+    matrix = np.vstack(rows)
+    out = pd.DataFrame(matrix, columns=feature_cols, dtype=np.float64)
+    logger.info(
+        "Feature extraction complete: in=%d, out=%d, dropped=%d (%.2f%%)",
+        n_total_epochs, len(out), n_dropped,
+        100.0 * n_dropped / max(n_total_epochs, 1),
+    )
+    return out
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+```bash
+pytest tests/pipelines/test_eeg_pipeline.py -v
+```
+Expected: 26 PASS (20 prior + 6 recording).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/pipelines/test_eeg_pipeline.py src/pipelines/eeg_pipeline.py
+git commit -m "feat(eeg): flatten 3D epochs into deterministic 2D feat_<ch>_<band|stat> table"
+```
+
+---
+
+## Task 7: `run_pipeline` orchestrator + CLI (TDD)
+
+**Files:**
+- Modify: `tests/pipelines/test_eeg_pipeline.py`
+- Modify: `src/pipelines/eeg_pipeline.py`
+
+- [ ] **Step 1: Append the failing tests**
+
+Extend the merged test import tuple to include `run_pipeline`. Add `import shutil` to the stdlib block at the top of the test file.
+
+Append:
+```python
+
+
+class TestRunPipeline:
+    def test_end_to_end_writes_processed_parquet(self, tmp_path: Path) -> None:
+        raw_dir = tmp_path / "data" / "raw"
+        proc_dir = tmp_path / "data" / "processed"
+        raw_dir.mkdir(parents=True)
+        proc_dir.mkdir(parents=True)
+        input_path = raw_dir / "rec.fif"
+        output_path = proc_dir / "eeg_features.parquet"
+        shutil.copy(FIXTURE, input_path)
+
+        run_pipeline(
+            input_path=input_path, output_path=output_path,
+            epoch_duration_s=2.0, eog_ch_name="EOG061",
+            n_components=4, random_state=97,
+        )
+
+        assert output_path.exists()
+        df = pd.read_parquet(output_path)
+        assert len(df) == 5
+        assert all(c.startswith("feat_") for c in df.columns)
+
+    def test_run_pipeline_preserves_float64_dtype(self, tmp_path: Path) -> None:
+        raw_dir = tmp_path / "data" / "raw"
+        proc_dir = tmp_path / "data" / "processed"
+        raw_dir.mkdir(parents=True)
+        proc_dir.mkdir(parents=True)
+        input_path = raw_dir / "rec.fif"
+        output_path = proc_dir / "eeg_features.parquet"
+        shutil.copy(FIXTURE, input_path)
+
+        run_pipeline(
+            input_path=input_path, output_path=output_path,
+            epoch_duration_s=2.0, eog_ch_name="EOG061",
+            n_components=4, random_state=97,
+        )
+        df = pd.read_parquet(output_path)
+        for col in df.columns:
+            assert df[col].dtype == np.float64, f"{col} widened to {df[col].dtype}"
+
+    def test_run_pipeline_is_idempotent(self, tmp_path: Path) -> None:
+        raw_dir = tmp_path / "data" / "raw"
+        proc_dir = tmp_path / "data" / "processed"
+        raw_dir.mkdir(parents=True)
+        proc_dir.mkdir(parents=True)
+        input_path = raw_dir / "rec.fif"
+        output_path = proc_dir / "eeg_features.parquet"
+        shutil.copy(FIXTURE, input_path)
+
+        run_pipeline(
+            input_path=input_path, output_path=output_path,
+            epoch_duration_s=2.0, eog_ch_name="EOG061",
+            n_components=4, random_state=97,
+        )
+        first = output_path.read_bytes()
+        run_pipeline(
+            input_path=input_path, output_path=output_path,
+            epoch_duration_s=2.0, eog_ch_name="EOG061",
+            n_components=4, random_state=97,
+        )
+        second = output_path.read_bytes()
+        assert first == second, "EEG pipeline output must be byte-deterministic"
+
+    def test_run_pipeline_raises_when_input_missing(self, tmp_path: Path) -> None:
+        with pytest.raises(FileNotFoundError):
+            run_pipeline(
+                input_path=tmp_path / "nope.fif",
+                output_path=tmp_path / "out.parquet",
+            )
+
+    def test_run_pipeline_rejects_directory_as_output(self, tmp_path: Path) -> None:
+        raw_dir = tmp_path / "data" / "raw"
+        raw_dir.mkdir(parents=True)
+        input_path = raw_dir / "rec.fif"
+        shutil.copy(FIXTURE, input_path)
+        bad_output = tmp_path / "out_dir"
+        bad_output.mkdir()
+        with pytest.raises(IsADirectoryError, match="must be a file"):
+            run_pipeline(
+                input_path=input_path, output_path=bad_output,
+                epoch_duration_s=2.0, eog_ch_name="EOG061",
+                n_components=4, random_state=97,
+            )
+```
+
+- [ ] **Step 2: Run tests; they MUST fail**
+
+Expected: 5 FAILS with `cannot import name 'run_pipeline'`.
+
+- [ ] **Step 3: Implement the orchestrator + CLI**
+
+Add `from pathlib import Path` to the stdlib imports block at the top of `src/pipelines/eeg_pipeline.py`.
+
+Append at the END of the file:
+```python
+
+
+# Default I/O paths for the EEG pipeline. Override via run_pipeline() args.
+DEFAULT_INPUT = Path("data/raw/eeg.fif")
+DEFAULT_OUTPUT = Path("data/processed/eeg_features.parquet")
+
+
+def run_pipeline(
+    input_path: Path = DEFAULT_INPUT,
+    output_path: Path = DEFAULT_OUTPUT,
+    epoch_duration_s: float = 2.0,
+    eog_ch_name: str | None = None,
+    n_components: int = 15,
+    random_state: int = 97,
+) -> None:
+    """Run the EEG pipeline end-to-end: raw FIF/EDF → processed feature Parquet.
+
+    Reads `input_path` via MNE, applies bandpass + ICA + epoching + feature
+    extraction, then writes a model-ready Parquet at `output_path` (preserves
+    float64 dtype; satisfies AGENTS.md §6).
+
+    Args:
+        input_path: Path to the raw recording (.fif or .edf).
+        output_path: Where to write the processed feature Parquet file.
+            Parent directory is created if missing.
+        epoch_duration_s: Length of each fixed-duration epoch (seconds).
+        eog_ch_name: Name of the EOG channel for ICA-based artifact rejection.
+            None disables ICA.
+        n_components: Cap on ICA components.
+        random_state: Seed for ICA's solver. Required for §4 Determinism.
+
+    Raises:
+        FileNotFoundError: if `input_path` does not exist.
+        IsADirectoryError: if `output_path` resolves to an existing directory.
+    """
+    input_path = Path(input_path)
+    output_path = Path(output_path)
+    if not input_path.exists():
+        raise FileNotFoundError(f"Raw EEG file not found: {input_path}")
+
+    logger.info("Reading raw EEG from %s", input_path)
+    if input_path.suffix.lower() == ".edf":
+        raw = mne.io.read_raw_edf(input_path, preload=True, verbose="ERROR")
+    else:
+        raw = mne.io.read_raw_fif(input_path, preload=True, verbose="ERROR")
+    logger.info(
+        "Loaded %d channels, sfreq=%.1f Hz, n_times=%d",
+        len(raw.ch_names), raw.info["sfreq"], raw.n_times,
+    )
+
+    features = extract_features_from_recording(
+        raw,
+        epoch_duration_s=epoch_duration_s,
+        eog_ch_name=eog_ch_name,
+        n_components=n_components,
+        random_state=random_state,
+    )
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    if output_path.is_dir():
+        raise IsADirectoryError(
+            f"output_path must be a file, got a directory: {output_path}"
+        )
+    # Parquet preserves dtypes (float64 features stay float64) and is
+    # byte-deterministic with single-threaded snappy. AGENTS.md §6.
+    features.to_parquet(
+        output_path, index=False, engine="pyarrow", compression="snappy",
+    )
+    logger.info(
+        "Wrote processed features to %s (rows=%d, cols=%d)",
+        output_path, len(features), features.shape[1],
+    )
+
+
+if __name__ == "__main__":
+    # Day-2 CLI entrypoint — runs with default paths against `data/raw/eeg.fif`.
+    # Argument parsing (argparse / click) will land in a later task.
+    #   python -m src.pipelines.eeg_pipeline
+    run_pipeline()
+```
+
+- [ ] **Step 4: Run tests; full suite green**
+
+```bash
+pytest -v
+```
+Expected: **61 PASS** (30 from Day 1 + 31 EEG: 6 valid_epoch + 4 bandpass + 5 ICA + 5 features + 6 recording + 5 run_pipeline).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/pipelines/test_eeg_pipeline.py src/pipelines/eeg_pipeline.py
+git commit -m "feat(eeg): add run_pipeline orchestrator + CLI (FIF/EDF → Parquet)"
+```
+
+---
+
+## Task 8: AGENTS.md + README updates
+
+**Files:**
+- Modify: `AGENTS.md`
+- Modify: `README.md`
+
+- [ ] **Step 1: Update AGENTS.md §1 pipeline table**
+
+In `/Users/mertgungor/Desktop/hackathon/AGENTS.md`, find the pipeline table:
+```
+| Image (MRI / fMRI) | `src/pipelines/mri_pipeline.py` | ComBat Harmonization for site-level domain shift |
+| Signal (EEG) | `src/pipelines/eeg_pipeline.py` | MNE-Python + ICA for artifact removal |
+| Tabular (BBB / molecules) | `src/pipelines/bbb_pipeline.py` | RDKit Morgan fingerprints from SMILES |
+```
+The lines stay; nothing to change here — the EEG row already exists.
+
+- [ ] **Step 2: Update README Status table**
+
+In `/Users/mertgungor/Desktop/hackathon/README.md`, find:
+```
+| 2 | Signal (EEG) | `src/pipelines/eeg_pipeline.py` | Planned (MNE-Python + ICA) |
+```
+Replace with:
+```
+| 2 | Signal (EEG) | `src/pipelines/eeg_pipeline.py` | Shipped — 61 tests green |
+```
+Also update the Day-1 row's count if needed (it should still read "Shipped — 30 tests green" since Day 1 tests didn't change). And update any Quick Start `pytest -v` expected count from 30 to 61.
+
+- [ ] **Step 3: Add EEG smoke-run line to README Quick Start**
+
+In the Quick Start section, after the BBB smoke-run line, append:
+```bash
+# Smoke-test the EEG pipeline with the bundled fixture
+mkdir -p data/raw
+cp tests/fixtures/eeg_sample.fif data/raw/eeg.fif
+python -m src.pipelines.eeg_pipeline
+```
+And below it: "Result lives at `data/processed/eeg_features.parquet`."
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add AGENTS.md README.md
+git commit -m "docs: mark EEG pipeline shipped; bump test count to 61"
+```
+
+---
+
+## Task 9: DoD verification + smoke run
+
+**Files:** none modified (verification only)
+
+- [ ] **Step 1: Full test suite green**
+
+```bash
+cd /Users/mertgungor/Desktop/hackathon
+source .venv312/bin/activate
+pytest -v --tb=short
+```
+Required: **61 passed**, 0 failed, 0 skipped, 0 warnings.
+
+- [ ] **Step 2: CLI smoke run (real-world flow)**
+
+```bash
+mkdir -p data/raw
+cp tests/fixtures/eeg_sample.fif data/raw/eeg.fif
+rm -f data/processed/eeg_features.parquet
+
+python -c "
+from pathlib import Path
+from src.pipelines.eeg_pipeline import run_pipeline
+run_pipeline(
+    input_path=Path('data/raw/eeg.fif'),
+    output_path=Path('data/processed/eeg_features.parquet'),
+    epoch_duration_s=2.0, eog_ch_name='EOG061',
+    n_components=4, random_state=97,
+)
+"
+md5_run1=$(md5 -q data/processed/eeg_features.parquet 2>/dev/null || md5sum data/processed/eeg_features.parquet | awk '{print $1}')
+echo "MD5 run1: $md5_run1"
+
+python -c "
+from pathlib import Path
+from src.pipelines.eeg_pipeline import run_pipeline
+run_pipeline(
+    input_path=Path('data/raw/eeg.fif'),
+    output_path=Path('data/processed/eeg_features.parquet'),
+    epoch_duration_s=2.0, eog_ch_name='EOG061',
+    n_components=4, random_state=97,
+)
+"
+md5_run2=$(md5 -q data/processed/eeg_features.parquet 2>/dev/null || md5sum data/processed/eeg_features.parquet | awk '{print $1}')
+echo "MD5 run2: $md5_run2"
+```
+Required: `md5_run1 == md5_run2` (Determinism).
+
+- [ ] **Step 3: Verify schema**
+
+```bash
+python -c "
+import pandas as pd
+df = pd.read_parquet('data/processed/eeg_features.parquet')
+print('rows:', len(df))
+print('cols:', df.shape[1])
+print('feat_*:', sum(c.startswith('feat_') for c in df.columns))
+print('any EOG col:', any('EOG' in c for c in df.columns))
+print('all float64:', all(df[c].dtype.name == 'float64' for c in df.columns))
+print('first 4 cols:', list(df.columns)[:4])
+"
+```
+Required:
+- rows = 5
+- feat_* count = 4 channels × (5 bands + 5 stats) = 40
+- "any EOG col" = False
+- "all float64" = True
+- first columns must follow `feat_<channel>_psd_<band>` / `feat_<channel>_<stat>` pattern
+
+- [ ] **Step 4: Verify data is gitignored**
+
+```bash
+git check-ignore -v data/raw/eeg.fif data/processed/eeg_features.parquet
+git status
+```
+Expected: both ignored, working tree clean.
+
+---
+
+## Day-2 Definition of Done
+
+- [ ] `src/pipelines/eeg_pipeline.py` exposes `is_valid_epoch`, `bandpass_filter`, `remove_artifacts_with_ica`, `compute_features_from_epoch`, `extract_features_from_recording`, `run_pipeline`, plus `EEG_BANDS`, `STATS`, `DEFAULT_INPUT`, `DEFAULT_OUTPUT`.
+- [ ] `python -m src.pipelines.eeg_pipeline` against `data/raw/eeg.fif` produces a deterministic Parquet at `data/processed/eeg_features.parquet`.
+- [ ] Invalid epochs (NaN/inf) are logged with their indices and dropped (Data Readiness §4 rule 2).
+- [ ] ICA is seeded; same input → byte-identical output (rule 3 + 5).
+- [ ] Row count in / out / dropped logged at INFO (rule 4).
+- [ ] Per-epoch feature schema is `feat_<channel>_psd_<band>` and `feat_<channel>_<stat>` for every EEG channel.
+- [ ] Parquet output preserves `float64` dtype across the round-trip.
+- [ ] Test suite: **61 passing**, 0 failures, 0 warnings.
+- [ ] At least 9 atomic commits across Day 2 (1 fixture + 6 TDD features + 1 doc update + 1 close-out).