@brainpilot/skills 0.0.6 → 0.0.8

package/skills/06_fMRI_Neuroimaging/ixi-skill/scripts/reorganize_ixi.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Reorganize IXI native layout to BIDS structure.
+
+Converts IXI directory layout (e.g., IXI002/, IXI002-T1.nii.gz, IXI002-T2.nii.gz)
+to BIDS-compliant structure (sub-IXI002/anat/).
+"""
+import argparse
+import json
+import shutil
+import sys
+from pathlib import Path
+
+# Site mapping based on subject ID prefix
+SITE_MAP = {
+    "HH": {"name": "Hammersmith Hospital", "scanner": "Philips", "field_strength": "3T"},
+    "Guy": {"name": "Guy's Hospital", "scanner": "Philips", "field_strength": "1.5T"},
+    "IOP": {"name": "Institute of Psychiatry", "scanner": "GE", "field_strength": "1.5T"},
+}
+
+
+def detect_site(subject_id: str) -> str:
+    """Detect site from subject ID."""
+    for prefix in SITE_MAP:
+        if subject_id.startswith(prefix):
+            return prefix
+    return "Unknown"
+
+
+def normalize_subject_id(ixi_id: str) -> str:
+    """Convert IXI subject ID to BIDS format."""
+    return f"sub-{ixi_id.strip()}"
+
+
+def find_subjects(input_dir: Path) -> list:
+    """Find IXI subject files."""
+    # IXI files are typically named IXI002-T1.nii.gz, IXI002-T2.nii.gz, etc.
+    subjects = set()
+    for f in input_dir.glob("IXI*-*.nii.gz"):
+        # Extract subject ID (e.g., IXI002 from IXI002-T1.nii.gz)
+        parts = f.stem.split("-")
+        if len(parts) >= 2:
+            subjects.add(parts[0])
+    return sorted(list(subjects))
+
+
+def reorganize_subject(input_dir: Path, subject_id: str, output_dir: Path, dry_run: bool = False) -> dict:
+    """Reorganize a single IXI subject to BIDS."""
+    bids_id = normalize_subject_id(subject_id)
+    sub_dir = output_dir / bids_id
+    report = {"subject": subject_id, "files_created": 0, "warnings": []}
+
+    if not dry_run:
+        (sub_dir / "anat").mkdir(parents=True, exist_ok=True)
+
+    # Map IXI modality suffixes to BIDS
+    modality_map = {
+        "T1": "T1w",
+        "T2": "T2w",
+        "MRA": "MRA",
+        "PD": "PD",
+        "DTI": "dwi",
+    }
+
+    for ixi_suffix, bids_suffix in modality_map.items():
+        src_candidates = list(input_dir.glob(f"{subject_id}-{ixi_suffix}.nii.gz"))
+        if not src_candidates:
+            src_candidates = list(input_dir.glob(f"{subject_id}-{ixi_suffix.lower()}.nii.gz"))
+
+        for src in src_candidates:
+            if bids_suffix == "dwi":
+                dst = sub_dir / "dwi" / f"{bids_id}_{bids_suffix}.nii.gz"
+                if not dry_run:
+                    (sub_dir / "dwi").mkdir(parents=True, exist_ok=True)
+                    shutil.copy2(src, dst)
+            else:
+                dst = sub_dir / "anat" / f"{bids_id}_{bids_suffix}.nii.gz"
+                if not dry_run:
+                    shutil.copy2(src, dst)
+            report["files_created"] += 1
+
+    # Check for missing modalities
+    if report["files_created"] == 0:
+        report["warnings"].append("No modality files found")
+
+    return report
+
+
+def create_dataset_description(output_dir: Path, n_subjects: int, sites: dict):
+    """Create BIDS dataset_description.json."""
+    desc = {
+        "Name": "IXI (Information eXtraction from Images)",
+        "BIDSVersion": "1.8.0",
+        "DatasetType": "raw",
+        "License": "CC0",
+        "Authors": ["IXI Consortium"],
+        "HowToAcknowledge": "Please cite the IXI dataset.",
+        "ReferencesAndLinks": ["https://brain-development.org/ixi-dataset/"],
+        "Subjects": n_subjects,
+        "Sites": sites,
+    }
+    with open(output_dir / "dataset_description.json", "w", encoding="utf-8") as f:
+        json.dump(desc, f, indent=2)
+
+
+def create_participants_tsv(output_dir: Path, subjects: list, input_dir: Path):
+    """Create participants.tsv with site information."""
+    with open(output_dir / "participants.tsv", "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=["participant_id", "site", "scanner", "field_strength"])
+        writer.writeheader()
+        for subj in subjects:
+            site = detect_site(subj)
+            site_info = SITE_MAP.get(site, {"name": "Unknown", "scanner": "Unknown", "field_strength": "Unknown"})
+            writer.writerow({
+                "participant_id": normalize_subject_id(subj),
+                "site": site_info["name"],
+                "scanner": site_info["scanner"],
+                "field_strength": site_info["field_strength"],
+            })
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Reorganize IXI native layout to BIDS."
+    )
+    parser.add_argument("--input", required=True, help="Path to IXI raw directory")
+    parser.add_argument("--output", required=True, help="Output BIDS directory")
+    parser.add_argument("--dry-run", action="store_true", help="Preview without copying")
+    args = parser.parse_args()
+
+    input_dir = Path(args.input).resolve()
+    output_dir = Path(args.output).resolve()
+
+    if not input_dir.exists():
+        print(f"Input directory not found: {input_dir}", file=sys.stderr)
+        return 1
+
+    # Find subjects
+    subjects = find_subjects(input_dir)
+    print(f"Found {len(subjects)} subjects in {input_dir}")
+
+    if not subjects:
+        print("No subjects found. Check input directory structure.", file=sys.stderr)
+        return 1
+
+    if not args.dry_run:
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Process each subject
+    total_files = 0
+    all_warnings = []
+    site_counts = {}
+
+    for i, subj in enumerate(subjects):
+        report = reorganize_subject(input_dir, subj, output_dir, dry_run=args.dry_run)
+        total_files += report["files_created"]
+        if report["warnings"]:
+            all_warnings.extend([f"{report['subject']}: {w}" for w in report["warnings"]])
+
+        # Track site counts
+        site = detect_site(subj)
+        site_counts[site] = site_counts.get(site, 0) + 1
+
+        if (i + 1) % 100 == 0 or (i + 1) == len(subjects):
+            print(f"  Processed {i + 1}/{len(subjects)} subjects ({total_files} files)")
+
+    # Create metadata
+    if not args.dry_run:
+        create_dataset_description(output_dir, len(subjects), site_counts)
+        import csv
+        create_participants_tsv(output_dir, subjects, input_dir)
+
+    # Summary
+    print(f"\nBIDS Staging Summary:")
+    print(f"  Subjects: {len(subjects)}")
+    print(f"  Files created: {total_files}")
+    print(f"  Sites: {site_counts}")
+    print(f"  Output: {output_dir}")
+    if args.dry_run:
+        print("  [DRY RUN - no files were copied]")
+
+    if all_warnings:
+        print(f"\n  Warnings ({len(all_warnings)}):")
+        for w in all_warnings[:20]:
+            print(f"    - {w}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/06_fMRI_Neuroimaging/mnd-skill/SKILL.md

@@ -0,0 +1,191 @@
+---
+name: mnd-skill
+description: "Use this skill whenever the user wants an end-to-end workflow for the Motor Neuron Disease (MND) dataset from OpenNeuro ds005874, including BIDS validation, multimodal processing of rs-fMRI and task-fMRI, phenotype extraction, and QC integration. Triggers include: 'MND', 'Motor Neuron Disease', 'ALS', 'Amyotrophic Lateral Sclerosis', 'process MND data', 'MND fMRI', or any request to run the MND multimodal pipeline."
+license: MIT License (NeuroClaw custom skill - freely modifiable within the project)
+layer: subagent
+skill_type: dataset
+dependencies:
+  - smri-skill
+  - fmri-skill
+  - bids-organizer
+  - claw-shell
+complementary_skills:
+  - brain-visualization
+---
+# MND Skill (Dataset-Orchestration Layer)
+
+## Overview
+
+`mnd-skill` is the NeuroClaw orchestration skill for the **Motor Neuron Disease (MND)** dataset from OpenNeuro ds005874.
+
+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 existing base/tool skills via `claw-shell`.
+- Companion scripts in `scripts/` provide reference implementations for BIDS validation, phenotype extraction, and QC.
+
+**Core workflow (never bypassed):**
+1. Identify input MND data and target modalities.
+2. Generate a **numbered execution plan** clearly stating WHAT needs to be done and which tool skill will handle each step.
+3. Present the full plan, estimated runtime, resource requirements, and risks to the user and wait for explicit confirmation ("YES" / "execute" / "proceed").
+4. On confirmation, delegate every step to the appropriate skill via `claw-shell`.
+5. After execution, save all outputs in a clean directory structure (`mnd_output/`).
+
+**Research use only.**
+
+---
+
+## Quick Reference
+
+| Task | What needs to be done | Delegate to | Expected output |
+|---|---|---|---|
+| BIDS validation | Validate MND BIDS structure | `scripts/validate_mnd.py` | Validation report |
+| sMRI processing | Brain extraction, tissue segmentation | `smri-skill` | `smri_output/` derivatives |
+| rs-fMRI processing | Preprocessing, denoising, connectivity | `fmri-skill` | `fmri_output/` derivatives |
+| task-fMRI processing | Motor task GLM, activation analysis | `fmri-skill` | `fmri_output/` task results |
+| Phenotype extraction | Diagnosis, clinical measures | `scripts/extract_mnd_phenotype.py` | Merged phenotype CSV |
+| QC summary | Per-subject quality control | `scripts/mnd_qc_summary.py` | QC summary + exclusion list |
+
+---
+
+## Dataset Characteristics
+
+- **Cohort**: 59 participants
+  - **Patient group**: Motor Neuron Disease (e.g., ALS) patients
+  - **Control group**: Healthy age-matched controls
+- **Modalities**: rs-fMRI, task-fMRI (motor tasks)
+- **Format**: BIDS-compliant
+- **Access**: OpenNeuro ds005874
+- **License**: CC0
+
+---
+
+## Supported Modalities
+
+| Modality | Description | Tasks/Conditions |
+|---|---|---|
+| rs-fMRI | Resting-state functional MRI | Eyes open/closed |
+| task-fMRI | Task-based functional MRI | Motor tasks (finger tapping, hand grip) |
+
+---
+
+## MND Task Paradigms
+
+| Task | Description | Duration |
+|---|---|---|
+| REST | Resting-state (eyes open/closed) | ~8 min |
+| MOTOR | Motor tasks (finger tapping, hand grip) | ~5 min |
+
+---
+
+## BIDS Preparation
+
+### Script: `scripts/validate_mnd.py`
+
+Validates MND BIDS structure and generates a compliance report.
+
+```bash
+python skills/mnd-skill/scripts/validate_mnd.py \
+  --input /path/to/MND/bids \
+  --output /path/to/mnd_output/qc/bids_validation.csv
+```
+
+Features:
+- BIDS directory structure validation
+- Modality completeness check (rs-fMRI, task-fMRI)
+- Participant group labeling (patient vs. control)
+- Missing data identification
+
+---
+
+## Core Workflow (Never Bypassed)
+
+1. Identify user target: full MND processing, imaging subset, phenotype extraction, or BIDS validation only.
+2. Generate a numbered plan with tools, outputs, runtime, storage, and risks.
+3. Wait for explicit confirmation (`YES` / `execute` / `proceed`).
+4. On confirmation, run BIDS validation using `scripts/validate_mnd.py`.
+5. Delegate to `smri-skill` for structural MRI processing (if available).
+6. Delegate to `fmri-skill` for functional MRI processing (resting-state and motor task).
+7. If phenotype extraction is requested, run `scripts/extract_mnd_phenotype.py`.
+8. If QC summary is requested, run `scripts/mnd_qc_summary.py`.
+9. Save outputs into `mnd_output/`.
+
+---
+
+## Modality Processing Delegation
+
+| Modality | Delegated skill | Typical tasks | Main outputs |
+|---|---|---|---|
+| sMRI (T1w) | `smri-skill` | brain extraction, tissue segmentation | `smri_output/` derivatives |
+| rs-fMRI | `fmri-skill` | preprocessing, denoising, connectivity | `fmri_output/` connectivity |
+| task-fMRI | `fmri-skill` | motor task GLM, activation analysis | `fmri_output/` task results |
+
+---
+
+## Standard Output Layout
+
+```
+mnd_output/
+├── bids/                   # BIDS-staged data (or validation report)
+├── smri/                   # Structural MRI derivatives
+├── fmri/                   # Functional MRI derivatives (rest + motor)
+├── phenotype/              # Merged phenotype tables (diagnosis, clinical)
+├── qc/                     # QC summaries and exclusion lists
+└── logs/                   # Processing logs
+```
+
+---
+
+## Benchmark Adapter Guidance
+
+For benchmark-style prompts, do not force the full orchestration when the task only asks for local MND data validation.
+
+- If the task starts from MND data already present on disk and only asks for BIDS validation:
+  - Skip the download stage
+  - Default to the narrow path `local MND discovery -> BIDS validation -> report`
+- In benchmark mode, do not require explicit confirmation before presenting the validation solution.
+
+---
+
+## Safety and Execution Policy
+- No execution before explicit plan confirmation.
+- All execution must be routed via `claw-shell`.
+- Missing dependencies must be resolved by `dependency-planner` before running.
+
+---
+
+## Important Notes and Limitations
+- MND is a clinical cohort; patient data requires careful handling.
+- Case-control matching should be verified before group comparisons.
+- Motor tasks are designed to probe motor network function; standard motor task GLM applies.
+- The dataset is relatively small (59 participants); statistical power may be limited.
+- `mnd-skill` is orchestration-only; detailed preprocessing logic remains in modality skills.
+
+---
+
+## When to Call This Skill
+- User asks for end-to-end MND workflow.
+- User asks to process MND fMRI data.
+- User needs BIDS validation for MND data.
+- User asks to extract MND phenotype data (diagnosis, clinical measures).
+- User asks for motor network analysis in MND patients.
+
+---
+
+## Complementary / Related Skills
+- `smri-skill` → structural MRI preprocessing
+- `fmri-skill` → functional MRI preprocessing and analysis
+- `bids-organizer` → BIDS validation and organization
+- `brain-visualization` → visualization of derivatives
+- `dependency-planner` → dependency resolution
+- `conda-env-manager` → environment management
+- `claw-shell` → command execution
+
+---
+
+## Reference
+- OpenNeuro ds005874: https://openneuro.org/datasets/ds005874
+
+Created At: 2026-05-06 13:31 HKT
+Last Updated At: 2026-05-06 13:31 HKT
+Author: chengwang96

package/skills/06_fMRI_Neuroimaging/mnd-skill/scripts/extract_mnd_phenotype.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Extract and merge MND phenotype data.
+
+Reads MND phenotype files (diagnosis, clinical measures)
+and produces a merged phenotype table aligned with imaging subject list.
+"""
+import argparse
+import csv
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional
+
+# Column mapping for MND phenotype data
+COLUMN_MAP = {
+    "subject_id": ["subject", "Subject", "participant_id", "SubID"],
+    "age": ["age", "Age", "Age_in_Yrs"],
+    "sex": ["sex", "Sex", "Gender"],
+    "handedness": ["handedness", "Handedness"],
+    # Diagnosis
+    "diagnosis": ["diagnosis", "Diagnosis", "Group"],
+    "diagnosis_detail": ["diagnosis_detail", "Diagnosis_Detail"],
+    "patient_control": ["patient_control", "Patient_Control"],
+    # Clinical measures
+    "alsfrs_r": ["ALSFRS_R", "alsfrs_r_score"],
+    "alsfrs_r_total": ["ALSFRS_R_Total", "alsfrs_r_total"],
+    "disease_duration": ["disease_duration", "Disease_Duration"],
+    "onset_age": ["onset_age", "Onset_Age"],
+    "onset_site": ["onset_site", "Onset_Site"],
+    # Motor measures
+    "fvc_percent": ["FVC_Percent", "fvc_percent"],
+    "als_frs_bulbar": ["ALSFRS_Bulbar", "als_frs_bulbar"],
+    "als_frs_motor": ["ALSFRS_Motor", "als_frs_motor"],
+    "als_frs_respiratory": ["ALSFRS_Respiratory", "als_frs_respiratory"],
+}
+
+
+def load_csv(path: Path) -> List[Dict[str, str]]:
+    """Load CSV/TSV file and return list of dicts."""
+    delimiter = "\t" if path.suffix == ".tsv" else ","
+    with open(path, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f, delimiter=delimiter)
+        return list(reader)
+
+
+def find_column(row: Dict[str, str], candidates: List[str]) -> Optional[str]:
+    """Find the first matching column name in a row."""
+    for col in candidates:
+        if col in row:
+            return col
+    return None
+
+
+def extract_phenotype(
+    phenotype_files: List[Path],
+    imaging_ids: Optional[List[str]] = None,
+    columns: Optional[List[str]] = None,
+) -> List[Dict[str, str]]:
+    """Extract and merge phenotype data from multiple files."""
+    all_data = []
+    for fpath in phenotype_files:
+        rows = load_csv(fpath)
+        all_data.extend(rows)
+
+    if not all_data:
+        return []
+
+    target_columns = columns if columns else list(COLUMN_MAP.keys())
+    merged = {}
+
+    for row in all_data:
+        subj_col = find_column(row, COLUMN_MAP["subject_id"])
+        if subj_col is None:
+            continue
+        subj_id = row[subj_col].strip()
+        if not subj_id:
+            continue
+
+        if subj_id not in merged:
+            merged[subj_id] = {"subject_id": subj_id}
+
+        for target_col in target_columns:
+            if target_col == "subject_id":
+                continue
+            if target_col in merged[subj_id] and merged[subj_id][target_col]:
+                continue
+            candidates = COLUMN_MAP.get(target_col, [target_col])
+            src_col = find_column(row, candidates)
+            if src_col and row.get(src_col, "").strip():
+                merged[subj_id][target_col] = row[src_col].strip()
+
+    result = list(merged.values())
+    if imaging_ids:
+        imaging_set = set(imaging_ids)
+        result = [r for r in result if r["subject_id"] in imaging_set]
+    return result
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Extract MND phenotype data."
+    )
+    parser.add_argument("--phenotype-files", required=True, nargs="+",
+                        help="Paths to MND phenotype CSV/TSV files")
+    parser.add_argument("--output", required=True, help="Output path for merged phenotype CSV")
+    parser.add_argument("--imaging-ids", help="Text file with imaging subject IDs to filter")
+    parser.add_argument("--columns", help="Comma-separated columns to extract")
+    args = parser.parse_args()
+
+    phenotype_files = [Path(f).resolve() for f in args.phenotype_files]
+    for f in phenotype_files:
+        if not f.exists():
+            print(f"File not found: {f}", file=sys.stderr)
+            return 1
+
+    imaging_ids = None
+    if args.imaging_ids:
+        id_file = Path(args.imaging_ids).resolve()
+        if id_file.exists():
+            imaging_ids = [l.strip() for l in id_file.read_text().splitlines() if l.strip()]
+
+    columns = None
+    if args.columns:
+        columns = [c.strip() for c in args.columns.split(",")]
+
+    merged = extract_phenotype(phenotype_files, imaging_ids, columns)
+    if not merged:
+        print("[ERROR] No phenotype data extracted.", file=sys.stderr)
+        return 1
+
+    output_path = Path(args.output).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    fieldnames = list(merged[0].keys())
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(merged)
+
+    print(f"Phenotype: {len(merged)} subjects, {len(fieldnames)} columns -> {output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/06_fMRI_Neuroimaging/mnd-skill/scripts/mnd_qc_summary.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Generate per-subject QC summaries for MND processing.
+
+Clinical-specific: tracks diagnosis group and applies appropriate QC criteria.
+"""
+import argparse
+import csv
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+
+def load_confounds(confounds_path: Path) -> Dict[str, float]:
+    """Extract QC metrics from fMRIPrep confounds TSV."""
+    metrics = {"fd_mean": float("nan"), "fd_max": float("nan")}
+    try:
+        import pandas as pd
+        df = pd.read_csv(confounds_path, sep="\t")
+        if "framewise_displacement" in df.columns:
+            fd = df["framewise_displacement"].dropna()
+            metrics["fd_mean"] = float(fd.mean())
+            metrics["fd_max"] = float(fd.max())
+    except Exception:
+        pass
+    return metrics
+
+
+def check_exclusion(metrics: Dict[str, float], fd_threshold: float = 0.3) -> List[str]:
+    """Check exclusion criteria."""
+    reasons = []
+    if not (metrics["fd_mean"] != metrics["fd_mean"]):
+        if metrics["fd_mean"] > fd_threshold:
+            reasons.append(f"FD mean {metrics['fd_mean']:.3f} > {fd_threshold}")
+    return reasons
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Generate QC summaries for MND processing."
+    )
+    parser.add_argument("--fmriprep-dir", help="Path to fMRIPrep output directory")
+    parser.add_argument("--output", required=True, help="Output path for QC summary CSV")
+    parser.add_argument("--exclude-output", help="Output path for exclusion list CSV")
+    parser.add_argument("--fd-threshold", type=float, default=0.3,
+                        help="FD threshold (default: 0.3 mm)")
+    parser.add_argument("--diagnosis-file", help="CSV with subject diagnosis info")
+    args = parser.parse_args()
+
+    output_path = Path(args.output).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Load diagnosis info if available
+    diagnosis_map = {}
+    if args.diagnosis_file:
+        diag_path = Path(args.diagnosis_file).resolve()
+        if diag_path.exists():
+            with open(diag_path, "r", encoding="utf-8") as f:
+                reader = csv.DictReader(f)
+                for row in reader:
+                    subj = row.get("subject_id") or row.get("Subject", "")
+                    diag = row.get("diagnosis") or row.get("Diagnosis") or row.get("Group", "")
+                    if subj and diag:
+                        diagnosis_map[subj] = diag
+
+    # Discover subjects
+    subjects = set()
+    if args.fmriprep_dir:
+        fmriprep_dir = Path(args.fmriprep_dir).resolve()
+        if fmriprep_dir.exists():
+            for d in fmriprep_dir.glob("sub-*"):
+                if d.is_dir():
+                    subjects.add(d.name)
+
+    if not subjects:
+        print("[WARN] No subjects found.", file=sys.stderr)
+        return 1
+
+    results = []
+    excluded = []
+    for subj in sorted(subjects):
+        metrics = {"subject_id": subj}
+
+        # Add diagnosis if available
+        if diagnosis_map:
+            metrics["diagnosis"] = diagnosis_map.get(subj, "unknown")
+
+        if args.fmriprep_dir:
+            confounds_files = list(Path(args.fmriprep_dir).glob(f"{subj}/func/*_desc-confounds_timeseries.tsv"))
+            if confounds_files:
+                metrics.update(load_confounds(confounds_files[0]))
+
+        exclusion_reasons = check_exclusion(metrics, args.fd_threshold)
+        metrics["excluded"] = len(exclusion_reasons) > 0
+        metrics["exclusion_reasons"] = "; ".join(exclusion_reasons)
+
+        results.append(metrics)
+        if exclusion_reasons:
+            excluded.append({"subject_id": subj, "reasons": "; ".join(exclusion_reasons)})
+
+    if results:
+        fieldnames = list(results[0].keys())
+        with open(output_path, "w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(results)
+        print(f"QC: {len(results)} subjects, {len(excluded)} excluded -> {output_path}")
+
+    if args.exclude_output and excluded:
+        exclude_path = Path(args.exclude_output).resolve()
+        exclude_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(exclude_path, "w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=["subject_id", "reasons"])
+            writer.writeheader()
+            writer.writerows(excluded)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())