@brainpilot/skills 0.0.6 → 0.0.7

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

@@ -0,0 +1,173 @@
+---
+name: pet-skill
+description: "Use this skill whenever the user wants to process PET neuroimaging data including spatial normalization to T1w/MNI space, SUVR computation, reference region quantification, partial volume correction, or tracer-specific workflows (PiB amyloid, FDG metabolism, tau). Triggers include: 'PET', 'PET processing', 'SUVR', 'amyloid PET', 'FDG PET', 'tau PET', 'PiB', 'flortaucipir', 'reference region', 'partial volume correction', or any request involving PET neuroimaging data."
+license: MIT License (NeuroClaw custom skill – freely modifiable within the project)
+layer: subagent
+skill_type: modality
+dependencies:
+  - fsl-tool
+  - freesurfer-tool
+  - nibabel-skill
+  - claw-shell
+complementary_skills:
+  - smri-skill
+  - fmri-skill
+  - brain-visualization
+---
+# PET Skill (Modality Layer)
+
+## Overview
+
+`pet-skill` is the NeuroClaw **modality-layer** interface skill responsible for all PET neuroimaging 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 existing base/tool skills: `fsl-tool`, `freesurfer-tool`, `nibabel-skill`, and `claw-shell`.
+- Companion scripts in `scripts/` provide reference implementations for SUVR computation and reference region extraction.
+
+**Core workflow (never bypassed):**
+1. Identify input PET data and tracer type (PiB, FDG, tau, or other).
+2. Ensure T1w structural data is available (via `smri-skill` if not yet processed).
+3. Generate a **numbered execution plan** clearly stating WHAT needs to be done and which tool skill will handle each step.
+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 to the appropriate skill via `claw-shell`.
+6. After execution, save all outputs in a clean directory structure (`pet_output/`).
+
+**Research use only.**
+
+---
+
+## Quick Reference (Common PET Tasks)
+
+| Task | What needs to be done | Delegate to which tool skill | Expected output |
+|---|---|---|---|
+| PET-to-T1w coregistration | Register dynamic or static PET frame to T1w using rigid-body alignment | `fsl-tool` (FLIRT) | PET in T1w native space |
+| T1w-to-MNI normalization | Warp T1w (and co-registered PET) to MNI152 template | `fsl-tool` (FNIRT) or `smri-skill` | PET in MNI152 standard space |
+| Reference region extraction | Extract mean signal from anatomically defined reference region (e.g., cerebellar cortex, pons, whole cerebellum) | `fsl-tool` + `freesurfer-tool` + `nibabel-skill` | Reference region mean time-activity curve |
+| SUVR computation | Compute Standardized Uptake Value Ratio = target ROI / reference region | `scripts/compute_suvr.py` | Per-region SUVR values (CSV) |
+| Partial volume correction | Apply geometric transfer matrix (GTM) or region-based PVC methods | `fsl-tool` + custom | PVC-corrected ROI values |
+| Dynamic PET modeling | Kinetic modeling (e.g., Logan plot, SUVR with dynamic frames) | Custom analysis | DVR or SUVR over time |
+| Tracer-specific workflow | PiB (amyloid, cerebellar cortex ref), FDG (metabolism, pons ref), tau (flortaucipir, cerebellar cortex ref) | Full pipeline | Tracer-appropriate SUVR maps |
+
+---
+
+## Tracer-Specific Reference Regions
+
+| Tracer | Target | Reference Region | SUVR Threshold (amyloid+) |
+|---|---|---|---|
+| **PiB** (¹¹C-Pittsburgh Compound B) | Amyloid-β deposition | Cerebellar cortex (gray matter) | SUVR > 1.42 or > 1.21 (centiloid-adjusted) |
+| **FDG** (¹⁸F-Fluorodeoxyglucose) | Glucose metabolism (hypometabolism pattern) | Pons or whole cerebellum | Lower SUVR = worse metabolism |
+| **Tau** (¹⁸F-Flortaucipir / AV-1451) | Tau neurofibrillary tangles | Cerebellar cortex (gray matter) | SUVR > 1.2–1.3 (region-dependent) |
+
+---
+
+## Core Processing Pipeline
+
+### Stage 1: T1w Preprocessing (via `smri-skill`)
+- Brain extraction, tissue segmentation, cortical parcellation (FreeSurfer)
+- Required for reference region definition and PVC
+
+### Stage 2: PET-to-T1w Coregistration (via `fsl-tool`)
+- Rigid-body registration of mean PET frame to T1w using FLIRT
+- Apply transformation to full dynamic or static PET series
+
+### Stage 3: Reference Region Definition
+- Use FreeSurfer parcellation to extract reference region mask in T1w space
+- Common references: cerebellar cortex (`Cerebellum_Cortex` in Desikan-Killiany), pons
+- Project mask to PET space or keep in T1w space with partial volume correction
+
+### Stage 4: SUVR Computation (via `scripts/compute_suvr.py`)
+- Extract mean signal from target ROI and reference region
+- SUVR = mean(target) / mean(reference)
+- Output per-region SUVR values as CSV
+
+### Stage 5 (Optional): Spatial Normalization to MNI
+- Warp PET (in T1w space) to MNI152 using T1w-to-MNI warp
+- Enable group-level voxelwise analysis
+
+---
+
+## Scripts
+
+### `scripts/compute_suvr.py`
+Computes SUVR from a PET image and ROI/reference masks.
+
+```bash
+python skills/pet-skill/scripts/compute_suvr.py \
+  --pet /path/to/pet_in_t1w_space.nii.gz \
+  --target-mask /path/to/target_roi_mask.nii.gz \
+  --ref-mask /path/to/reference_region_mask.nii.gz \
+  --output /path/to/pet_output/suvr_values.csv
+```
+
+---
+
+## Standard Output Layout
+
+```
+pet_output/
+├── coregistration/          # PET-to-T1w registration matrices and resampled PET
+├── suvr/                    # SUVR maps and per-region CSV values
+│   ├── suvr_values.csv
+│   └── suvr_map.nii.gz
+├── pvc/                     # Partial volume corrected values (if requested)
+├── mni/                     # PET in MNI152 space (if normalization requested)
+├── qc/                      # Coregistration quality, reference region coverage
+└── logs/
+```
+
+---
+
+## Installation (Handled by dependency-planner)
+
+No manual installation required at this layer.
+When first used, `pet-skill` automatically calls `dependency-planner` to ensure `fsl-tool`, `freesurfer-tool`, `nibabel-skill`, and `claw-shell` are ready.
+
+---
+
+## Important Notes & Limitations
+
+- PET images are typically low-resolution (~2–4 mm); coregistration to high-resolution T1w is essential.
+- Reference region selection is tracer-dependent; using the wrong reference region invalidates SUVR.
+- Partial volume correction is recommended for atrophy-prone populations (e.g., Alzheimer's disease).
+- Dynamic PET requires frame timing information from DICOM headers or sidecar JSON.
+- Static PET (single late frame) is sufficient for most clinical SUVR analyses.
+- This skill is for research workflows; not for clinical decision-making.
+
+---
+
+## When to Call This Skill
+
+- After `smri-skill` when T1w structural preprocessing is complete and PET data needs processing.
+- When the user needs SUVR computation from amyloid (PiB), metabolism (FDG), or tau PET data.
+- When PET-to-T1w coregistration or normalization to MNI space is required.
+- When partial volume correction is requested for ROI-based PET quantification.
+- When dataset skills (e.g., `aibl-skill`, `adni-skill`) delegate PET processing.
+
+---
+
+## Complementary / Related Skills
+
+- `smri-skill` → T1w structural preprocessing (brain extraction, parcellation)
+- `fmri-skill` → if PET is used alongside fMRI for multimodal analysis
+- `fsl-tool` → FLIRT (coregistration), FNIRT (normalization), PETPVC (partial volume correction)
+- `freesurfer-tool` → cortical/subcortical parcellation for ROI definition
+- `nibabel-skill` → NIfTI I/O for mask manipulation
+- `brain-visualization` → PET overlay visualization
+- `aibl-skill` → AIBL dataset (PiB, FDG, tau PET)
+- `adni-skill` → ADNI dataset (PET data available)
+
+---
+
+## Reference
+- Klunk et al. (2004): PiB amyloid imaging
+- Landau et al. (2012): Amyloid imaging with PiB and florbetapir
+- Baker et al. (2017): AV-1451 tau PET imaging
+- BIDS PET extension: https://bids-specification.readthedocs.io/en/stable/04-modality-specific-files/09-positron-emission-tomography.html
+- FSL: https://fsl.fmrib.ox.ac.uk/fsl/
+- FreeSurfer: https://surfer.nmr.mgh.harvard.edu/
+
+Created At: 2026-05-06 12:19 HKT
+Last Updated At: 2026-05-06 12:19 HKT
+Author: chengwang96

package/skills/06_fMRI_Neuroimaging/pet-skill/scripts/compute_suvr.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""Compute SUVR (Standardized Uptake Value Ratio) from a PET image and ROI masks.
+
+Supports static PET (single frame) and mean-of-frames from dynamic PET.
+Outputs per-region SUVR values as CSV and optional SUVR map as NIfTI.
+"""
+import argparse
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional
+
+try:
+    import numpy as np
+except ImportError:
+    print("Error: numpy is required.", file=sys.stderr)
+    sys.exit(1)
+
+try:
+    import nibabel as nib
+except ImportError:
+    print("Error: nibabel is required.", file=sys.stderr)
+    sys.exit(1)
+
+
+def load_mask(mask_path: Path) -> tuple:
+    """Load a NIfTI mask and return (data array, affine)."""
+    img = nib.load(str(mask_path))
+    data = img.get_fdata()
+    return data, img.affine, img.header
+
+
+def extract_mean_signal(pet_data: np.ndarray, mask_data: np.ndarray) -> float:
+    """Extract mean PET signal within a binary mask."""
+    mask_bool = mask_data > 0
+    if not np.any(mask_bool):
+        return float("nan")
+    return float(np.mean(pet_data[mask_bool]))
+
+
+def compute_suvr_map(pet_data: np.ndarray, target_mask: np.ndarray, ref_mean: float) -> np.ndarray:
+    """Compute voxelwise SUVR map within target mask."""
+    suvr = np.zeros_like(pet_data)
+    if ref_mean > 0:
+        target_bool = target_mask > 0
+        suvr[target_bool] = pet_data[target_bool] / ref_mean
+    return suvr
+
+
+def load_multi_frame_pet(pet_path: Path, frame_index: Optional[int] = None) -> np.ndarray:
+    """Load PET image, optionally selecting a specific frame from 4D data."""
+    img = nib.load(str(pet_path))
+    data = img.get_fdata()
+
+    if data.ndim == 4:
+        if frame_index is not None:
+            if frame_index >= data.shape[3]:
+                print(f"[WARN] Frame index {frame_index} exceeds available frames {data.shape[3]}, using last frame")
+                frame_index = data.shape[3] - 1
+            data = data[:, :, :, frame_index]
+        else:
+            # Use mean across all frames
+            print(f"  4D PET detected ({data.shape[3]} frames), computing mean across frames")
+            data = np.mean(data, axis=3)
+
+    return data
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Compute SUVR from a PET image and ROI/reference masks."
+    )
+    parser.add_argument(
+        "--pet",
+        required=True,
+        help="Path to PET NIfTI file (3D static or 4D dynamic)",
+    )
+    parser.add_argument(
+        "--ref-mask",
+        required=True,
+        help="Path to reference region binary mask (e.g., cerebellar cortex)",
+    )
+    parser.add_argument(
+        "--target-mask",
+        help="Path to target ROI binary mask (single region). If omitted, only reference mean is reported.",
+    )
+    parser.add_argument(
+        "--roi-masks",
+        help="Comma-separated list of additional ROI masks for multi-region SUVR computation",
+    )
+    parser.add_argument(
+        "--roi-names",
+        help="Comma-separated ROI names (must match --roi-masks order)",
+    )
+    parser.add_argument(
+        "--frame",
+        type=int,
+        default=None,
+        help="Frame index for 4D PET (default: mean across all frames)",
+    )
+    parser.add_argument(
+        "--output",
+        required=True,
+        help="Output path for SUVR values CSV",
+    )
+    parser.add_argument(
+        "--suvr-map-output",
+        help="Optional: output path for voxelwise SUVR map NIfTI (requires --target-mask)",
+    )
+    args = parser.parse_args()
+
+    pet_path = Path(args.pet).resolve()
+    ref_path = Path(args.ref_mask).resolve()
+
+    if not pet_path.exists():
+        print(f"PET file not found: {pet_path}", file=sys.stderr)
+        return 1
+    if not ref_path.exists():
+        print(f"Reference mask not found: {ref_path}", file=sys.stderr)
+        return 1
+
+    # Load PET
+    print(f"Loading PET: {pet_path}")
+    pet_data = load_multi_frame_pet(pet_path, args.frame)
+    print(f"  PET shape: {pet_data.shape}, range: [{pet_data.min():.2f}, {pet_data.max():.2f}]")
+
+    # Load reference region
+    print(f"Loading reference mask: {ref_path}")
+    ref_data, ref_affine, ref_header = load_mask(ref_path)
+    ref_mean = extract_mean_signal(pet_data, ref_data)
+    print(f"  Reference region mean: {ref_mean:.4f}")
+
+    if np.isnan(ref_mean) or ref_mean <= 0:
+        print("[ERROR] Reference region mean is NaN or <= 0. Check mask alignment.", file=sys.stderr)
+        return 1
+
+    # Collect results
+    results = []
+
+    # Single target mask
+    if args.target_mask:
+        target_path = Path(args.target_mask).resolve()
+        if not target_path.exists():
+            print(f"Target mask not found: {target_path}", file=sys.stderr)
+            return 1
+        target_data, _, _ = load_mask(target_path)
+        target_mean = extract_mean_signal(pet_data, target_data)
+        suvr = target_mean / ref_mean if ref_mean > 0 else float("nan")
+        results.append({"roi": "target", "mean_signal": target_mean, "ref_mean": ref_mean, "suvr": suvr})
+        print(f"  Target mean: {target_mean:.4f}, SUVR: {suvr:.4f}")
+
+        # Optional SUVR map
+        if args.suvr_map_output:
+            suvr_map = compute_suvr_map(pet_data, target_data, ref_mean)
+            out_img = nib.Nifti1Image(suvr_map, ref_affine, ref_header)
+            suvr_map_path = Path(args.suvr_map_output).resolve()
+            suvr_map_path.parent.mkdir(parents=True, exist_ok=True)
+            nib.save(out_img, str(suvr_map_path))
+            print(f"  SUVR map saved: {suvr_map_path}")
+
+    # Multiple ROI masks
+    if args.roi_masks:
+        roi_paths = [Path(p.strip()).resolve() for p in args.roi_masks.split(",")]
+        roi_names = None
+        if args.roi_names:
+            roi_names = [n.strip() for n in args.roi_names.split(",")]
+        if roi_names and len(roi_names) != len(roi_paths):
+            print("[WARN] --roi-names count does not match --roi-masks count, using file stems", file=sys.stderr)
+            roi_names = None
+
+        for i, roi_path in enumerate(roi_paths):
+            if not roi_path.exists():
+                print(f"[WARN] ROI mask not found: {roi_path}", file=sys.stderr)
+                continue
+            roi_data, _, _ = load_mask(roi_path)
+            roi_mean = extract_mean_signal(pet_data, roi_data)
+            suvr = roi_mean / ref_mean if ref_mean > 0 else float("nan")
+            name = roi_names[i] if roi_names else roi_path.stem
+            results.append({"roi": name, "mean_signal": roi_mean, "ref_mean": ref_mean, "suvr": suvr})
+
+    if not results:
+        print("[WARN] No target or ROI masks provided. Only reference mean is reported.")
+        results.append({"roi": "reference_only", "mean_signal": float("nan"), "ref_mean": ref_mean, "suvr": float("nan")})
+
+    # Write CSV
+    import csv
+
+    output_path = Path(args.output).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=["roi", "mean_signal", "ref_mean", "suvr"])
+        writer.writeheader()
+        writer.writerows(results)
+
+    print(f"\nSUVR Summary ({len(results)} ROI(s)) -> {output_path}")
+    for r in results:
+        print(f"  {r['roi']}: SUVR = {r['suvr']:.4f}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,206 @@
+---
+name: pnc-skill
+description: "Use this skill whenever the user wants an end-to-end workflow for the Philadelphia Neurodevelopmental Cohort (PNC) dataset, including BIDS validation, multimodal processing of sMRI, rs-fMRI, task-fMRI, and dMRI, phenotype extraction, and QC integration. Triggers include: 'PNC', 'Philadelphia Neurodevelopmental Cohort', 'process PNC data', 'PNC fMRI', or any request to run the PNC multimodal pipeline."
+license: MIT License (NeuroClaw custom skill - freely modifiable within the project)
+layer: subagent
+skill_type: dataset
+dependencies:
+  - smri-skill
+  - fmri-skill
+  - dwi-skill
+  - bids-organizer
+  - claw-shell
+complementary_skills:
+  - brain-visualization
+---
+# PNC Skill (Dataset-Orchestration Layer)
+
+## Overview
+
+`pnc-skill` is the NeuroClaw orchestration skill for the **Philadelphia Neurodevelopmental Cohort (PNC)** dataset, a large-scale collaborative study between the University of Pennsylvania and the Children's Hospital of Philadelphia.
+
+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 PNC 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 (`pnc_output/`).
+
+**Research use only.**
+
+---
+
+## Quick Reference
+
+| Task | What needs to be done | Delegate to | Expected output |
+|---|---|---|---|
+| BIDS validation | Validate PNC BIDS structure | `scripts/validate_pnc.py` | Validation report |
+| sMRI processing | Brain extraction, tissue segmentation | `smri-skill` | `smri_output/` derivatives |
+| rs-fMRI processing | Preprocessing, denoising, connectivity | `fmri-skill` | `fmri_output/` connectivity |
+| task-fMRI processing | Go/No-Go, emotion, memory task GLM | `fmri-skill` | `fmri_output/` task results |
+| dMRI processing | Diffusion preprocessing, tensor metrics | `dwi-skill` | `dwi_output/` metrics |
+| Phenotype extraction | Cognitive, psychiatric, demographic | `scripts/extract_pnc_phenotype.py` | Merged phenotype CSV |
+| QC summary | Per-subject quality control | `scripts/pnc_qc_summary.py` | QC summary + exclusion list |
+
+---
+
+## Dataset Characteristics
+
+- **Cohort**: ~9,000+ youth aged 8-21 years
+- **Scanner**: 3T Siemens TIM Trio
+- **Modalities**: T1w sMRI, rs-fMRI, task-fMRI, dMRI/DTI
+- **Task paradigms**: Go/No-Go, Fraternal Twins, Penn Line Orientation, Penn Word Memory
+- **Clinical**: Psychiatric assessment, cognitive battery (Penn CNB)
+- **Access**: NIMH Data Archive (NDA), OpenNeuro ds000030 (BIDS subset)
+- **Format**: BIDS-compliant (community conversion)
+- **Reference**: Satterthwaite et al. (2014), NeuroImage
+
+---
+
+## Supported Modalities
+
+| Modality | Description | Tasks/Conditions |
+|---|---|---|
+| T1w | High-resolution structural MRI | 1mm isotropic |
+| rs-fMRI | Resting-state functional MRI | Eyes open |
+| task-fMRI | Task-based functional MRI | Go/No-Go, Emotion, Line Orientation, Word Memory |
+| dMRI | Diffusion-weighted imaging | DTI, white matter tractography |
+
+---
+
+## PNC Task Paradigms
+
+| Task | Description | Cognitive Domain |
+|---|---|---|
+| Go/No-Go | Response inhibition / impulse control | Executive function |
+| Fraternal Twins | Emotion recognition | Social cognition |
+| Penn Line Orientation | Spatial processing | Visuospatial |
+| Penn Word Memory | Memory encoding/retrieval | Episodic memory |
+
+---
+
+## BIDS Preparation
+
+### Script: `scripts/validate_pnc.py`
+
+Validates PNC BIDS structure and generates a compliance report.
+
+```bash
+python skills/pnc-skill/scripts/validate_pnc.py \
+  --input /path/to/PNC/bids \
+  --output /path/to/pnc_output/qc/bids_validation.csv
+```
+
+Features:
+- BIDS directory structure validation
+- Modality completeness check (T1w, rs-fMRI, task-fMRI, dMRI)
+- Age range verification (8-21 years)
+- Task paradigm presence check
+
+---
+
+## Core Workflow (Never Bypassed)
+
+1. Identify user target: full PNC 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_pnc.py`.
+5. Delegate to `smri-skill` for structural MRI processing.
+6. Delegate to `fmri-skill` for rs-fMRI and task-fMRI processing.
+7. Delegate to `dwi-skill` for dMRI processing.
+8. If phenotype extraction is requested, run `scripts/extract_pnc_phenotype.py`.
+9. If QC summary is requested, run `scripts/pnc_qc_summary.py`.
+10. Save outputs into `pnc_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` | task GLM, activation analysis | `fmri_output/` task results |
+| dMRI | `dwi-skill` | diffusion preprocessing, tensor metrics | `dwi_output/` metrics |
+
+---
+
+## Standard Output Layout
+
+```
+pnc_output/
+├── bids/                   # BIDS-staged data (or validation report)
+├── smri/                   # Structural MRI derivatives
+├── fmri/                   # Functional MRI derivatives (rs + task)
+├── dwi/                    # Diffusion MRI derivatives
+├── phenotype/              # Merged phenotype tables (cognitive, psychiatric)
+├── 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 PNC data validation.
+
+- If the task starts from PNC data already present on disk and only asks for BIDS validation:
+  - Skip the download stage
+  - Default to the narrow path `local PNC 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
+- PNC is a developmental cohort; analyses should account for age effects (8-21 years).
+- Pediatric data may require adjusted preprocessing parameters (e.g., higher motion thresholds).
+- Penn CNB (Computerized Neurocognitive Battery) provides rich cognitive phenotyping.
+- Psychiatric assessment includes DSM-based diagnoses.
+- Large sample size enables well-powered developmental analyses.
+- `pnc-skill` is orchestration-only; detailed preprocessing logic remains in modality skills.
+
+---
+
+## When to Call This Skill
+- User asks for end-to-end PNC workflow.
+- User asks to process PNC neuroimaging data.
+- User needs BIDS validation for PNC data.
+- User asks to extract PNC phenotype data (cognitive, psychiatric, demographic).
+- User asks for developmental neuroimaging analysis.
+
+---
+
+## Complementary / Related Skills
+- `smri-skill` → structural MRI preprocessing
+- `fmri-skill` → functional MRI preprocessing and analysis
+- `dwi-skill` → diffusion MRI preprocessing
+- `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
+- PNC: https://www.med.upenn.edu/bbl/
+- Satterthwaite et al. (2014): Neuroimaging of the Philadelphia Neurodevelopmental Cohort. NeuroImage.
+- OpenNeuro ds000030
+- NIMH Data Archive: https://nda.nih.gov/
+
+Created At: 2026-05-06 13:55 HKT
+Last Updated At: 2026-05-06 13:55 HKT
+Author: chengwang96