@brainpilot/skills 0.0.6 → 0.0.7

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

@@ -0,0 +1,302 @@
+---
+name: abide-skill
+description: "Use this skill whenever the user wants an end-to-end workflow for the ABIDE (Autism Brain Imaging Data Exchange) dataset, including download, BIDS organization, and processing of sMRI and rs-fMRI data. Triggers include: 'ABIDE', 'ABIDE data', 'process ABIDE', 'ABIDE fMRI', 'ABIDE sMRI', 'autism imaging', or any request to run the ABIDE pipeline. This is the NeuroClaw dataset-orchestration layer for ABIDE."
+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
+---
+# ABIDE Skill (Dataset-Orchestration Layer)
+
+## Overview
+`abide-skill` is the NeuroClaw orchestration skill for the **ABIDE (Autism Brain Imaging Data Exchange)** dataset.
+
+It coordinates a fixed three-phase workflow:
+1. Download ABIDE data from the FCP/INDI repository or NITRC.
+2. Prepare and validate BIDS-style data organization for downstream processing.
+3. Delegate modality pipelines to `smri-skill` and `fmri-skill`.
+
+It also provides **phenotype extraction** and **QC integration** paths:
+- Extract and merge ABIDE phenotype tables (diagnosis, age, sex, site, FIQ, ADOS, etc.).
+- Generate per-subject QC summaries with exclusion lists.
+
+This skill follows NeuroClaw hierarchy:
+- Defines **WHAT to do**, not low-level implementation details.
+- Does **not** execute direct shell commands itself.
+- Delegates all execution via `claw-shell` to base/tool skills.
+
+**Research use only.**
+
+---
+
+## Download Stage (Mandatory First Step)
+
+### Source
+ABIDE data is distributed through the **FCP/INDI** repository:
+- ABIDE I: https://fcon_1000.projects.nitrc.org/indi/abide/
+- ABIDE II: https://fcon_1000.projects.nitrc.org/indi/abide_II.html
+- NITRC mirror: https://www.nitrc.org/projects/fcp_indi/
+
+### Supported ABIDE Data Packages
+- **ABIDE I**: 1,112 subjects from 17 international sites (539 ASD, 573 controls)
+- **ABIDE II**: 1,044 subjects from 19 sites
+- **Phenotype data**: CSV files with demographics, diagnosis, cognitive scores
+- **Preprocessed derivatives** (optional): CPAC, DPARSF, CCS, NeuroMark pipelines
+
+### Delegation Rules for Download
+- Environment/setup checks: `dependency-planner` + `conda-env-manager`
+- Download tool installation and execution: `claw-shell`
+- Optional raw-data organization to BIDS-style staging: `bids-organizer`
+
+### Download Inputs to Confirm in Plan
+- Target ABIDE version (I, II, or both)
+- Target subset (full cohort, specific sites, or ASD/control only)
+- Subject list scope (full or custom IDs)
+- Whether to download raw data or preprocessed derivatives
+- Destination directory with sufficient disk space
+
+---
+
+## Narrow Path: ABIDE Raw NIfTI -> BIDS Staging
+
+Use this path when the task only asks to reorganize raw ABIDE NIfTI files into a BIDS-style dataset and does not require preprocessing, ROI extraction, phenotype merging, or downstream analysis.
+
+### When this narrow path should dominate
+- The task objective is limited to ABIDE NIfTI staging, BIDS renaming, sidecar handling, and dataset-level metadata.
+- Inputs are already local ABIDE NIfTI files or ABIDE-style subject/site folders.
+- The required deliverable is a direct staging script or command sequence, not a plan for fMRIPrep or downstream analysis.
+
+### Narrow-path contract
+- Do not widen the solution to fMRIPrep, ROI extraction, phenotype merging, or downstream analysis unless the task explicitly requires them.
+- Treat this as a direct file-organization problem: scan ABIDE subject/site layout, normalize subject labels, map modalities to BIDS names, copy or symlink NIfTI plus matching sidecars, and write dataset-level metadata plus staging logs.
+- If the task is benchmark-style, prefer a single direct end-to-end staging script over a confirmation-first orchestration plan.
+
+### Expected narrow-path behavior
+1. Detect ABIDE-style subject IDs (numeric, e.g., `0050642`) and normalize to BIDS labels such as `sub-0050642`.
+2. Detect site information and encode as BIDS session or metadata (e.g., `ses-NYU`, or site column in `participants.tsv`).
+3. Route modalities:
+   - T1w -> `anat/*_T1w`
+   - rs-fMRI/BOLD -> `func/*_task-rest_bold`
+4. Preserve or rename matching JSON sidecars when available; if metadata is absent, create only the minimal dataset files required by the task and log the limitation.
+5. Emit dataset-level outputs such as `dataset_description.json`, `participants.tsv`, `README`, and a manifest or skipped-file report.
+
+---
+
+## Core Workflow (Never Bypassed)
+1. Identify user target: full ABIDE download, imaging subset, phenotype extraction, or BIDS staging 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 download stage first (if needed).
+5. After download success, run BIDS preparation using `scripts/reorganize_abide.py`.
+6. Delegate to modality skills:
+   - `smri-skill` for structural MRI (T1w)
+   - `fmri-skill` for resting-state fMRI (rs-fMRI)
+7. If phenotype extraction is requested, run `scripts/extract_abide_phenotype.py`.
+8. If QC summary is requested, run `scripts/abide_qc_summary.py`.
+9. Save outputs into an ABIDE-centered structure under `abide_output/`.
+
+---
+
+## Input Layout (Example)
+
+Subject `0050642` from site NYU:
+
+```
+abide_raw/
+  NYU/
+    0050642/
+      session_1/
+        anat_1/
+          anat.nii.gz
+        func_1/
+          func.nii.gz
+  phenotype/
+    ABIDE_phenotypic.csv
+```
+
+Or flat layout:
+
+```
+abide_raw/
+  0050642/
+    anat/
+      T1w.nii.gz
+    func/
+      rest_bold.nii.gz
+```
+
+---
+
+## BIDS Preparation
+
+### Script: `scripts/reorganize_abide.py`
+
+Converts ABIDE raw directory structure to BIDS-compliant layout.
+
+```bash
+python skills/abide-skill/scripts/reorganize_abide.py \
+  --input /path/to/abide_raw \
+  --output /path/to/abide_bids \
+  --phenotype /path/to/abide_raw/phenotype/ABIDE_phenotypic.csv
+```
+
+Features:
+- Subject ID normalization: numeric ABIDE IDs to BIDS `sub-NNNNNNN`
+- Site extraction and encoding in `participants.tsv`
+- Modality routing: T1w, rs-fMRI
+- Sidecar JSON preservation and validation
+- `dataset_description.json` and `participants.tsv` generation with phenotype metadata
+- Dry-run mode: `--dry-run` to preview without copying
+
+---
+
+## Multimodal Processing Delegation
+
+After BIDS staging completes, `abide-skill` delegates by modality:
+
+| Modality | Delegated skill | Typical tasks | Main outputs |
+|---|---|---|---|
+| sMRI (T1w) | `smri-skill` | brain extraction, tissue segmentation, cortical reconstruction, ROI morphometry | `smri_output/` derivatives and stats |
+| rs-fMRI | `fmri-skill` | preprocessing, denoising, ROI time series, connectivity | `fmri_output/` derivatives, timeseries, connectivity |
+
+### Delegation Strategy
+- If user asks for full ABIDE analysis: run sMRI -> fMRI in ordered phases.
+- If user asks for one modality only: call only the corresponding modality skill.
+- If compute resources are adequate and the user approves parallel runs: run modality pipelines in parallel.
+
+---
+
+## Phenotype Extraction
+
+### Script: `scripts/extract_abide_phenotype.py`
+
+Extracts and merges ABIDE phenotype tables for downstream analysis.
+
+```bash
+python skills/abide-skill/scripts/extract_abide_phenotype.py \
+  --phenotype-dir /path/to/abide_raw/phenotype \
+  --output /path/to/abide_output/phenotype/merged_phenotype.csv \
+  --columns subject,DX_GROUP,AGE_AT_SCAN,SEX,FIQ,VIQ,PIQ,site \
+  --imaging-ids /path/to/abide_output/bids/participants.tsv
+```
+
+Features:
+- Reads ABIDE phenotype CSV files (ABIDE I and II compatible)
+- Standardizes column names (DX_GROUP: 1=ASD, 2=control)
+- Column selection and renaming
+- Site encoding and grouping
+- Missing value handling
+- Cross-reference with imaging subject list
+- Outputs merged CSV ready for statistical analysis or model training
+
+---
+
+## QC Integration
+
+### Script: `scripts/abide_qc_summary.py`
+
+Generates per-subject QC summaries and exclusion lists.
+
+```bash
+python skills/abide-skill/scripts/abide_qc_summary.py \
+  --fmriprep-dir /path/to/abide_output/fmriprep \
+  --freesurfer-dir /path/to/abide_output/smri/freesurfer \
+  --raw-qc /path/to/abide_raw/phenotype/ABIDE_phenotypic.csv \
+  --output /path/to/abide_output/qc/qc_summary.csv \
+  --exclude-output /path/to/abide_output/qc/exclude_list.csv \
+  --fd-threshold 0.3 \
+  --coverage-threshold 0.8
+```
+
+Features:
+- Reads fMRIPrep confounds (framewise displacement, DVARS)
+- Reads FreeSurfer recon-all QC metrics
+- Incorporates ABIDE QC flags (QC_RATER_1, func_perc_fd, anat_rater_1, etc.)
+- Applies exclusion criteria: motion threshold (FD), coverage threshold, structural quality
+- Per-site QC summary for site-effect assessment
+- Outputs per-subject QC summary CSV and exclusion list CSV
+
+---
+
+## Recommended Output Layout
+All assets should be organized under `./abide_output/`:
+- `abide_output/raw/` (downloaded original ABIDE files)
+- `abide_output/bids/` (staged BIDS data)
+- `abide_output/staging/` (optional normalized staging intermediate)
+- `abide_output/smri/` (links or copies from `smri_output/`)
+- `abide_output/fmri/` (links or copies from `fmri_output/`)
+- `abide_output/phenotype/` (merged phenotype tables)
+- `abide_output/qc/` (QC summaries and exclusion lists)
+- `abide_output/logs/` (download + orchestration logs)
+
+---
+
+## Benchmark Adapter Guidance
+
+For benchmark-style prompts, do not force the full `download -> staging -> multimodal processing` orchestration when the task is only asking for local ABIDE data staging or organization.
+
+- If the task starts from raw ABIDE data already present on disk and only asks for BIDS-style staging / organization:
+  - skip the mandatory download stage
+  - do not automatically delegate to `smri-skill` or `fmri-skill`
+  - default to the narrow path `local raw ABIDE discovery -> BIDS-style staging -> minimal metadata -> validation/report`
+- In benchmark mode, do not require explicit confirmation before presenting the direct staging solution.
+- Preserve the ABIDE-centered output contract under `abide_output/bids/` when the task is specifically a staging benchmark.
+- Only use the full multimodal orchestration and confirmation-heavy workflow when the prompt explicitly asks for download, end-to-end ABIDE processing, or post-staging structural / functional analysis.
+
+---
+
+## 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.
+- If download fails for partial subjects, continue batch with clear failure report and retry list.
+
+---
+
+## Important Notes and Limitations
+- ABIDE data from different sites may have varying acquisition parameters; site effects should be accounted for in analysis.
+- ABIDE subject IDs are numeric and vary in length across sites.
+- ABIDE I and II have different phenotype table formats; the extraction script handles both.
+- ABIDE provides preprocessed derivatives from multiple pipelines (CPAC, DPARSF, CCS); raw data processing via fMRIPrep is recommended for reproducibility.
+- ABIDE data does not include task-fMRI; only resting-state fMRI is available.
+- `abide-skill` is orchestration-only; detailed preprocessing logic remains in `smri-skill` and `fmri-skill`.
+
+---
+
+## When to Call This Skill
+- User asks for end-to-end ABIDE workflow.
+- User asks to download ABIDE data and then run sMRI/rs-fMRI processing.
+- User needs BIDS staging for raw ABIDE NIfTI files.
+- User asks to extract and merge ABIDE phenotype tables.
+- User asks for ABIDE-specific QC summaries and exclusion lists.
+- User needs a single entry point for ABIDE multimodal orchestration.
+
+---
+
+## Complementary / Related Skills
+- `smri-skill`
+- `fmri-skill`
+- `bids-organizer`
+- `fmriprep-tool`
+- `freesurfer-tool`
+- `neurostorm`
+- `brain_gnn`
+- `dependency-planner`
+- `conda-env-manager`
+- `claw-shell`
+
+---
+
+## Reference
+- ABIDE I: https://fcon_1000.projects.nitrc.org/indi/abide/
+- ABIDE II: https://fcon_1000.projects.nitrc.org/indi/abide_II.html
+- Di Martino et al., 2014, *The autism brain imaging data exchange: towards a large-scale evaluation of the intrinsic brain architecture in autism*
+- BIDS spec: https://bids.neuroimaging.io/
+
+Created At: 2026-05-06 01:45 HKT
+Last Updated At: 2026-05-06 01:45 HKT
+Author: chengwang96

package/skills/06_fMRI_Neuroimaging/abide-skill/scripts/abide_qc_summary.py

@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+"""Generate per-subject QC summaries and exclusion lists for ABIDE.
+
+Combines fMRIPrep confounds, FreeSurfer recon-all metrics, and ABIDE native
+QC flags to produce a unified QC report with configurable exclusion criteria.
+"""
+import argparse
+import csv
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple
+
+try:
+    import pandas as pd
+except ImportError:
+    print("Error: pandas is required. Install with: pip install pandas", file=sys.stderr)
+    sys.exit(1)
+
+
+def detect_delimiter(file_path: Path) -> str:
+    """Detect whether file uses tab or comma delimiter."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        first_line = f.readline()
+    if "\t" in first_line:
+        return "\t"
+    return ","
+
+
+def collect_fmriprep_qc(fmriprep_dir: Path) -> Dict[str, Dict[str, float]]:
+    """Collect QC metrics from fMRIPrep outputs."""
+    qc = {}
+
+    confounds_patterns = [
+        "**/desc-confounds_timeseries.tsv",
+        "**/*_desc-confounds_timeseries.tsv",
+        "**/confounds.tsv",
+    ]
+
+    confounds_files = []
+    for pattern in confounds_patterns:
+        confounds_files.extend(fmriprep_dir.rglob(pattern))
+
+    for confounds_file in confounds_files:
+        subject_id = None
+        for part in confounds_file.parts:
+            if part.startswith("sub-"):
+                subject_id = part
+                break
+        if not subject_id:
+            continue
+
+        delimiter = detect_delimiter(confounds_file)
+        try:
+            df = pd.read_csv(confounds_file, sep=delimiter, low_memory=False)
+        except Exception as e:
+            print(f"[WARN] Failed to read {confounds_file}: {e}", file=sys.stderr)
+            continue
+
+        fd_col = None
+        for col_name in ["framewise_displacement", "fd", "FD"]:
+            if col_name in df.columns:
+                fd_col = col_name
+                break
+
+        dvars_col = None
+        for col_name in ["dvars", "DVARS", "std_dvars"]:
+            if col_name in df.columns:
+                dvars_col = col_name
+                break
+
+        metrics = {"n_volumes": len(df)}
+
+        if fd_col:
+            fd_values = pd.to_numeric(df[fd_col], errors="coerce").dropna()
+            if len(fd_values) > 0:
+                metrics["mean_fd"] = float(fd_values.mean())
+                metrics["max_fd"] = float(fd_values.max())
+                metrics["median_fd"] = float(fd_values.median())
+            else:
+                metrics["mean_fd"] = 0.0
+                metrics["max_fd"] = 0.0
+                metrics["median_fd"] = 0.0
+
+        if dvars_col:
+            dvars_values = pd.to_numeric(df[dvars_col], errors="coerce").dropna()
+            if len(dvars_values) > 0:
+                metrics["mean_dvars"] = float(dvars_values.mean())
+
+        if subject_id in qc:
+            existing = qc[subject_id]
+            existing["mean_fd"] = max(existing.get("mean_fd", 0), metrics.get("mean_fd", 0))
+            existing["max_fd"] = max(existing.get("max_fd", 0), metrics.get("max_fd", 0))
+            existing["n_volumes"] = existing.get("n_volumes", 0) + metrics.get("n_volumes", 0)
+        else:
+            qc[subject_id] = metrics
+
+    return qc
+
+
+def collect_freesurfer_qc(freesurfer_dir: Path) -> Dict[str, Dict[str, float]]:
+    """Collect QC metrics from FreeSurfer recon-all outputs."""
+    qc = {}
+
+    for recon_log in freesurfer_dir.rglob("**/recon-all.log"):
+        # Extract subject ID from path
+        subject_id = None
+        for part in recon_log.parts:
+            if part.startswith("sub-"):
+                subject_id = part
+                break
+        if not subject_id:
+            continue
+
+        completed = False
+        try:
+            with open(recon_log, "r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+                completed = "finished without error" in content.lower() or "recon-all -done" in content.lower()
+        except Exception:
+            pass
+
+        metrics = {"completed": completed}
+
+        # Try to read aseg.stats
+        aseg_matches = list(freesurfer_dir.rglob(f"{subject_id}**/aseg.stats"))
+        if aseg_matches:
+            try:
+                with open(aseg_matches[0], "r", encoding="utf-8", errors="ignore") as f:
+                    for line in f:
+                        if "EstimatedTotalIntraCranialVol" in line:
+                            parts = line.split()
+                            if len(parts) >= 4:
+                                try:
+                                    metrics["etiv"] = float(parts[3])
+                                except ValueError:
+                                    pass
+                        elif "BrainSegVol" in line and "Not" not in line:
+                            parts = line.split()
+                            if len(parts) >= 4:
+                                try:
+                                    metrics["total_brain_volume"] = float(parts[3])
+                                except ValueError:
+                                    pass
+            except Exception:
+                pass
+
+        qc[subject_id] = metrics
+
+    return qc
+
+
+def collect_abide_native_qc(phenotype_file: Path) -> Dict[str, Dict[str, float]]:
+    """Collect ABIDE native QC flags from phenotype file."""
+    qc = {}
+    if not phenotype_file.exists():
+        return qc
+
+    try:
+        df = pd.read_csv(phenotype_file, sep=None, engine="python", low_memory=False)
+    except Exception as e:
+        print(f"[WARN] Failed to read {phenotype_file}: {e}", file=sys.stderr)
+        return qc
+
+    id_col = None
+    for col_name in ["SUBJECT_ID", "subject", "Subject", "SUBJECT_KEY"]:
+        if col_name in df.columns:
+            id_col = col_name
+            break
+    if not id_col:
+        return qc
+
+    # Look for QC columns
+    qc_cols = [c for c in df.columns if "qc" in c.lower() or "rater" in c.lower() or "perc_fd" in c.lower()]
+
+    for _, row in df.iterrows():
+        sid = str(row[id_col]).strip()
+        metrics = {}
+        for col in qc_cols:
+            val = row.get(col)
+            if pd.notna(val):
+                try:
+                    metrics[col] = float(val)
+                except (ValueError, TypeError):
+                    metrics[col] = str(val)
+        qc[f"sub-{sid}"] = metrics
+
+    return qc
+
+
+def generate_qc_summary(
+    fmriprep_qc: Dict[str, Dict[str, float]],
+    freesurfer_qc: Dict[str, Dict[str, float]],
+    abide_qc: Dict[str, Dict[str, float]],
+    fd_threshold: float = 0.3,
+    max_fd_threshold: float = 5.0,
+    coverage_threshold: float = 0.8,
+) -> Tuple["pd.DataFrame", List[str]]:
+    """Generate QC summary DataFrame and exclusion list."""
+    all_subjects = set()
+    all_subjects.update(fmriprep_qc.keys())
+    all_subjects.update(freesurfer_qc.keys())
+    all_subjects.update(abide_qc.keys())
+
+    rows = []
+    excluded = []
+
+    for sub_id in sorted(all_subjects):
+        row = {"subject_id": sub_id}
+        exclude_reasons = []
+
+        fp = fmriprep_qc.get(sub_id, {})
+        row["mean_fd"] = fp.get("mean_fd", None)
+        row["max_fd"] = fp.get("max_fd", None)
+        row["median_fd"] = fp.get("median_fd", None)
+        row["mean_dvars"] = fp.get("mean_dvars", None)
+        row["n_volumes"] = fp.get("n_volumes", None)
+
+        fs = freesurfer_qc.get(sub_id, {})
+        row["fs_completed"] = fs.get("completed", None)
+        row["total_brain_volume"] = fs.get("total_brain_volume", None)
+        row["etiv"] = fs.get("etiv", None)
+
+        abcd = abide_qc.get(sub_id, {})
+        for key, val in abcd.items():
+            row[f"abide_{key}"] = val
+
+        if row["mean_fd"] is not None and row["mean_fd"] > fd_threshold:
+            exclude_reasons.append(f"mean_fd={row['mean_fd']:.3f}>{fd_threshold}")
+
+        if row["max_fd"] is not None and row["max_fd"] > max_fd_threshold:
+            exclude_reasons.append(f"max_fd={row['max_fd']:.3f}>{max_fd_threshold}")
+
+        if row["fs_completed"] is False:
+            exclude_reasons.append("FreeSurfer recon-all incomplete")
+
+        row["exclude"] = len(exclude_reasons) > 0
+        row["exclude_reasons"] = "; ".join(exclude_reasons) if exclude_reasons else ""
+
+        if exclude_reasons:
+            excluded.append(sub_id)
+
+        rows.append(row)
+
+    df = pd.DataFrame(rows)
+    return df, excluded
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Generate per-subject QC summaries and exclusion lists for ABIDE."
+    )
+    parser.add_argument("--fmriprep-dir", help="Path to fMRIPrep output directory")
+    parser.add_argument("--freesurfer-dir", help="Path to FreeSurfer output directory")
+    parser.add_argument("--raw-qc", help="Path to ABIDE phenotype CSV with QC flags")
+    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="Mean FD threshold (default: 0.3)")
+    parser.add_argument("--max-fd-threshold", type=float, default=5.0, help="Max FD threshold (default: 5.0)")
+    parser.add_argument("--coverage-threshold", type=float, default=0.8, help="Coverage threshold (default: 0.8)")
+    args = parser.parse_args()
+
+    fmriprep_qc = {}
+    freesurfer_qc = {}
+    abide_qc = {}
+
+    if args.fmriprep_dir:
+        fp_dir = Path(args.fmriprep_dir).resolve()
+        if fp_dir.exists():
+            print(f"Collecting fMRIPrep QC from {fp_dir}...")
+            fmriprep_qc = collect_fmriprep_qc(fp_dir)
+            print(f"  Found {len(fmriprep_qc)} subjects")
+
+    if args.freesurfer_dir:
+        fs_dir = Path(args.freesurfer_dir).resolve()
+        if fs_dir.exists():
+            print(f"Collecting FreeSurfer QC from {fs_dir}...")
+            freesurfer_qc = collect_freesurfer_qc(fs_dir)
+            print(f"  Found {len(freesurfer_qc)} subjects")
+
+    if args.raw_qc:
+        raw_qc_path = Path(args.raw_qc).resolve()
+        if raw_qc_path.exists():
+            print(f"Collecting ABIDE native QC from {raw_qc_path}...")
+            abide_qc = collect_abide_native_qc(raw_qc_path)
+            print(f"  Found {len(abide_qc)} subjects")
+
+    if not fmriprep_qc and not freesurfer_qc and not abide_qc:
+        print("[ERROR] No QC data collected. Check input paths.", file=sys.stderr)
+        return 1
+
+    summary_df, excluded = generate_qc_summary(
+        fmriprep_qc=fmriprep_qc,
+        freesurfer_qc=freesurfer_qc,
+        abide_qc=abide_qc,
+        fd_threshold=args.fd_threshold,
+        max_fd_threshold=args.max_fd_threshold,
+        coverage_threshold=args.coverage_threshold,
+    )
+
+    output_path = Path(args.output).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    summary_df.to_csv(output_path, index=False)
+    print(f"\nQC Summary: {len(summary_df)} subjects -> {output_path}")
+    print(f"  Excluded: {len(excluded)} / {len(summary_df)} ({100*len(excluded)/max(len(summary_df),1):.1f}%)")
+
+    if args.exclude_output:
+        exclude_path = Path(args.exclude_output).resolve()
+        exclude_path.parent.mkdir(parents=True, exist_ok=True)
+        exclude_df = summary_df[summary_df["exclude"] == True][["subject_id", "exclude_reasons"]]
+        exclude_df.to_csv(exclude_path, index=False)
+        print(f"  Exclusion list: {exclude_path}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())