@brainpilot/skills 0.0.6 → 0.0.8

package/skills/06_fMRI_Neuroimaging/rest-mneta-mdd-skill/SKILL.md

@@ -0,0 +1,215 @@
+---
+name: rest-mneta-mdd-skill
+description: "Use this skill whenever the user wants an end-to-end workflow for the REST-meta-MDD (Resting-State Meta-Major Depressive Disorder) dataset, including BIDS validation, processing of rs-fMRI, phenotype extraction, and QC integration. Triggers include: 'REST-meta-MDD', 'MDD', 'Major Depressive Disorder', 'depression resting-state', 'process REST-meta-MDD', or any request to run the REST-meta-MDD pipeline."
+license: MIT License (NeuroClaw custom skill - freely modifiable within the project)
+layer: subagent
+skill_type: dataset
+dependencies:
+  - fmri-skill
+  - bids-organizer
+  - claw-shell
+complementary_skills:
+  - smri-skill
+  - brain-visualization
+---
+# REST-meta-MDD Skill (Dataset-Orchestration Layer)
+
+## Overview
+
+`rest-mneta-mdd-skill` is the NeuroClaw orchestration skill for the **REST-meta-MDD (Resting-State Meta-Major Depressive Disorder)** dataset, a large-scale multi-site consortium project pooling resting-state fMRI data from 17 research sites across China.
+
+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 REST-meta-MDD 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 (`rest_mdd_output/`).
+
+**Research use only.**
+
+---
+
+## Quick Reference
+
+| Task | What needs to be done | Delegate to | Expected output |
+|---|---|---|---|
+| BIDS validation | Validate REST-meta-MDD BIDS structure | `scripts/validate_rest_mdd.py` | Validation report |
+| rs-fMRI processing | Preprocessing, denoising, connectivity | `fmri-skill` | `fmri_output/` connectivity |
+| Phenotype extraction | Diagnosis, clinical measures, site info | `scripts/extract_rest_mdd_phenotype.py` | Merged phenotype CSV |
+| Site harmonization | Multi-site effect correction | `scripts/harmonize_sites.py` | Harmonized data |
+| QC summary | Per-subject quality control | `scripts/rest_mdd_qc_summary.py` | QC summary + exclusion list |
+
+---
+
+## Dataset Characteristics
+
+- **Cohort**: ~3,600+ participants
+  - **MDD patients**: ~1,837 Major Depressive Disorder patients
+  - **Healthy controls**: ~1,779 age/sex-matched controls
+- **Sites**: 17 research sites across China
+- **Scanner**: Multi-site (various 3T scanners)
+- **Modalities**: rs-fMRI (primary), T1w sMRI (some sites)
+- **Clinical**: Diagnosis (SCID), HAMD, HAMA, medication status
+- **Access**: Chinese Data Sharing Platform, REST-meta-MDD consortium
+- **Format**: NIfTI (community BIDS conversion available)
+- **Reference**: Yan et al. (2019), Science Bulletin
+
+---
+
+## Supported Modalities
+
+| Modality | Description | Details |
+|---|---|---|
+| rs-fMRI | Resting-state functional MRI | Eyes closed, 5-10 min |
+| T1w | Structural MRI (some sites) | 1mm isotropic |
+
+---
+
+## REST-meta-MDD Clinical Measures
+
+| Measure | Description | Domain |
+|---|---|---|
+| Diagnosis | MDD vs. Healthy Control (SCID-based) | Clinical status |
+| HAMD | Hamilton Depression Rating Scale | Depression severity |
+| HAMA | Hamilton Anxiety Rating Scale | Anxiety severity |
+| Medication | Medication status (medicated vs. drug-naive) | Treatment |
+| Site | Data collection site (1-17) | Multi-site |
+| Age | Age at scan | Demographics |
+| Sex | Biological sex | Demographics |
+| Education | Years of education | Demographics |
+
+---
+
+## BIDS Preparation
+
+### Script: `scripts/validate_rest_mdd.py`
+
+Validates REST-meta-MDD BIDS structure and generates a compliance report.
+
+```bash
+python skills/rest-mneta-mdd-skill/scripts/validate_rest_mdd.py \
+  --input /path/to/REST-meta-MDD/bids \
+  --output /path/to/rest_mdd_output/qc/bids_validation.csv
+```
+
+Features:
+- BIDS directory structure validation
+- Site identification and completeness check
+- Diagnostic group labeling (MDD vs. control)
+- Modality completeness (rs-fMRI required, T1w optional)
+
+---
+
+## Core Workflow (Never Bypassed)
+
+1. Identify user target: full REST-meta-MDD processing, rs-fMRI only, 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_rest_mdd.py`.
+5. Delegate to `fmri-skill` for rs-fMRI processing.
+6. If T1w data available, delegate to `smri-skill`.
+7. If phenotype extraction is requested, run `scripts/extract_rest_mdd_phenotype.py`.
+8. If site harmonization is requested, run `scripts/harmonize_sites.py`.
+9. If QC summary is requested, run `scripts/rest_mdd_qc_summary.py`.
+10. Save outputs into `rest_mdd_output/`.
+
+---
+
+## Modality Processing Delegation
+
+| Modality | Delegated skill | Typical tasks | Main outputs |
+|---|---|---|---|
+| rs-fMRI | `fmri-skill` | preprocessing, denoising, connectivity | `fmri_output/` connectivity |
+| sMRI (T1w) | `smri-skill` | brain extraction, tissue segmentation | `smri_output/` derivatives |
+
+---
+
+## Standard Output Layout
+
+```
+rest_mdd_output/
+├── bids/                   # BIDS-staged data (or validation report)
+├── fmri/                   # Functional MRI derivatives (rs-fMRI connectivity)
+├── smri/                   # Structural MRI derivatives (if available)
+├── phenotype/              # Merged phenotype tables (diagnosis, clinical, site)
+├── harmonized/             # Site-harmonized data (ComBat or similar)
+├── qc/                     # QC summaries and exclusion lists
+└── logs/                   # Processing logs
+```
+
+---
+
+## Multi-Site Harmonization
+
+REST-meta-MDD is a multi-site dataset (17 sites). Site effects are a major confound:
+
+- **ComBat**: Commonly used batch effect correction for neuroimaging data
+- **Site-wise z-scoring**: Normalize metrics within site before pooling
+- **Mixed-effects models**: Include site as random effect in statistical analyses
+- The `scripts/harmonize_sites.py` script provides reference implementations
+
+---
+
+## Benchmark Adapter Guidance
+
+For benchmark-style prompts, do not force the full orchestration when the task only asks for local REST-meta-MDD data validation.
+
+- If the task starts from REST-meta-MDD data already present on disk and only asks for BIDS validation:
+  - Skip the download stage
+  - Default to the narrow path `local REST-meta-MDD 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
+- Multi-site data (17 sites) requires careful site effect handling.
+- Scanner heterogeneity across sites introduces variability.
+- rs-fMRI is the primary modality; structural data is limited.
+- MDD diagnosis is SCID-based across all sites.
+- Large sample size (~3,600) provides good statistical power for case-control analyses.
+- Medication status is an important confound; subgroup analyses (medicated vs. drug-naive) are recommended.
+- `rest-mneta-mdd-skill` is orchestration-only; detailed preprocessing logic remains in modality skills.
+
+---
+
+## When to Call This Skill
+- User asks for end-to-end REST-meta-MDD workflow.
+- User asks to process REST-meta-MDD resting-state fMRI data.
+- User needs BIDS validation for REST-meta-MDD data.
+- User asks to extract REST-meta-MDD phenotype data (diagnosis, HAMD, site).
+- User asks for depression neuroimaging analysis or multi-site harmonization.
+
+---
+
+## Complementary / Related Skills
+- `fmri-skill` → functional MRI preprocessing and analysis
+- `smri-skill` → structural MRI preprocessing (if available)
+- `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
+- REST-meta-MDD: Chinese Data Sharing Platform
+- Yan et al. (2019): Reduced default mode network functional connectivity in patients with recurrent major depressive disorder. Science Bulletin.
+- REST-meta-MDD consortium
+
+Created At: 2026-05-06 13:55 HKT
+Last Updated At: 2026-05-06 13:55 HKT
+Author: chengwang96

package/skills/06_fMRI_Neuroimaging/rest-mneta-mdd-skill/scripts/extract_rest_mdd_phenotype.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Extract and merge REST-meta-MDD phenotype data.
+
+Reads REST-meta-MDD phenotype files (diagnosis, clinical measures, site info)
+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_MAP = {
+    "subject_id": ["subject", "Subject", "participant_id", "SubID"],
+    "age": ["age", "Age"],
+    "sex": ["sex", "Sex", "Gender"],
+    "education": ["education", "Education", "Edu"],
+    "diagnosis": ["diagnosis", "Diagnosis", "Group", "DX"],
+    "site": ["site", "Site", "site_id"],
+    # Clinical measures
+    "hamd": ["HAMD", "hamd", "HAMD_17", "hamd_17"],
+    "hama": ["HAMA", "hama"],
+    "medication": ["medication", "Medication", "Med_Status"],
+    "disease_duration": ["disease_duration", "Duration"],
+    "episode": ["episode", "Episode", "n_episodes"],
+    "first_episode_age": ["first_episode_age", "Age_Onset"],
+}
+
+
+def load_csv(path: Path) -> List[Dict[str, str]]:
+    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]:
+    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]]:
+    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 REST-meta-MDD phenotype data.")
+    parser.add_argument("--phenotype-files", required=True, nargs="+")
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--imaging-ids")
+    parser.add_argument("--columns")
+    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)
+
+    # Site summary
+    sites = set(r.get("site", "") for r in merged if r.get("site"))
+    print(f"Phenotype: {len(merged)} subjects, {len(fieldnames)} columns, {len(sites)} sites -> {output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/06_fMRI_Neuroimaging/rest-mneta-mdd-skill/scripts/harmonize_sites.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Harmonize multi-site neuroimaging data for REST-meta-MDD.
+
+Provides reference implementations for site effect correction:
+- ComBat harmonization
+- Site-wise z-scoring
+"""
+import argparse
+import csv
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import numpy as np
+
+
+def load_csv(path: Path) -> List[Dict[str, str]]:
+    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 site_wise_zscore(
+    data: np.ndarray,
+    sites: np.ndarray,
+) -> np.ndarray:
+    """Apply site-wise z-score normalization."""
+    harmonized = data.copy()
+    unique_sites = np.unique(sites)
+    for site in unique_sites:
+        mask = sites == site
+        site_data = data[mask]
+        mean = np.nanmean(site_data, axis=0)
+        std = np.nanstd(site_data, axis=0)
+        std[std == 0] = 1  # avoid division by zero
+        harmonized[mask] = (site_data - mean) / std
+    return harmonized
+
+
+def combat_harmonize(
+    data: np.ndarray,
+    sites: np.ndarray,
+    covariates: Optional[np.ndarray] = None,
+) -> np.ndarray:
+    """ComBat harmonization (simplified reference implementation).
+
+    For production use, consider the neuroCombat library:
+    pip install neurocombat
+    """
+    try:
+        from neuroCombat import neuroCombat
+        import pandas as pd
+
+        # Prepare data for neuroCombat
+        df_data = pd.DataFrame(data)
+        batch = sites.tolist()
+        covars = None
+        if covariates is not None:
+            covars = pd.DataFrame(covariates, columns=["cov1"])
+
+        result = neuroCombat(dat=df_data.T, batch=batch, covars=covars)
+        return result["dat"].T
+    except ImportError:
+        print("[WARN] neuroCombat not installed, falling back to site-wise z-score.",
+              file=sys.stderr)
+        return site_wise_zscore(data, sites)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Harmonize multi-site neuroimaging data."
+    )
+    parser.add_argument("--input", required=True,
+                        help="Input CSV/TSV with features (rows=subjects, cols=features)")
+    parser.add_argument("--site-column", default="site",
+                        help="Column name for site ID (default: site)")
+    parser.add_argument("--method", choices=["zscore", "combat"], default="zscore",
+                        help="Harmonization method (default: zscore)")
+    parser.add_argument("--output", required=True,
+                        help="Output path for harmonized data CSV")
+    parser.add_argument("--covariates", help="CSV with covariates to preserve")
+    args = parser.parse_args()
+
+    input_path = Path(args.input).resolve()
+    if not input_path.exists():
+        print(f"Input file not found: {input_path}", file=sys.stderr)
+        return 1
+
+    rows = load_csv(input_path)
+    if not rows:
+        print("[ERROR] No data loaded.", file=sys.stderr)
+        return 1
+
+    # Extract subject IDs and sites
+    subject_ids = [r.get("subject_id", r.get("subject", f"sub-{i}")) for i, r in enumerate(rows)]
+    sites = np.array([r.get(args.site_column, "unknown") for r in rows])
+
+    # Extract numeric feature columns
+    feature_cols = [c for c in rows[0].keys()
+                    if c not in ("subject_id", "subject", args.site_column)
+                    and c not in ("diagnosis", "group", "age", "sex")]
+
+    data = np.zeros((len(rows), len(feature_cols)))
+    for i, row in enumerate(rows):
+        for j, col in enumerate(feature_cols):
+            try:
+                data[i, j] = float(row.get(col, "nan"))
+            except ValueError:
+                data[i, j] = np.nan
+
+    # Harmonize
+    if args.method == "combat":
+        covariates = None
+        if args.covariates:
+            cov_path = Path(args.covariates).resolve()
+            if cov_path.exists():
+                cov_rows = load_csv(cov_path)
+                cov_cols = [c for c in cov_rows[0].keys() if c != "subject_id"]
+                covariates = np.zeros((len(cov_rows), len(cov_cols)))
+                for i, row in enumerate(cov_rows):
+                    for j, col in enumerate(cov_cols):
+                        try:
+                            covariates[i, j] = float(row.get(col, "0"))
+                        except ValueError:
+                            covariates[i, j] = 0.0
+        harmonized = combat_harmonize(data, sites, covariates)
+    else:
+        harmonized = site_wise_zscore(data, sites)
+
+    # Write output
+    output_path = Path(args.output).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    fieldnames = ["subject_id"] + feature_cols
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for i, sid in enumerate(subject_ids):
+            row = {"subject_id": sid}
+            for j, col in enumerate(feature_cols):
+                row[col] = f"{harmonized[i, j]:.6f}"
+            writer.writerow(row)
+
+    unique_sites = np.unique(sites)
+    print(f"Harmonized: {len(rows)} subjects, {len(feature_cols)} features, "
+          f"{len(unique_sites)} sites (method={args.method}) -> {output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/06_fMRI_Neuroimaging/rest-mneta-mdd-skill/scripts/rest_mdd_qc_summary.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Generate per-subject QC summaries for REST-meta-MDD processing.
+
+Multi-site QC: tracks site effects and applies site-appropriate thresholds.
+"""
+import argparse
+import csv
+import sys
+from pathlib import Path
+from typing import Dict, List
+
+
+def load_confounds(confounds_path: Path) -> Dict[str, float]:
+    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]:
+    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 REST-meta-MDD processing."
+    )
+    parser.add_argument("--fmriprep-dir", help="Path to fMRIPrep output directory")
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--exclude-output")
+    parser.add_argument("--fd-threshold", type=float, default=0.3)
+    parser.add_argument("--diagnosis-file", help="CSV with subject diagnosis/site info")
+    args = parser.parse_args()
+
+    output_path = Path(args.output).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    diagnosis_map = {}
+    site_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("Group", "")
+                    site = row.get("site") or row.get("Site", "")
+                    if subj:
+                        if diag:
+                            diagnosis_map[subj] = diag
+                        if site:
+                            site_map[subj] = site
+
+    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}
+        if diagnosis_map:
+            metrics["diagnosis"] = diagnosis_map.get(subj, "unknown")
+        if site_map:
+            metrics["site"] = site_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)
+
+        # Site-level summary
+        sites = set(r.get("site", "unknown") for r in results)
+        print(f"QC: {len(results)} subjects across {len(sites)} sites, "
+              f"{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())