@brainpilot/skills 0.0.6 → 0.0.8

package/skills/05_EEG_ERP/meg-skill/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: meg-skill
+description: "Use this skill whenever the user wants to process MEG (magnetoencephalography) data including source localization, time-frequency analysis, connectivity analysis, sensor-level preprocessing, or MEG-specific feature extraction. Triggers include: 'MEG', 'MEG processing', 'MEG source localization', 'MEG connectivity', 'magnetoencephalography', 'beamformer', 'time-frequency', 'MEG preprocessing', or any request involving MEG data files (.fif, .con, .ds)."
+license: MIT License (NeuroClaw custom skill – freely modifiable within the project)
+layer: subagent
+skill_type: modality
+dependencies:
+  - claw-shell
+complementary_skills:
+  - eeg-skill
+  - smri-skill
+  - brain-visualization
+---
+# MEG Skill (Modality Layer)
+
+## Overview
+
+`meg-skill` is the NeuroClaw **modality-layer** interface skill responsible for all MEG (magnetoencephalography) data processing tasks.
+
+It strictly follows the NeuroClaw hierarchical design principles:
+- This skill **only describes WHAT needs to be done** and **which tool skill to delegate to**.
+- It contains **no implementation code or concrete commands**.
+- All concrete execution is delegated to MNE-Python (via `claw-shell`) and companion scripts.
+- Companion scripts in `scripts/` provide reference implementations for time-frequency analysis and source localization.
+
+**Core workflow (never bypassed):**
+1. Identify input MEG data format (.fif Elekta/Neuromag, .ds CTF, .con KIT/Yokogawa).
+2. Ensure T1w structural MRI is available for source localization (via `smri-skill` if not yet processed).
+3. Generate a **numbered execution plan** clearly stating WHAT needs to be done.
+4. Present the full plan, estimated runtime, resource requirements, and risks to the user and wait for explicit confirmation ("YES" / "execute" / "proceed").
+5. On confirmation, delegate every step via `claw-shell`.
+6. After execution, save all outputs in a clean directory structure (`meg_output/`).
+
+**Research use only.**
+
+---
+
+## Quick Reference (Common MEG Tasks)
+
+| Task | What needs to be done | Implementation via | Expected output |
+|---|---|---|---|
+| Load & validation | Read raw MEG, check channel types, info metadata | MNE-Python (`mne.io`) | Raw object + validation report |
+| Maxwell filtering | Signal-space separation (SSS) for Elekta systems | MNE-Python (`mne.preprocessing.maxwell_filter`) | Cleaned raw MEG |
+| Filtering | Band-pass, notch (line noise removal at 50/60 Hz) | MNE-Python (`raw.filter`, `raw.notch_filter`) | Filtered raw data |
+| Epoching | Segment continuous data around events | MNE-Python (`mne.Epochs`) | Epoched data |
+| ICA artifact removal | Remove cardiac, ocular, environmental artifacts | MNE-Python (`mne.preprocessing.ICA`) | Cleaned epochs |
+| Time-frequency analysis | Morlet wavelet multitaper, Hilbert transform | `scripts/time_frequency.py` | TFR maps (power, ITC) |
+| Source localization | Forward/inverse modeling (MNE, dSPM, beamformer) | MNE-Python + FreeSurfer | Source estimates in brain space |
+| Source-space connectivity | Coherence, PLV, dPLI between source parcels | MNE-Python (`mne_connectivity`) | Connectivity matrices |
+| Sensor-level connectivity | Coherence, PLV between sensor pairs | MNE-Python | Sensor connectivity |
+| Evoked responses | Average epochs, compute ERPs/ERFs | MNE-Python (`epochs.average`) | Evoked NIfTI/fif files |
+
+---
+
+## Supported MEG File Formats
+
+| Format | System | Extension | Reader |
+|---|---|---|---|
+| Elekta/Neuromag | VectorView, TRIUX | `.fif` | `mne.io.read_raw_fif` |
+| CTF | CTF MEG systems | `.ds` | `mne.io.read_raw_ctf` |
+| KIT/Yokogawa | KIT, Ricoh | `.con`, `.mrk` | `mne.io.read_raw_kit` |
+| BIDS MEG | Any (BIDS format) | `.meg.fif` | `mne.io.read_raw_fif` |
+
+---
+
+## Core Processing Pipeline
+
+### Stage 1: Data Loading & Validation
+- Load raw MEG data and validate channel types (magnetometers, gradiometers, EEG, EOG, ECG, STIM)
+- Check sampling rate, duration, and channel count
+- Report bad channels if annotated
+
+### Stage 2: Preprocessing
+- **Maxwell filtering** (SSS/tSSS): for Elekta systems, remove environmental noise
+- **Band-pass filtering**: typically 1–100 Hz for sensor-level analysis
+- **Notch filter**: remove power line noise (50 Hz or 60 Hz)
+- **Downsampling**: optional, to reduce computation (e.g., 1000 Hz → 250 Hz)
+
+### Stage 3: Artifact Removal (ICA)
+- Run ICA (FastICA, Infomax, or Picard)
+- Auto-detect and remove cardiac (ECG), ocular (EOG), and muscle artifacts
+- Correlate ICA components with ECG/EOG channels
+
+### Stage 4: Epoching & Averaging
+- Segment around events of interest
+- Baseline correction
+- Reject bad epochs (amplitude threshold, autoreject)
+- Compute evoked responses (ERFs)
+
+### Stage 5: Time-Frequency Analysis (via `scripts/time_frequency.py`)
+- Morlet wavelet or multitaper spectral analysis
+- Compute power spectral density per frequency band (δ/θ/α/β/γ)
+- Inter-trial coherence (ITC)
+
+### Stage 6 (Optional): Source Localization
+- Requires T1w MRI from `smri-skill` and FreeSurfer cortical reconstruction
+- Compute forward model (BEM or sphere)
+- Apply inverse solution (MNE, dSPM, sLORETA, or LCMV beamformer)
+- Output source estimates on cortical surface
+
+---
+
+## Scripts
+
+### `scripts/time_frequency.py`
+Computes time-frequency representations from MEG epochs.
+
+```bash
+python skills/meg-skill/scripts/time_frequency.py \
+  --epochs /path/to/epochs.fif \
+  --output /path/to/meg_output/tfr/ \
+  --freq-min 1 --freq-max 100 --freq-steps 40 \
+  --method morlet \
+  --baseline -0.2 0.0
+```
+
+---
+
+## Standard Output Layout
+
+```
+meg_output/
+├── preprocessed/          # Filtered, cleaned raw MEG
+├── epochs/                # Epoched data (.fif)
+├── evoked/                # Averaged evoked responses (.fif, .nii.gz)
+├── tfr/                   # Time-frequency results
+│   ├── power_*.nii.gz
+│   └── itc_*.nii.gz
+├── source/                # Source estimates (if source localization run)
+│   ├── stc_*.lh.stc
+│   └── stc_*.rh.stc
+├── connectivity/          # Connectivity matrices (if requested)
+├── qc/                    # Quality control reports
+└── logs/
+```
+
+---
+
+## Installation (Handled by dependency-planner)
+
+No manual installation required at this layer.
+When first used, `meg-skill` automatically calls `dependency-planner` to install MNE-Python and dependencies via conda.
+
+---
+
+## Important Notes & Limitations
+
+- MEG data is large (hundreds of MB to GB per recording); ensure sufficient disk space.
+- Maxwell filtering (SSS) is specific to Elekta/Neuromag systems; CTF and KIT systems use different approaches.
+- Source localization requires co-registered T1w MRI and MEG sensor positions (head position indicator coils or digitized head shape).
+- MNE-Python is the primary backend; all MEG processing is built on MNE.
+- MEG has millisecond temporal resolution but lower spatial resolution than fMRI.
+- BIDS-MEG format follows the BIDS extension for MEG: https://bids-specification.readthedocs.io/en/stable/04-modality-specific-files/02-magnetoencephalography.html
+- This skill is for research workflows; not for clinical decision-making.
+
+---
+
+## When to Call This Skill
+
+- When the user provides MEG data (.fif, .ds, .con) and requests preprocessing, artifact removal, or analysis.
+- When time-frequency analysis or source localization is needed for MEG data.
+- When MEG connectivity analysis (sensor-level or source-level) is requested.
+- When `eeg-skill` handles EEG but the data also includes MEG channels.
+- When dataset skills (e.g., `Cam-CAN`) delegate MEG processing.
+
+---
+
+## Complementary / Related Skills
+
+- `eeg-skill` → EEG processing (MEG and EEG share many MNE-Python tools)
+- `smri-skill` → T1w structural preprocessing (required for source localization)
+- `freesurfer-tool` → cortical reconstruction for source-space analysis
+- `nibabel-skill` → NIfTI I/O for surface/volume data
+- `brain-visualization` → MEG source overlay visualization
+- `nilearn-tool` → post-hoc statistical analysis on source estimates
+
+---
+
+## Reference
+- MNE-Python: https://mne.tools/
+- Gramfort et al. (2013): MEG and EEG data analysis with MNE-Python
+- Taulu & Simola (2006): Spatiotemporal signal space separation (SSS)
+- BIDS MEG: https://bids-specification.readthedocs.io/en/stable/04-modality-specific-files/02-magnetoencephalography.html
+- Cam-CAN dataset: https://www.cam-can.org/
+
+Created At: 2026-05-06 12:19 HKT
+Last Updated At: 2026-05-06 12:19 HKT
+Author: chengwang96

package/skills/05_EEG_ERP/meg-skill/scripts/time_frequency.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""Compute time-frequency representations from MEG/EEG epochs.
+
+Uses MNE-Python for Morlet wavelet or multitaper spectral analysis.
+Outputs power and inter-trial coherence (ITC) maps.
+"""
+import argparse
+import sys
+from pathlib import Path
+
+try:
+    import numpy as np
+except ImportError:
+    print("Error: numpy is required.", file=sys.stderr)
+    sys.exit(1)
+
+try:
+    import mne
+except ImportError:
+    print("Error: mne is required. Install with: pip install mne", file=sys.stderr)
+    sys.exit(1)
+
+
+def compute_tfr_morlet(
+    epochs: mne.Epochs,
+    freqs: np.ndarray,
+    n_cycles: float,
+    baseline: tuple = None,
+    return_itc: bool = True,
+) -> tuple:
+    """Compute time-frequency representation using Morlet wavelets.
+
+    Args:
+        epochs: MNE Epochs object.
+        freqs: Array of frequencies of interest.
+        n_cycles: Number of cycles in the Morlet wavelet.
+        baseline: Tuple (tmin, tmax) for baseline correction.
+        return_itc: Whether to compute inter-trial coherence.
+
+    Returns:
+        power: Average TFR power (EvokedArray).
+        itc: Inter-trial coherence (EvokedArray) or None.
+    """
+    # Compute TFR for each epoch
+    tfr = epochs.compute_tfr(
+        method="morlet",
+        freqs=freqs,
+        n_cycles=n_cycles,
+        return_itc=False,
+        average=False,
+    )
+
+    # Average power across epochs
+    power = tfr.copy().average()
+
+    # Apply baseline correction
+    if baseline is not None:
+        power.apply_baseline(baseline=baseline)
+
+    itc = None
+    if return_itc:
+        # ITC = |mean(exp(j * phase))| across epochs
+        data = tfr.data  # (n_epochs, n_channels, n_freqs, n_times)
+        itc_data = np.abs(np.mean(np.exp(1j * np.angle(data)), axis=0))
+        itc = power.copy()
+        itc.data = itc_data
+
+    return power, itc
+
+
+def compute_tfr_multitaper(
+    epochs: mne.Epochs,
+    freqs: np.ndarray,
+    bandwidth: float,
+    baseline: tuple = None,
+) -> "mne.time_frequency.AverageTFR":
+    """Compute time-frequency representation using multitaper method.
+
+    Args:
+        epochs: MNE Epochs object.
+        freqs: Array of frequencies of interest.
+        bandwidth: Frequency bandwidth of the multitaper windows.
+        baseline: Tuple (tmin, tmax) for baseline correction.
+
+    Returns:
+        power: Average TFR power.
+    """
+    tfr = epochs.compute_tfr(
+        method="multitaper",
+        freqs=freqs,
+        bandwidth=bandwidth,
+        return_itc=False,
+        average=False,
+    )
+
+    power = tfr.copy().average()
+
+    if baseline is not None:
+        power.apply_baseline(baseline=baseline)
+
+    return power
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Compute time-frequency representations from MEG/EEG epochs."
+    )
+    parser.add_argument("--epochs", required=True, help="Path to epochs .fif file")
+    parser.add_argument("--output", required=True, help="Output directory for TFR results")
+    parser.add_argument("--method", default="morlet", choices=["morlet", "multitaper"],
+                        help="TFR method (default: morlet)")
+    parser.add_argument("--freq-min", type=float, default=1.0, help="Minimum frequency in Hz (default: 1)")
+    parser.add_argument("--freq-max", type=float, default=100.0, help="Maximum frequency in Hz (default: 100)")
+    parser.add_argument("--freq-steps", type=int, default=40, help="Number of frequency steps (default: 40)")
+    parser.add_argument("--n-cycles", type=float, default=7.0, help="Number of Morlet wavelet cycles (default: 7)")
+    parser.add_argument("--bandwidth", type=float, default=4.0, help="Multitaper bandwidth in Hz (default: 4)")
+    parser.add_argument("--baseline", nargs=2, type=float, metavar=("TMIN", "TMAX"),
+                        help="Baseline correction window in seconds (e.g., -0.2 0.0)")
+    parser.add_argument("--channels", help="Comma-separated channel names to include (default: all MEG channels)")
+    parser.add_argument("--picks", default="meg", help="Channel types to include: meg, eeg, mag, grad (default: meg)")
+    parser.add_argument("--no-itc", action="store_true", help="Skip ITC computation")
+    parser.add_argument("--format", default="nifti", choices=["nifti", "numpy", "fif"],
+                        help="Output format (default: nifti)")
+    args = parser.parse_args()
+
+    epochs_path = Path(args.epochs).resolve()
+    if not epochs_path.exists():
+        print(f"Epochs file not found: {epochs_path}", file=sys.stderr)
+        return 1
+
+    # Load epochs
+    print(f"Loading epochs: {epochs_path}")
+    epochs = mne.read_epochs(str(epochs_path), preload=True)
+    print(f"  {len(epochs)} epochs, {len(epochs.ch_names)} channels, {epochs.info['sfreq']} Hz")
+
+    # Select channels
+    if args.channels:
+        ch_names = [c.strip() for c in args.channels.split(",")]
+        epochs.pick(ch_names)
+        print(f"  Selected channels: {ch_names}")
+    else:
+        epochs.pick(args.picks)
+
+    # Build frequency array
+    freqs = np.linspace(args.freq_min, args.freq_max, args.freq_steps)
+    print(f"  Frequencies: {freqs[0]:.1f} - {freqs[-1]:.1f} Hz ({len(freqs)} steps)")
+
+    # Parse baseline
+    baseline = None
+    if args.baseline:
+        baseline = (args.baseline[0], args.baseline[1])
+        print(f"  Baseline: [{baseline[0]}, {baseline[1]}] s")
+
+    # Compute TFR
+    output_dir = Path(args.output).resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"\nComputing TFR ({args.method})...")
+    if args.method == "morlet":
+        power, itc = compute_tfr_morlet(
+            epochs, freqs, n_cycles=args.n_cycles, baseline=baseline, return_itc=not args.no_itc,
+        )
+    else:
+        power = compute_tfr_multitaper(
+            epochs, freqs, bandwidth=args.bandwidth, baseline=baseline,
+        )
+        itc = None
+
+    # Save results
+    power_path = output_dir / "tfr_power"
+    if args.format == "fif":
+        power.save(str(power_path.with_suffix(".fif")), overwrite=True)
+        print(f"  Power saved: {power_path.with_suffix('.fif')}")
+    elif args.format == "numpy":
+        np.save(str(power_path.with_suffix(".npy")), power.data)
+        print(f"  Power saved: {power_path.with_suffix('.npy')} (shape: {power.data.shape})")
+    else:
+        # Save as NIfTI (convert 4D data: channels x freqs x times)
+        try:
+            import nibabel as nib
+            data = power.data  # (n_channels, n_freqs, n_times)
+            # Create a 4D NIfTI with singleton spatial dimensions
+            nii_data = data.reshape(1, 1, data.shape[0], data.shape[1] * data.shape[2]) if data.ndim == 3 else data
+            affine = np.eye(4)
+            img = nib.Nifti1Image(nii_data, affine)
+            nii_path = power_path.with_suffix(".nii.gz")
+            nib.save(img, str(nii_path))
+            print(f"  Power saved: {nii_path} (shape: {data.shape})")
+        except ImportError:
+            # Fallback to numpy
+            np.save(str(power_path.with_suffix(".npy")), power.data)
+            print(f"  Power saved (numpy fallback): {power_path.with_suffix('.npy')}")
+
+    if itc is not None:
+        itc_path = output_dir / "tfr_itc"
+        if args.format == "fif":
+            itc.save(str(itc_path.with_suffix(".fif")), overwrite=True)
+        elif args.format == "numpy":
+            np.save(str(itc_path.with_suffix(".npy")), itc.data)
+        else:
+            try:
+                import nibabel as nib
+                data = itc.data
+                nii_data = data.reshape(1, 1, data.shape[0], data.shape[1] * data.shape[2]) if data.ndim == 3 else data
+                img = nib.Nifti1Image(nii_data, np.eye(4))
+                nib.save(img, str(itc_path.with_suffix(".nii.gz")))
+            except ImportError:
+                np.save(str(itc_path.with_suffix(".npy")), itc.data)
+        print(f"  ITC saved: {itc_path}")
+
+    # Print summary
+    print(f"\nTFR Summary:")
+    print(f"  Method: {args.method}")
+    print(f"  Frequency range: {freqs[0]:.1f} - {freqs[-1]:.1f} Hz")
+    print(f"  Time range: {power.times[0]:.3f} - {power.times[-1]:.3f} s")
+    print(f"  Channels: {power.data.shape[0]}")
+    print(f"  Power range: [{power.data.min():.2e}, {power.data.max():.2e}]")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/05_EEG_ERP/mne-eeg-tool/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: mne-eeg-tool
+description: "Use this skill whenever any NeuroClaw modality skill (especially eeg-skill) needs to execute concrete MNE-Python operations for EEG loading, preprocessing, filtering, artifact removal, epoching, frequency-band analysis, or feature extraction. This is the dedicated base/tool skill that contains all specific MNE-Python code and usage patterns."
+license: MIT License (NeuroClaw custom skill – freely modifiable within the project)
+layer: base
+skill_type: tool
+dependencies:
+  - claw-shell
+---
+# MNE-EEG Tool (Base/Tool Layer)
+
+## Overview
+`mne-eeg-tool` is the **NeuroClaw base/tool skill** that provides all concrete MNE-Python implementation for EEG processing.
+
+It is **never called directly by the user**. It is exclusively delegated to by the modality-layer skill `eeg-skill` (and any future EEG-related modality skills).
+
+This skill:
+- Contains the complete, ready-to-run MNE-Python code (covers all standard preprocessing and feature extraction tasks).
+- Handles environment setup verification.
+- Provides a single, well-documented wrapper script (`eeg_pipeline.py`) that implements **all** common EEG tasks, including the newly added continuous-data branch, functional connectivity, ERP features, frontal alpha asymmetry, and microstate analysis.
+- Routes every execution through `claw-shell` for safety and logging.
+
+**Research use only** — outputs are for scientific analysis.
+
+## Agent Reference Rule
+
+When the agent needs MNE-EEG implementation code, it should first consult the curated snippet in `skills/mne-eeg-tool/scripts/` instead of copying from the embedded wrapper below.
+
+Reference snippet available:
+- `scripts/eeg_pipeline_reference.py` -> full EEG pipeline: load, bad-channel detection, filtering, ICA, epoching, frequency bands, connectivity, ERP features, alpha asymmetry, microstates
+
+Example:
+```bash
+python skills/mne-eeg-tool/scripts/eeg_pipeline_reference.py \
+    --input path/to/data.set \
+    --resting \
+    --output-dir eeg_output/
+```
+
+## Quick Reference (Core Functions)
+
+| Function                              | Purpose                                                                 | New in this update? |
+|---------------------------------------|-------------------------------------------------------------------------|---------------------|
+| `load_eeg()`                          | Load .set / .edf / .bdf / .fif / BIDS + validation                     | —                   |
+| `detect_and_interpolate_bad_channels()` | Auto-detect + interpolate noisy channels                             | **Yes**             |
+| `preprocess_filtering()`              | Resample + high-pass + notch + bandpass                                 | —                   |
+| `remove_artifacts()`                  | ICA + AutoReject + EOG/ECG regression                                   | **Yes**             |
+| `continuous_data_cleaning()`          | Resting-state pipeline (no events)                                      | **Yes**             |
+| `rereference_and_epoch()`             | Average reference + epoching + baseline correction                      | —                   |
+| `extract_frequency_bands()`           | Split into δ/θ/α/β/γ bands + power matrices                             | —                   |
+| `extract_features()`                  | Band power, CSP, Hjorth, sample entropy, etc.                           | —                   |
+| `compute_connectivity()`              | PLV, coherence, wPLI, imaginary coherence                               | **Yes**             |
+| `extract_erp_features()`              | Peak amplitude, latency, area under curve                               | **Yes**             |
+| `compute_alpha_asymmetry()`           | Frontal alpha asymmetry (emotion studies)                               | **Yes**             |
+| `run_microstate_analysis()`           | EEG microstates (resting-state)                                         | **Yes**             |
+| `full_eeg_pipeline()`                 | One-click end-to-end pipeline (any combination)                         | —                   |
+
+## Installation (Handled by dependency-planner)
+This skill is automatically installed when `eeg-skill` is used:
+
+```bash
+# Executed via dependency-planner + conda-env-manager
+conda create -n neuroclaw-eeg python=3.11 -y
+conda activate neuroclaw-eeg
+conda install -c conda-forge mne pyentrp scikit-learn pandas numpy matplotlib -y
+pip install mne[full]  # optional: full extras
+```
+
+## NeuroClaw recommended wrapper script
+
+The full EEG pipeline implementation is in `scripts/eeg_pipeline_reference.py` (see Agent Reference Rule above).
+
+Example:
+```bash
+python skills/mne-eeg-tool/scripts/eeg_pipeline_reference.py \
+    --input path/to/data.set \
+    --resting \
+    --output-dir eeg_output/
+```
+
+Functions: `load_eeg`, `detect_and_interpolate_bad_channels`, `preprocess_filtering`, `remove_artifacts`, `continuous_data_cleaning`, `rereference_and_epoch`, `extract_frequency_bands`, `extract_features`, `compute_connectivity`, `extract_erp_features`, `compute_alpha_asymmetry`, `run_microstate_analysis`, `full_eeg_pipeline`.
+
+## Important Notes & Limitations
+- Requires the `neuroclaw-eeg` conda environment (auto-created by `dependency-planner`).
+- Long-running steps (ICA, connectivity, microstates) run safely in `claw` tmux session.
+- Outputs are always written to `./eeg_output/` with clear subfolders.
+- Fully extensible: new functions can be added to `eeg_pipeline.py` without touching `eeg-skill`.
+
+## Complementary / Related Skills
+- `claw-shell` → executes this skill’s wrapper
+- `dependency-planner` + `conda-env-manager` → creates `neuroclaw-eeg` environment
+
+## Reference
+Official MNE-Python documentation (https://mne.tools) + MNE-Connectivity + mne-microstates.
+Aligned with NeuroClaw base/tool skill pattern (freesurfer-tool, dcm2nii, etc.).
+
+Curated reference snippet in this skill:
+- `skills/mne-eeg-tool/scripts/eeg_pipeline_reference.py`
+
+## Post-Execution Verification (Harness Integration)
+
+After MNE-EEG processing completes, this skill **automatically invokes harness-core's VerificationRunner** to validate output integrity:
+
+**Integrated verification checks**:
+
+```python
+from skills.harness_core import VerificationRunner, AuditLogger
+
+verifier = VerificationRunner(task_type="eeg_processing")
+
+# 1. EEG file loading success
+verifier.add_check("eeg_loading",
+    checker=lambda: verify_eeg_loaded(output_dir),
+    severity="error"
+)
+
+# 2. Channel count and data shape
+verifier.add_check("channel_integrity",
+    checker=lambda: verify_channel_count(output_dir),
+    severity="error"
+)
+
+# 3. Artifact removal success (ICA, AutoReject)
+verifier.add_check("artifact_removal",
+    checker=lambda: verify_artifact_removal_rate(output_dir, min_rate=0.85),
+    severity="warning"
+)
+
+# 4. Frequency spectrum sanity (not all zeros, reasonable power)
+verifier.add_check("frequency_spectrum",
+    checker=lambda: verify_frequency_spectrum(output_dir),
+    severity="warning"
+)
+
+# 5. Data range and NaN/Inf checks
+verifier.add_check("data_integrity",
+    checker=lambda: verify_no_nan_inf(output_dir),
+    severity="error"
+)
+
+# 6. Connectivity/Features output shape
+verifier.add_check("feature_extraction",
+    checker=lambda: verify_feature_dimensions(output_dir),
+    severity="warning"
+)
+
+report = verifier.run(output_dir)
+
+# Log verification results
+logger = AuditLogger(log_file=f"{output_dir}/eeg_verification.jsonl")
+logger.log_validation(
+    task_name="eeg_processing",
+    checks_passed=len([r for r in report.results if r.passed]),
+    total_checks=len(report.results),
+    output_path=output_dir
+)
+```
+
+**Output**: `eeg_output/eeg_verification.jsonl` (structured audit log with JSONL format)
+
+---
+
+Created At: 2026-03-25 14:00 HKT  
+Last Updated At: 2026-04-05 02:03 HKT  
+Author: chengwang96