@brainpilot/skills 0.0.6 → 0.0.8

package/skills/06_fMRI_Neuroimaging/freesurfer-tool/SKILL.md

@@ -0,0 +1,286 @@
+---
+name: freesurfer-tool
+description: "Use this skill whenever the user wants to process structural MRI data (T1w, T2w, FLAIR, etc.) with FreeSurfer, especially for cortical/subcortical segmentation, surface reconstruction, parcellation, cortical thickness, volume statistics, or full recon-all pipeline. Triggers include: 'freesurfer', 'recon-all', 'segment MRI', 'FreeSurfer processing', 'cortical segmentation', 'subcortical segmentation', 'run recon-all', 'freesurfer T1', 'process brain MRI with freesurfer', 'aseg aparc', or any request to run FreeSurfer on NIfTI MRI data for research analysis."
+license: MIT License (NeuroClaw custom skill – freely modifiable within the project)
+layer: base
+skill_type: tool
+dependencies:
+  - claw-shell
+---
+# FreeSurfer Tool
+
+## Overview
+
+FreeSurfer is the gold-standard open-source suite for automated reconstruction of the brain’s cortical surface from structural MRI, including skull-stripping, intensity normalization, Talairach registration, cortical parcellation (Desikan-Killiany / Destrieux atlases), subcortical segmentation (`aseg`), surface mesh generation, cortical thickness estimation, and statistics.
+
+This skill serves as the **NeuroClaw interface-layer wrapper** for FreeSurfer and strictly follows the hierarchical design:
+
+1. Check whether FreeSurfer is installed (`recon-all --version`, `$FREESURFER_HOME` environment variable).  
+2. If not found → immediately invoke `dependency-planner` to plan and (after user confirmation) install the latest stable FreeSurfer release + license setup.  
+3. Collect and confirm: input NIfTI file(s), subject ID, output `SUBJECTS_DIR`, desired stages/flags (e.g. `-all`, `-autorecon1..3`, `-T2`, `-FLAIR`, `-parallel`).  
+4. Generate a clear, numbered execution plan including exact shell commands.  
+5. Present plan, estimated runtime, disk/RAM requirements, and risks → wait for explicit user confirmation (“YES” / “execute” / “proceed”).  
+6. On confirmation → delegate **all** shell command execution to the `claw-shell` skill (environment setup, `recon-all` invocation, logging, progress monitoring).  
+7. Report completion status, log location, output directory, and next steps.
+
+**Key design principle (2026 update)**: No direct `subprocess.run()` calls for long-running FreeSurfer commands. All shell execution is routed through `claw-shell` for centralized logging, timeout handling, real-time output streaming, and interruption safety.
+
+**Research use only.**
+
+## Quick Reference (Common Use Cases)
+
+| Task                              | Recommended `recon-all` flags / approach                          |
+|-----------------------------------|-------------------------------------------------------------------|
+| Full pipeline (most common)       | `-all`                                                            |
+| Fast subcortical + basic surfaces | `-autorecon1 -autorecon2 -autorecon3`                             |
+| Cortical surfaces & parcellation  | `-autorecon2 -autorecon3` (after `autorecon1` completed)          |
+| Improve pial surface with T2      | `-T2 T2w.nii.gz`                                                  |
+| Use FLAIR for better segmentation | `-FLAIR FLAIR.nii.gz`                                             |
+| Enable multi-core acceleration    | `-parallel -openmp 8` (or match available cores)                  |
+| Resume interrupted run            | Omit `-i` and `-all`, specify stages only                         |
+| Generate statistics only          | `-stats`                                                          |
+
+## Installation Check & Setup
+
+Installation is **fully delegated** to `dependency-planner`.
+
+When FreeSurfer is not detected:
+- Call `dependency-planner` with request:  
+  "Install latest stable FreeSurfer (8.1.0 or newer) on current OS, including license.txt setup"
+- After user confirms the installation plan → `dependency-planner` handles download, package install, license placement
+- This skill then verifies `$FREESURFER_HOME` and `recon-all` availability
+
+**Prerequisites**:
+- `dependency-planner` (mandatory for installation)
+- `claw-shell` (mandatory for command execution)
+- Valid FreeSurfer academic license (free registration required)
+- ≥16 GB RAM recommended (32 GB+ strongly preferred for `-all`)
+
+## Agent Reference Rule
+
+When the agent needs FreeSurfer processing implementation code, it should first consult the curated snippet in `skills/freesurfer-tool/scripts/` instead of copying from the embedded wrapper below.
+
+Reference snippet available:
+- `scripts/freesurfer_processor.py` -> recon-all pipeline orchestration: environment setup, stage selection, parallel flags, claw-shell delegation
+
+Example:
+```bash
+python skills/freesurfer-tool/scripts/freesurfer_processor.py \
+    --input-mri sub-001_T1w.nii.gz \
+    --subjid sub-001 \
+    --subjects-dir /data/freesurfer_output \
+    --stages all \
+    --extra-flags "-T2 T2.nii.gz -parallel -openmp 12"
+```
+
+## NeuroClaw recommended wrapper script
+
+```python
+# freesurfer_processor.py
+import argparse
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+
+# In real NeuroClaw: these would be agent tool calls
+def check_freesurfer_installed():
+    # Simulate check via claw-shell
+    # Real impl: call claw-shell with "recon-all --version"
+    return False, "FreeSurfer not found (simulation mode)"
+
+def delegate_to_claw_shell(commands, purpose, log_tag):
+    print(f"[Delegating to claw-shell] Purpose: {purpose}")
+    print(f"Log tag: {log_tag}")
+    print("Commands to execute:")
+    for cmd in commands:
+        print("  " + cmd)
+    # Real implementation: agent/tool call to claw-shell
+    # e.g. tool_call("claw-shell", commands=commands, log_tag=log_tag, capture_output=True, timeout="24h")
+
+def main():
+    parser = argparse.ArgumentParser(description="NeuroClaw FreeSurfer Processor")
+    parser.add_argument("--input-mri", required=True, help="Path to T1w (or other) NIfTI file")
+    parser.add_argument("--subjid", required=True, help="Subject ID (e.g. sub-001)")
+    parser.add_argument("--subjects-dir", required=True, help="Output SUBJECTS_DIR path")
+    parser.add_argument("--stages", default="all", help="all / autorecon1 / autorecon2 / autorecon3 / stats / comma-separated stages")
+    parser.add_argument("--extra-flags", default="", help="Additional flags, e.g. '-T2 T2.nii.gz -FLAIR FLAIR.nii.gz -parallel -openmp 12'")
+    parser.add_argument("--plan-only", action="store_true", help="Show plan without execution")
+    args = parser.parse_args()
+
+    installed, version_info = check_freesurfer_installed()
+    if not installed:
+        print("FreeSurfer not detected on system.")
+        print("→ Invoking dependency-planner to install FreeSurfer and set up license.")
+        print("Please complete the dependency-planner confirmation flow first.")
+        sys.exit(1)
+
+    print("FreeSurfer detected:", version_info)
+
+    subjects_dir = Path(args.subjects_dir).resolve()
+    print(f"\nProcessing plan for subject: {args.subjid}")
+    print(f"Input MRI     : {args.input_mri}")
+    print(f"Output dir    : {subjects_dir}")
+    print(f"Stages        : {args.stages}")
+    if args.extra_flags:
+        print(f"Extra flags   : {args.extra_flags}")
+
+    # Build shell commands
+    commands = []
+    # 1. Set environment
+    fs_home = "/usr/local/freesurfer"  # typical default; adjust if needed
+    commands.append(f"export FREESURFER_HOME={fs_home}")
+    commands.append(f"source $FREESURFER_HOME/SetUpFreeSurfer.sh")
+
+    # 2. recon-all command
+    recon_cmd = [
+        "recon-all",
+        "-subjid", args.subjid,
+        "-i", args.input_mri
+    ]
+
+    if args.stages == "all":
+        recon_cmd.append("-all")
+    elif "," in args.stages:
+        for stage in args.stages.split(","):
+            stage = stage.strip()
+            if stage:
+                recon_cmd.append(f"-{stage}")
+    else:
+        recon_cmd.append(f"-{args.stages}")
+
+    if args.extra_flags:
+        recon_cmd.extend(args.extra_flags.split())
+
+    # Recommend parallel execution if not disabled
+    if "-parallel" not in args.extra_flags and "-openmp" not in args.extra_flags:
+        recon_cmd.extend(["-parallel", "-openmp", "8"])
+
+    commands.append(" ".join(recon_cmd))
+
+    log_tag = f"freesurfer_{args.subjid}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+
+    print("\nExecution plan (to be run via claw-shell):")
+    for i, cmd in enumerate(commands, 1):
+        print(f"Step {i}: {cmd}")
+
+    print(f"\nEstimated runtime: 4–24 hours (full -all), 1–4 hours (segmentation stages only)")
+    print(f"Disk usage: ~2–5 GB per subject")
+    print(f"Logs will be captured by claw-shell under tag: {log_tag}")
+
+    if args.plan_only:
+        print("\nPlan-only mode — no execution performed.")
+        return
+
+    confirm = input("\nExecute now? Type YES to proceed: ").strip().upper()
+    if confirm != "YES":
+        print("Aborted by user.")
+        return
+
+    print("\nDelegating pipeline execution to claw-shell skill...")
+    delegate_to_claw_shell(
+        commands=commands,
+        purpose=f"FreeSurfer processing for subject {args.subjid} ({args.stages})",
+        log_tag=log_tag
+    )
+
+    print(f"→ Execution handed over to claw-shell.")
+    print(f"→ Check logs using tag: {log_tag}")
+    print(f"→ Final outputs will be in: {subjects_dir / args.subjid}")
+
+if __name__ == "__main__":
+    main()
+```
+
+## Important Notes & Limitations
+
+- All actual shell command execution is delegated to `claw-shell` (no direct `subprocess` calls for `recon-all`).  
+- Full `-all` pipeline is very long-running → `claw-shell` should support background/detached mode or long timeouts.  
+- Input must be NIfTI (`.nii` or `.nii.gz`); convert DICOM first using `dcm2nii` skill.  
+- Output follows standard FreeSurfer structure: `$SUBJECTS_DIR/<subjid>`.  
+- Windows users: strongly recommended to use WSL2 (installation handled by `dependency-planner`).  
+- License check: skill assumes `license.txt` is already in place after `dependency-planner` run.
+
+## When to Call This Skill
+
+- User provides structural MRI (NIfTI) and wants automated FreeSurfer processing.  
+- Any mention of `recon-all`, `aseg`, `aparc`, cortical thickness, surface reconstruction, or FreeSurfer statistics.
+
+## Complementary / Related Skills
+
+- `dependency-planner` → install FreeSurfer + license  
+- `claw-shell` → safe execution of long-running shell commands  
+- `conda-env-manager` → manage Python environment for post-processing FreeSurfer outputs  
+
+## Reference
+
+Official site: https://surfer.nmr.mgh.harvard.edu  
+Latest stable release (as of 2026): FreeSurfer 8.1.0 or newer  
+License registration: https://surfer.nmr.mgh.harvard.edu/registration.html  
+Documentation: https://surfer.nmr.mgh.harvard.edu/fswiki/FreeSurferWiki  
+
+Custom NeuroClaw skill created to integrate FreeSurfer safely into the hierarchical skill structure.
+
+Curated reference snippet in this skill:
+- `skills/freesurfer-tool/scripts/freesurfer_processor.py`
+
+## Post-Execution Verification (Harness Integration)
+
+After FreeSurfer processing completes, this skill **automatically invokes harness-core's VerificationRunner** to validate output integrity:
+
+**Integrated verification checks**:
+
+```python
+from skills.harness_core import VerificationRunner, AuditLogger
+
+verifier = VerificationRunner(task_type="freesurfer_processing")
+
+# 1. Brain-extracted anatomy files
+verifier.add_check("brain_extraction",
+    checker=lambda: verify_brain_extraction(subjects_dir, subjid),
+    severity="error"
+)
+
+# 2. Cortical surface files (white, pial)
+verifier.add_check("surface_reconstruction",
+    checker=lambda: verify_surface_files(subjects_dir, subjid),
+    severity="error"
+)
+
+# 3. Cortical thickness bounds (1–4 mm range)
+verifier.add_check("thickness_bounds",
+    checker=lambda: verify_cortical_thickness_range(subjects_dir, subjid),
+    severity="warning"
+)
+
+# 4. parcellation labels (aparc/aseg)
+verifier.add_check("parcellation",
+    checker=lambda: verify_aparc_aseg(subjects_dir, subjid),
+    severity="error"
+)
+
+# 5. Statistics file completeness
+verifier.add_check("statistics",
+    checker=lambda: verify_stats_files(subjects_dir, subjid),
+    severity="warning"
+)
+
+report = verifier.run(subjects_dir)
+
+# Log verification results
+logger = AuditLogger(log_file=f"{subjects_dir}/{subjid}/freesurfer_verification.jsonl")
+logger.log_validation(
+    task_name="freesurfer_processing",
+    subject_id=subjid,
+    checks_passed=len([r for r in report.results if r.passed]),
+    total_checks=len(report.results)
+)
+```
+
+**Output**: `{SUBJECTS_DIR}/{subjid}/freesurfer_verification.jsonl` (structured audit log with JSONL format)
+
+---
+
+Created At: 2026-03-19 20:00 HKT  
+Last Updated At: 2026-04-05 02:03 HKT  
+Author: chengwang96

package/skills/06_fMRI_Neuroimaging/freesurfer-tool/scripts/freesurfer_processor.py

@@ -0,0 +1,145 @@
+"""FreeSurfer Processor Reference - recon-all pipeline orchestration.
+
+Distilled from the NeuroClaw freesurfer-tool SKILL.md.
+Agent should consult this script instead of copying from SKILL.md directly.
+
+Usage:
+    python skills/freesurfer-tool/scripts/freesurfer_processor.py \
+        --input-mri sub-001_T1w.nii.gz \
+        --subjid sub-001 \
+        --subjects-dir /data/freesurfer_output \
+        --stages all \
+        --extra-flags "-T2 T2.nii.gz -parallel -openmp 12"
+
+    # Plan only (no execution):
+    python skills/freesurfer-tool/scripts/freesurfer_processor.py \
+        --input-mri sub-001_T1w.nii.gz \
+        --subjid sub-001 \
+        --subjects-dir /data/freesurfer_output \
+        --plan-only
+"""
+
+import argparse
+import sys
+from pathlib import Path
+from datetime import datetime
+
+
+def check_freesurfer_installed():
+    """Check if FreeSurfer is available on the system."""
+    # Simulate check via claw-shell
+    # Real impl: call claw-shell with "recon-all --version"
+    return False, "FreeSurfer not found (simulation mode)"
+
+
+def delegate_to_claw_shell(commands, purpose, log_tag):
+    """Delegate command execution to claw-shell."""
+    print(f"[Delegating to claw-shell] Purpose: {purpose}")
+    print(f"Log tag: {log_tag}")
+    print("Commands to execute:")
+    for cmd in commands:
+        print("  " + cmd)
+    # Real implementation: agent/tool call to claw-shell
+    # e.g. tool_call("claw-shell", commands=commands, log_tag=log_tag, capture_output=True, timeout="24h")
+
+
+def build_recon_all_command(args):
+    """Build the recon-all command from arguments."""
+    commands = []
+
+    # 1. Set environment
+    fs_home = "/usr/local/freesurfer"  # typical default; adjust if needed
+    commands.append(f"export FREESURFER_HOME={fs_home}")
+    commands.append("source $FREESURFER_HOME/SetUpFreeSurfer.sh")
+
+    # 2. recon-all command
+    recon_cmd = [
+        "recon-all",
+        "-subjid", args.subjid,
+        "-i", args.input_mri,
+    ]
+
+    if args.stages == "all":
+        recon_cmd.append("-all")
+    elif "," in args.stages:
+        for stage in args.stages.split(","):
+            stage = stage.strip()
+            if stage:
+                recon_cmd.append(f"-{stage}")
+    else:
+        recon_cmd.append(f"-{args.stages}")
+
+    if args.extra_flags:
+        recon_cmd.extend(args.extra_flags.split())
+
+    # Recommend parallel execution if not disabled
+    if "-parallel" not in args.extra_flags and "-openmp" not in args.extra_flags:
+        recon_cmd.extend(["-parallel", "-openmp", "8"])
+
+    commands.append(" ".join(recon_cmd))
+    return commands
+
+
+def main():
+    parser = argparse.ArgumentParser(description="NeuroClaw FreeSurfer Processor")
+    parser.add_argument("--input-mri", required=True, help="Path to T1w (or other) NIfTI file")
+    parser.add_argument("--subjid", required=True, help="Subject ID (e.g. sub-001)")
+    parser.add_argument("--subjects-dir", required=True, help="Output SUBJECTS_DIR path")
+    parser.add_argument("--stages", default="all",
+                        help="all / autorecon1 / autorecon2 / autorecon3 / stats / comma-separated stages")
+    parser.add_argument("--extra-flags", default="",
+                        help="Additional flags, e.g. '-T2 T2.nii.gz -FLAIR FLAIR.nii.gz -parallel -openmp 12'")
+    parser.add_argument("--plan-only", action="store_true", help="Show plan without execution")
+    args = parser.parse_args()
+
+    installed, version_info = check_freesurfer_installed()
+    if not installed:
+        print("FreeSurfer not detected on system.")
+        print("-> Invoking dependency-planner to install FreeSurfer and set up license.")
+        print("Please complete the dependency-planner confirmation flow first.")
+        sys.exit(1)
+
+    print("FreeSurfer detected:", version_info)
+
+    subjects_dir = Path(args.subjects_dir).resolve()
+    print(f"\nProcessing plan for subject: {args.subjid}")
+    print(f"Input MRI     : {args.input_mri}")
+    print(f"Output dir    : {subjects_dir}")
+    print(f"Stages        : {args.stages}")
+    if args.extra_flags:
+        print(f"Extra flags   : {args.extra_flags}")
+
+    commands = build_recon_all_command(args)
+    log_tag = f"freesurfer_{args.subjid}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+
+    print("\nExecution plan (to be run via claw-shell):")
+    for i, cmd in enumerate(commands, 1):
+        print(f"Step {i}: {cmd}")
+
+    print(f"\nEstimated runtime: 4-24 hours (full -all), 1-4 hours (segmentation stages only)")
+    print(f"Disk usage: ~2-5 GB per subject")
+    print(f"Logs will be captured by claw-shell under tag: {log_tag}")
+
+    if args.plan_only:
+        print("\nPlan-only mode - no execution performed.")
+        return
+
+    confirm = input("\nExecute now? Type YES to proceed: ").strip().upper()
+    if confirm != "YES":
+        print("Aborted by user.")
+        return
+
+    print("\nDelegating pipeline execution to claw-shell skill...")
+    delegate_to_claw_shell(
+        commands=commands,
+        purpose=f"FreeSurfer processing for subject {args.subjid} ({args.stages})",
+        log_tag=log_tag,
+    )
+
+    print(f"-> Execution handed over to claw-shell.")
+    print(f"-> Check logs using tag: {log_tag}")
+    print(f"-> Final outputs will be in: {subjects_dir / args.subjid}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/06_fMRI_Neuroimaging/fsl-tool/SKILL.md

@@ -0,0 +1,208 @@
+---
+name: fsl-tool
+description: "Use this skill whenever the user wants to process neuroimaging data with FSL (FMRIB Software Library), covering structural MRI, functional MRI (fMRI), and diffusion MRI (dMRI/DTI). Triggers include: 'use FSL', 'FSL processing', 'fsl_anat', 'FEAT', 'MELODIC', 'eddy', 'bedpostx', 'probtrackx', 'BET', 'FAST', 'FLIRT', 'FNIRT', 'run FSL pipeline'. This skill is the NeuroClaw interface-layer wrapper for FSL: checks installation, generates execution plan with concrete shell commands, waits for explicit confirmation, then routes all commands through claw-shell."
+license: MIT License (NeuroClaw custom skill – freely modifiable within the project)
+layer: base
+skill_type: tool
+dependencies:
+  - claw-shell
+---
+# FSL Tool
+
+## Overview
+
+FSL is a comprehensive library of analysis tools for MRI, fMRI, and diffusion brain imaging. This skill provides a safe, unified interface for the three core modalities in NeuroClaw:
+
+- Structural MRI (T1w, T2w, FLAIR)  
+- Functional MRI (task-based and resting-state)  
+- Diffusion MRI (DTI / dMRI)
+
+**Workflow**:
+
+1. Check if FSL is installed (`fslversion`).  
+2. If not installed → call `dependency-planner` to generate installation plan.  
+3. Analyze input files and propose concrete shell commands with parameter explanations.  
+4. Present full numbered plan + estimated time + risks.  
+5. Wait for explicit user confirmation (“YES”, “execute”, “proceed”).  
+6. Execute all commands safely via `claw-shell`.  
+7. Summarize outputs and suggest next steps.
+
+**Research use only.**
+
+## Core Modalities and Common Shell Commands
+
+### 1. Structural MRI
+```bash
+# One-click structural preprocessing (strongly recommended)
+fsl_anat -i T1w.nii.gz -o T1w_anat --clobber
+# -i : input T1w file
+# -o : output folder name
+# --clobber : overwrite existing files (commonly used)
+
+# Brain extraction (BET)
+bet T1w.nii.gz T1w_brain -m -f 0.5
+# -m : output brain mask (_mask.nii.gz)
+# -f : brain extraction threshold (0.3~0.7; 0.5 is usually stable)
+
+# Tissue segmentation + bias correction
+fast -t 1 -n 3 -H 0.1 -I 4 -l 20.0 -o T1w_fast T1w_brain
+# -t 1 : T1-weighted image
+# -n 3 : 3 tissue classes (GM, WM, CSF)
+# -H 0.1 : bias field correction strength
+
+# Linear + nonlinear registration to MNI152
+flirt -in T1w_brain -ref $FSLDIR/data/standard/MNI152_T1_2mm_brain -out T1w_to_MNI -omat T1w_to_MNI.mat -dof 12
+fnirt --in=T1w_brain --aff=T1w_to_MNI.mat --cout=T1w_to_MNI_warp --config=T1_2_MNI152_2mm
+
+# Subcortical segmentation
+first -i T1w_brain -o T1w_first -b
+```
+
+### 2. Functional MRI
+```bash
+# Motion correction
+mcflirt -in bold.nii.gz -out bold_mcf -plots -refvol 0
+
+# Task-based fMRI full analysis (FEAT)
+feat design.fsf
+
+# Resting-state ICA
+melodic -i bold_mcf.nii.gz -o melodic_output --report --nobet --bgthreshold=10 --tr=2.0 --mmthresh=0.5 --dim=30
+
+# Automatic denoising (FIX)
+fix melodic_output -c $FSLDIR/training_files/Standard.RData -m -f 20
+```
+
+### 3. Diffusion MRI
+```bash
+# Distortion and eddy current correction
+topup --imain=AP_PA_b0.nii.gz --datain=acqparams.txt --out=topup_results --fout=field --iout=b0_unwarped
+eddy --imain=dwi.nii.gz --mask=dwi_brain_mask.nii.gz --acqp=acqparams.txt --index=index.txt \
+     --bvecs=bvecs --bvals=bvals --topup=topup_results --out=eddy_corrected --very_verbose
+
+# Tensor fitting
+dtifit -k eddy_corrected.nii.gz -m dwi_brain_mask.nii.gz -r bvecs -b bvals -o dtifit
+
+# Multi-fiber modeling
+bedpostx bedpostx_input -n 3 -w 1 -b 1000
+
+# Automated major tract extraction
+xtract -bpx bedpostx_input.bedpostX -out xtract_results -str $FSLDIR/data/xtract/tracts.txt
+```
+
+## Quick Reference
+
+| Modality     | Task                        | Main Command                  | Typical Time      |
+|--------------|-----------------------------|-------------------------------|-------------------|
+| Structural   | Full preprocessing          | `fsl_anat`                    | 10–40 min        |
+| Structural   | Brain extraction            | `bet`                         | 1–3 min          |
+| Structural   | Tissue segmentation         | `fast`                        | 5–15 min         |
+| Functional   | Motion correction           | `mcflirt`                     | 2–10 min         |
+| Functional   | Task GLM                    | `feat`                        | 15–90 min        |
+| Functional   | Resting-state ICA           | `melodic`                     | 20–120 min       |
+| Diffusion    | Preprocessing               | `topup + eddy`                | 30–180 min       |
+| Diffusion    | Tensor metrics              | `dtifit`                      | 5–20 min         |
+| Diffusion    | Tractography                | `probtrackx2 / xtract`        | 30 min – 24 h+   |
+
+## Installation
+
+Use `dependency-planner` skill with one of the following requests:
+- “Install latest FSL on Ubuntu using official installer”  
+- “Install FSL via conda-forge in a new environment”
+
+After installation, verify with:
+```bash
+fslversion
+echo $FSLDIR
+```
+
+## Important Notes & Limitations
+
+- All actual execution is routed through `claw-shell`.  
+- Long-running commands (bedpostx, probtrackx, group FEAT, etc.) run safely in the `claw` tmux session.  
+- Always consider running `fsl_anat` first for structural data — it handles BET + FAST + registration automatically.  
+- Input must be NIfTI format. Use `dcm2nii` skill first if starting from DICOM.  
+- Monitor progress with `tail -f` on the log file provided by claw-shell.
+
+## When to Call This Skill
+
+- After `dcm2nii` conversion  
+- When any FSL preprocessing, registration, segmentation or advanced analysis is needed  
+- Before feeding quantitative results into `paper-writing` or `experiment-controller`
+
+## Complementary / Related Skills
+
+- `dependency-planner`  
+- `claw-shell`  
+
+## More Advanced Features
+
+For less common tools (ASL, FABBER, VBM, PALM, custom scripting, etc.), please refer to the official FSL documentation:
+- Official FSL Website: https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/  
+- Structural tools: https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/Structural  
+- Functional tools: https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FEAT  
+- Diffusion tools: https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FDT  
+- Full tool list: https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FSL  
+
+You may use the `multi-search-engine`, `academic-research-hub`, or `arxiv-cli-tools` skill anytime to find the latest FSL tutorials or example pipelines.
+
+## Post-Execution Verification (Harness Integration)
+
+After FSL processing completes, this skill **automatically invokes harness-core's VerificationRunner** to validate output integrity:
+
+**Integrated verification checks**:
+
+```python
+from skills.harness_core import VerificationRunner, AuditLogger
+
+verifier = VerificationRunner(task_type="fsl_processing")
+
+# 1. Brain extraction quality (BET)
+verifier.add_check("brain_extraction",
+    checker=lambda: verify_bet_output(output_dir),
+    severity="error"
+)
+
+# 2. FSL output files existence
+verifier.add_check("output_files",
+    checker=lambda: verify_output_files(output_dir),
+    severity="error"
+)
+
+# 3. Data integrity (NaN/Inf checks)
+verifier.add_check("data_integrity",
+    checker=lambda: verify_no_nan_inf(output_dir),
+    severity="error"
+)
+
+# 4. Registration quality metrics
+verifier.add_check("registration_quality",
+    checker=lambda: verify_registration_quality(output_dir),
+    severity="warning"
+)
+
+# 5. Tensor metrics bounds (for DTI/DWI)
+verifier.add_check("tensor_bounds",
+    checker=lambda: verify_fa_md_bounds(output_dir),
+    severity="warning"
+)
+
+report = verifier.run(output_dir)
+
+# Log verification results
+logger = AuditLogger(log_file=f"{output_dir}/fsl_verification.jsonl")
+logger.log_validation(
+    task_name="fsl_processing",
+    checks_passed=len([r for r in report.results if r.passed]),
+    total_checks=len(report.results),
+    output_path=output_dir
+)
+```
+
+**Output**: `{output_dir}/fsl_verification.jsonl` (structured audit log with JSONL format)
+
+---
+
+Created At: 2026-03-25 00:00 HKT  
+Last Updated At: 2026-04-05 02:03 HKT  
+Author: chengwang96