@brainpilot/skills 0.0.6 → 0.0.8

package/skills/01_Meta-Skills/knowledge-graph-builder/scripts/new_data_source_template.py

@@ -0,0 +1,116 @@
+"""Template: Ingest a new data source into the knowledge graph.
+
+Usage:
+    python scripts/new_data_source_template.py --input data.tsv
+
+Replace TODO sections with your source-specific logic.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+
+# Adjust import path for your project structure
+from core.knowledge_graph.src.schema import ConceptNode, Edge, DomainTag
+from core.knowledge_graph.src.graph_manager import KnowledgeGraph
+from core.knowledge_graph.src.storage import load_graph, save_graph
+
+logger = logging.getLogger(__name__)
+
+
+def parse_data(data_path: str) -> list[dict]:
+    """TODO: Parse your source data file.
+
+    Returns list of dicts with at minimum:
+        - id: unique identifier
+        - name: preferred display name
+        - type: entity type (maps to DomainTag)
+        - parent_id: optional, for hierarchical edges
+        - synonyms: optional, list of alternate names
+    """
+    records = []
+    # TODO: implement parsing logic
+    # Example TSV parsing:
+    # with open(data_path) as f:
+    #     reader = csv.DictReader(f, delimiter='\t')
+    #     for row in reader:
+    #         records.append({
+    #             "id": f"SRC:{row['id']}",
+    #             "name": row["name"],
+    #             "type": "disease",
+    #             "parent_id": row.get("parent_id"),
+    #             "synonyms": row.get("synonyms", "").split("|"),
+    #         })
+    return records
+
+
+def ingest_source(kg: KnowledgeGraph, data_path: str) -> dict:
+    """Parse source data and add concepts + edges to graph.
+
+    Returns summary dict.
+    """
+    records = parse_data(data_path)
+    concepts_added = 0
+    edges_added = 0
+
+    for rec in records:
+        # 1. Create ConceptNode
+        # TODO: map your entity types to DomainTag values
+        domain = DomainTag.DISEASE  # adjust as needed
+
+        node = ConceptNode(
+            id=rec["id"],
+            preferred_name=rec["name"],
+            domain_tags=[domain.value],
+            source_vocab="your_source_name",
+            aliases=rec.get("synonyms", []),
+        )
+        kg.add_concept(node)
+        concepts_added += 1
+
+        # 2. Create hierarchical edge (if applicable)
+        parent_id = rec.get("parent_id")
+        if parent_id:
+            edge = Edge(
+                source_id=rec["id"],
+                target_id=parent_id,
+                relation_type="is_a",  # or "part_of" for anatomy
+                source="your_source_name",
+            )
+            before = kg.G.number_of_edges()
+            kg.add_edge(edge)
+            if kg.G.number_of_edges() > before:
+                edges_added += 1
+
+    summary = {
+        "concepts_added": concepts_added,
+        "edges_added": edges_added,
+        "total_records": len(records),
+    }
+    logger.info(f"ingestion complete: {summary}")
+    return summary
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Ingest data from a new source")
+    parser.add_argument("--input", required=True, help="Path to source data file")
+    parser.add_argument("--graph", default=None, help="Path to existing graph JSON")
+    parser.add_argument("--output", default=None, help="Output graph path")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
+
+    graph_path = Path(args.graph) if args.graph else Path("core/knowledge_graph/data/knowledge_graph.json")
+    kg = load_graph(graph_path)
+
+    summary = ingest_source(kg, args.input)
+
+    out_path = Path(args.output) if args.output else graph_path
+    save_graph(kg, out_path)
+    logger.info(f"saved graph to {out_path}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/01_Meta-Skills/knowledge-graph-builder/scripts/requirements.txt

@@ -0,0 +1,15 @@
+# Knowledge Graph Builder - Python Dependencies
+
+# Core
+networkx>=3.0
+requests>=2.31.0
+
+# LLM extraction
+openai>=1.0.0
+
+# PubMed (optional, requests fallback available)
+biopython>=1.81
+
+# Atlas generation (optional)
+nilearn>=0.10.0
+nibabel>=5.0.0

package/skills/01_Meta-Skills/method-design/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: method-design
+description: "Use this skill whenever the user wants to formalize a network architecture and derive theoretical components from a research idea. Triggers include: 'method design', 'design method', 'network architecture', 'formula derivation', 'method-design', 'theoretical framework', 'derive equations', or any request to transform IDEA.md into a detailed METHOD.md. This skill is the **mandatory interface-layer method formalizer** in NeuroClaw: it reads IDEA.md, designs concrete network structures (layers, modules, connections), performs mathematical derivations (equations, loss functions, proofs), and always outputs a structured METHOD.md."
+license: MIT License (NeuroClaw custom skill – freely modifiable within the project)
+layer: interface
+skill_type: workflow
+dependencies: []
+---
+# Method Design
+
+## Overview
+This skill implements the **Framework Formalization & Theoretical Derivation** process for the NeuroClaw method-design phase.
+
+It acts as the Method Architect within the multi-agent framework:
+- Reads the latest **IDEA.md** from the workspace.
+- Designs the specific neural network structure (e.g., CNN backbone, attention modules, MRI-specific layers) tailored to the neuroscience task.
+- Derives all necessary formulas (loss functions, gradients, convergence proofs, etc.) using symbolic or step-by-step reasoning.
+- Produces a clean, publication-ready **METHOD.md** with sections: Architecture Diagram (text description), Detailed Layers, Mathematical Formulation, Implementation Notes, and Pseudocode.
+
+If any part is ambiguous, it asks the user for clarification before proceeding.  
+**Research use only** — the output is a mathematically rigorous METHOD.md ready for experiment-controller and paper-writing.
+
+## Quick Reference (Method Flow)
+
+| Step | Description                          | Output File            |
+|------|--------------------------------------|------------------------|
+| 1. Read & Parse | Load and analyze IDEA.md            | 01_idea_summary.md    |
+| 2. Architecture Design | Define network layers & modules     | 02_architecture.md    |
+| 3. Formula Derivation | Derive equations & proofs           | 03_formulas.md        |
+| 4. Pseudocode & Notes | Generate implementation details     | 04_pseudocode.md      |
+| 5. Finalize | Compile and polish                  | METHOD.md             |
+
+## Installation
+```bash
+# Place files in: skills/method-design/
+```
+
+## Important Notes & Limitations
+- Always starts from the latest IDEA.md; stops and prompts if missing.
+- Every step saved as numbered .md files for transparency and resumption.
+- Uses symbolic derivation (no hallucinated math); can call claw-shell or code tools internally for verification.
+- Final output always saved as `METHOD.md` in workspace root.
+- Diagrams are described in text (PlantUML/Mermaid ready); no image generation here.
+
+## When to Call This Skill
+- Immediately after research-idea skill completes IDEA.md
+- When the user wants to specify network details or mathematical foundation
+- Before experiment-controller or paper-writing
+
+## Complementary / Related Skills
+- `research-idea` → provides IDEA.md (input)
+- `experiment-controller` → consumes METHOD.md
+- `paper-writing` → consumes METHOD.md
+
+## Reference
+NeuroClaw architecture (section 1.5 method-design skill).  
+Flow: IDEA.md parsing → architecture design → equation derivation → pseudocode → METHOD.md  
+
+Created At: 2026-03-24 00:00 HKT
+Last Updated At: 2026-03-26 00:14 HKT  
+Author: chengwang96

package/skills/01_Meta-Skills/multi-search-engine/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: "multi-search-engine"
+description: "Multi search engine integration with 17 engines (8 CN + 9 Global). Supports advanced search operators, time filters, site search, privacy engines, and WolframAlpha knowledge queries. No API keys required."
+layer: base
+skill_type: tool
+dependencies: []
+---
+# Multi Search Engine v2.0.1
+
+Integration of 17 search engines for web crawling without API keys.
+
+## Search Engines
+
+### Domestic (8)
+- **Baidu**: `https://www.baidu.com/s?wd={keyword}`
+- **Bing CN**: `https://cn.bing.com/search?q={keyword}&ensearch=0`
+- **Bing INT**: `https://cn.bing.com/search?q={keyword}&ensearch=1`
+- **360**: `https://www.so.com/s?q={keyword}`
+- **Sogou**: `https://sogou.com/web?query={keyword}`
+- **WeChat**: `https://wx.sogou.com/weixin?type=2&query={keyword}`
+- **Toutiao**: `https://so.toutiao.com/search?keyword={keyword}`
+- **Jisilu**: `https://www.jisilu.cn/explore/?keyword={keyword}`
+
+### International (9)
+- **Google**: `https://www.google.com/search?q={keyword}`
+- **Google HK**: `https://www.google.com.hk/search?q={keyword}`
+- **DuckDuckGo**: `https://duckduckgo.com/html/?q={keyword}`
+- **Yahoo**: `https://search.yahoo.com/search?p={keyword}`
+- **Startpage**: `https://www.startpage.com/sp/search?query={keyword}`
+- **Brave**: `https://search.brave.com/search?q={keyword}`
+- **Ecosia**: `https://www.ecosia.org/search?q={keyword}`
+- **Qwant**: `https://www.qwant.com/?q={keyword}`
+- **WolframAlpha**: `https://www.wolframalpha.com/input?i={keyword}`
+
+## Quick Examples
+
+```javascript
+// Basic search
+web_fetch({"url": "https://www.google.com/search?q=python+tutorial"})
+
+// Site-specific
+web_fetch({"url": "https://www.google.com/search?q=site:github.com+react"})
+
+// File type
+web_fetch({"url": "https://www.google.com/search?q=machine+learning+filetype:pdf"})
+
+// Time filter (past week)
+web_fetch({"url": "https://www.google.com/search?q=ai+news&tbs=qdr:w"})
+
+// Privacy search
+web_fetch({"url": "https://duckduckgo.com/html/?q=privacy+tools"})
+
+// DuckDuckGo Bangs
+web_fetch({"url": "https://duckduckgo.com/html/?q=!gh+tensorflow"})
+
+// Knowledge calculation
+web_fetch({"url": "https://www.wolframalpha.com/input?i=100+USD+to+CNY"})
+```
+
+## Advanced Operators
+
+| Operator | Example                  | Description          |
+|----------|--------------------------|----------------------|
+| `site:`  | `site:github.com python` | Search within site   |
+| `filetype:` | `filetype:pdf report` | Specific file type   |
+| `""`     | `"machine learning"`     | Exact match          |
+| `-`      | `python -snake`          | Exclude term         |
+| `OR`     | `cat OR dog`             | Either term          |
+
+## Time Filters
+
+| Parameter   | Description |
+|-------------|-------------|
+| `tbs=qdr:h` | Past hour   |
+| `tbs=qdr:d` | Past day    |
+| `tbs=qdr:w` | Past week   |
+| `tbs=qdr:m` | Past month  |
+| `tbs=qdr:y` | Past year   |
+
+## Privacy Engines
+- **DuckDuckGo**: No tracking
+- **Startpage**: Google results + privacy
+- **Brave**: Independent index
+- **Qwant**: EU GDPR compliant
+
+## Bangs Shortcuts (DuckDuckGo)
+
+| Bang | Destination     |
+|------|-----------------|
+| `!g` | Google          |
+| `!gh`| GitHub          |
+| `!so`| Stack Overflow  |
+| `!w` | Wikipedia       |
+| `!yt`| YouTube         |
+
+## WolframAlpha Queries
+- Math: `integrate x^2 dx`
+- Conversion: `100 USD to CNY`
+- Stocks: `AAPL stock`
+- Weather: `weather in Beijing`
+
+## Documentation
+- `references/advanced-search.md` - Domestic search guide
+- `references/international-search.md` - International search guide
+- `CHANGELOG.md` - Version history
+
+## License
+MIT
+
+## Complementary / Related Skills
+- `academic-research-hub` → scholarly paper search
+
+## Reference
+Core multi-engine search integration for NeuroClaw (v2.0.1).  
+Used as the primary literature & web search backend across all interface-layer skills.
+
+Created At: 2026-03-24 00:00 HKT
+Last Updated At: 2026-03-26 00:18 HKT  
+Author: chengwang96

package/skills/01_Meta-Skills/research-idea/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: research-idea
+description: "Use this skill whenever the user wants to generate or refine a research idea through literature search and discussion. Triggers include: 'research idea', 'brainstorm idea', 'generate idea', 'research-idea', 'idea generation', 'discuss new direction', or any request to explore literature and output to IDEA.md. This skill is the **mandatory interface-layer idea generator** in NeuroClaw: it calls networking search skills to retrieve recent papers, identifies gaps/trends, then iteratively discusses with the user to finalize a structured idea, always saving the result as IDEA.md."
+license: MIT License (NeuroClaw custom skill – freely modifiable within the project)
+layer: interface
+skill_type: workflow
+dependencies:
+  - multi-search-engine
+  - academic-research-hub
+---
+# Research Idea
+
+## Overview
+This skill implements the **Literature Search + User Discussion** process for NeuroClaw research-idea phase.
+
+It acts as the Idea Generator within the multi-agent framework:
+- Automatically calls search skills (`multi-search-engine`, `academic-research-hub`, etc.) for the latest papers (prefer last 3–6 months).
+- Summarizes key trends, methods, and open gaps.
+- Engages in step-by-step discussion with the user to refine novelty and feasibility.
+- Saves the final structured idea as **IDEA.md** (Background, Gap, Proposed Idea, Methods Outline, Impact).
+
+If no topic is provided, it first asks the user for a domain (e.g., MRI segmentation, world models in neuroscience).
+
+**Research use only** — the output is a concise, actionable IDEA.md ready for method-design.
+
+## Quick Reference (Idea Flow)
+
+| Step | Description                  | Output File          |
+|------|------------------------------|----------------------|
+| 1. Search | Call search skills for recent literature | temp_search.md      |
+| 2. Analysis | Summarize trends & gaps     | 01_gap_analysis.md  |
+| 3. Draft | Propose initial idea        | 02_preliminary.md   |
+| 4. Discuss | Iterate with user feedback  | 03_discussion.md    |
+| 5. Finalize | Polish and save             | IDEA.md             |
+
+## Installation
+```bash
+# Place files in: skills/research-idea/
+```
+
+## Important Notes & Limitations
+- Always uses external search skills (no LLM hallucination for literature).
+- Every step saved as numbered .md files for transparency/resume.
+- Requires user confirmation at discussion steps.
+- Final output always saved as `IDEA.md` in workspace root.
+
+## When to Call This Skill
+- Start of any new project
+- User wants to brainstorm or pivot research direction
+- Before method-design or paper-writing
+
+## Complementary / Related Skills
+- `multi-search-engine` → core web & general literature retrieval
+- `academic-research-hub` → arXiv, PubMed, Semantic Scholar paper search
+- `method-design` → consumes IDEA.md
+- `paper-writing` → consumes IDEA.md
+- `experiment-controller` → follows finalized idea
+
+## Reference
+NeuroClaw architecture (section 1.4 research survey skill).  
+Flow: search → gap analysis → proposal → user discussion → IDEA.md  
+
+Created At: 2026-03-24 20:00 HKT
+Last Updated At: 2026-03-26 00:28 HKT  
+Author: chengwang96

package/skills/05_EEG_ERP/eeg-skill/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: eeg-skill
+description: "Use this skill whenever the user wants to load, preprocess, epoch, filter, or extract features from EEG data (resting-state, task-based, BCI, clinical, motor imagery, emotion, epilepsy, fatigue, etc.). Triggers include: 'eeg', 'EEG preprocessing', 'EEG feature extraction', 'band power', 'downsample to frequency bands', 'motor imagery BCI', 'emotion EEG', 'epilepsy detection', or any request involving .set/.edf/.bdf/.fif/.bids files."
+license: MIT License (NeuroClaw custom skill – freely modifiable within the project)
+layer: subagent
+skill_type: modality
+dependencies:
+  - mne-eeg-tool
+  - claw-shell
+---
+# EEG Skill (Modality Layer)
+
+## Overview
+
+`eeg-skill` is the NeuroClaw **modality-layer** interface skill responsible for all EEG 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 full implementation code**.
+- All concrete execution (MNE-Python calls, torchaudio, scipy, file I/O, etc.) is delegated to the dedicated base/tool skill `mne-eeg-tool`.
+- Waveform-to-spectrogram conversion uses `torchaudio.transforms.MelSpectrogram`.
+- Frequency-band energy extraction uses continuous wavelet transform (`scipy.signal.cwt` with `morlet2` wavelet).
+
+**Core workflow (never bypassed):**
+
+1. Identify the user-provided EEG files (BIDS, .set, .edf, .bdf, .fif, etc.).
+2. Generate a **numbered execution plan** that clearly states 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 `mne-eeg-tool` via `claw-shell`.
+5. After execution, save all outputs in a clean directory structure (`eeg_output/`).
+
+**Research use only** — outputs are for scientific analysis only.
+
+## Quick Reference (Common EEG Tasks – Updated 2026-03-25)
+
+| Task                                      | What needs to be done                                                      | Delegate to which tool skill                  | Expected output                          |
+|-------------------------------------------|----------------------------------------------------------------------------|-----------------------------------------------|------------------------------------------|
+| Load & basic validation                   | Read raw EEG + channel locations + events + validation                     | `claw-shell` (via `mne-eeg-tool`)             | Validation report + raw object           |
+| Bad-channel detection & interpolation     | Auto-detect + interpolate noisy channels                                   | `claw-shell` (via `mne-eeg-tool`)             | Cleaned raw data                         |
+| Downsampling + filtering                  | Resample, high-pass, notch, bandpass filtering                             | `claw-shell` (via `mne-eeg-tool`)             | Filtered .fif files                      |
+| Artifact removal                          | ICA + AutoReject + EOG/ECG regression                                      | `claw-shell` (via `mne-eeg-tool`)             | Cleaned data                             |
+| Continuous data cleaning                  | Resting-state pipeline (no events)                                         | `claw-shell` (via `mne-eeg-tool`)             | Cleaned continuous data                  |
+| Re-referencing & epoching                 | Average reference (CAR) / REST + epoching + baseline correction            | `claw-shell` (via `mne-eeg-tool`)             | Epoched .fif files                       |
+| Waveform to Mel-Spectrogram               | Convert raw waveform to Mel spectrogram using torchaudio                   | `claw-shell` (via `mne-eeg-tool`)             | Mel-spectrogram tensors (.pt)            |
+| Frequency-band energy extraction          | Extract δ/θ/α/β/γ band energy using CWT with morlet2 wavelet               | `claw-shell` (via `mne-eeg-tool`)             | Per-band power matrices (CSV / .npy)     |
+| Feature extraction (core)                 | Band power, CSP, Hjorth, sample entropy                                    | `claw-shell` (via `mne-eeg-tool`)             | Feature matrices (CSV / .npy / .npz)     |
+| Advanced features                         | Functional connectivity, ERP peaks/latency/AUC, frontal alpha asymmetry, microstates | `claw-shell` (via `mne-eeg-tool`)             | Connectivity matrices, ERP CSV, asymmetry .npy, microstates .fif |
+| Full end-to-end pipeline                  | Any combination of the above for BCI, emotion, epilepsy, fatigue, etc.     | `claw-shell` + `dependency-planner`           | Complete processed dataset + QC report   |
+
+## Installation (Handled by dependency-planner)
+
+No manual installation required.  
+When first used, `eeg-skill` automatically calls `dependency-planner` to create the isolated `neuroclaw-eeg` conda environment containing MNE-Python, torchaudio, scipy, and all required packages.
+
+## NeuroClaw recommended wrapper script
+
+```python
+# Example snippets (for reference in mne-eeg-tool implementation)
+
+# 1. Waveform to Mel-Spectrogram
+import torch
+import torchaudio.transforms as T
+
+mel_spec = T.MelSpectrogram(
+    sample_rate=256,      # Adjust according to your EEG sampling rate
+    n_fft=1024,
+    hop_length=256,
+    n_mels=128,
+    f_min=0.5,
+    f_max=60.0            # Common EEG frequency range
+)
+spectrogram = mel_spec(waveform)   # waveform shape: (channels, time)
+
+# 2. Frequency-band energy extraction using CWT + morlet2
+import numpy as np
+from scipy.signal import cwt, morlet2
+
+def extract_band_power(signal, fs=256):
+    widths = np.arange(1, 128)  # Adjust according to frequency range
+    cwt_matrix = cwt(signal, morlet2, widths)
+    
+    # Example: extract delta (0.5-4 Hz), theta (4-8 Hz), alpha (8-13 Hz), beta (13-30 Hz), gamma (30-60 Hz)
+    delta_power = np.mean(np.abs(cwt_matrix[low_idx:high_idx])**2, axis=0)
+    # ... similar processing for other bands
+    return band_powers
+```
+
+## Important Notes & Limitations
+
+- This SKILL.md contains **only high-level task descriptions and delegation instructions**.
+- Waveform-to-spectrogram conversion is handled by `torchaudio.transforms.MelSpectrogram`.
+- Frequency-band energy extraction is performed via continuous wavelet transform (`scipy.signal.cwt` + `morlet2` wavelet).
+- Long-running operations (ICA on long recordings, CWT on high-density data, connectivity matrices, microstate analysis) are automatically routed to background mode in the `claw` tmux session.
+- Execution begins **only after explicit user confirmation** of the full numbered plan.
+- All outputs are saved in `./eeg_output/` with clear subfolders (raw/, filtered/, epoched/, features/, spectrograms/, etc.).
+
+## When to Call This Skill
+
+- The user provides raw or partially processed EEG data and requests preprocessing, Mel-spectrogram conversion, frequency-band energy extraction, feature engineering, or a full pipeline.
+- After `research-idea` or `method-design` when the experiment involves EEG data.
+
+## Post-Execution Verification (Harness Integration)
+
+After EEG processing completes, this skill **automatically invokes harness-core's VerificationRunner** to validate preprocessed data quality:
+
+**Integrated verification checks**:
+
+```python
+from skills.harness_core import VerificationRunner, AuditLogger
+import numpy as np
+import mne
+
+verifier = VerificationRunner(task_type="eeg_preprocessing")
+
+# 1. EEG data file exists and is readable
+verifier.add_check("eeg_file_integrity",
+    checker=lambda: verify_eeg_file_readable(output_dir),
+    severity="error"
+)
+
+# 2. Channel count matches expected
+verifier.add_check("channel_count",
+    checker=lambda: verify_expected_channels(output_dir, expected_count=64),
+    severity="warning"
+)
+
+# 3. No excessive bad segments (after artifact removal)
+verifier.add_check("artifact_removal_success",
+    checker=lambda: verify_bad_segments_removed(output_dir, max_pct=5),
+    severity="warning"
+)
+
+# 4. Data range plausible (not clipped or saturated)
+verifier.add_check("data_range_plausible",
+    checker=lambda: verify_data_range(output_dir, min_range=-500, max_range=500),
+    severity="error"
+)
+
+# 5. No NaN/Inf values in preprocessed data
+verifier.add_check("no_nan_inf",
+    checker=lambda: verify_no_nan_inf(output_dir),
+    severity="error"
+)
+
+# 6. Frequency spectrum reasonable (no DC offset, reasonable content)
+verifier.add_check("frequency_spectrum",
+    checker=lambda: verify_frequency_spectrum(output_dir),
+    severity="warning"
+)
+
+# 7. Epoching statistics (if applicable)
+verifier.add_check("epoch_statistics",
+    checker=lambda: verify_epoch_count_and_length(output_dir),
+    severity="warning"
+)
+
+# 8. Feature extraction output dimensions
+verifier.add_check("feature_matrix_shape",
+    checker=lambda: verify_feature_matrix_shape(output_dir),
+    severity="warning"
+)
+
+report = verifier.run(output_dir)
+
+# Log verification results
+logger = AuditLogger(log_file=f"{output_dir}/eeg_verification.jsonl")
+logger.log_validation(
+    task_name="eeg_preprocessing",
+    checks_passed=len([r for r in report.results if r.passed]),
+    checks_failed=len([r for r in report.results if not r.passed]),
+    warnings=len([r for r in report.results if r.severity == "warning" and not r.passed]),
+    report_summary=report.to_dict()
+)
+
+if report.failed:
+    raise ValueError(f"EEG preprocessing verification failed: {report.summary}")
+```
+
+**Output files generated**:
+- `{output_dir}/eeg_verification.jsonl` — structured audit log
+- `{output_dir}/.eeg_verification_timestamp` — completion marker
+
+## Complementary / Related Skills
+
+- `dependency-planner` + `conda-env-manager` → environment and package installation (MNE-Python + torchaudio + scipy)
+- `mne-eeg-tool` → base/tool layer that contains all specific implementation code
+- `harness-core` → automated verification and audit logging
+
+## Reference
+
+Aligned with NeuroClaw modality-skill pattern (see `freesurfer-tool`, `wmh-segmentation`, etc.).  
+Core libraries: MNE-Python (main), `torchaudio.transforms.MelSpectrogram` (waveform to spectrogram), `scipy.signal.cwt` + `morlet2` (frequency band energy extraction).
+
+---
+Created At: 2026-03-25 16:00 HKT  
+Last Updated At: 2026-04-05 02:01 HKT
+Author: chengwang96