pi-skill-search 0.1.0

package/skills/networkx/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: networkx
+description: Comprehensive toolkit for creating, analyzing, and visualizing complex networks and graphs in Python. Use when working with network/graph data structures, analyzing relationships between entities, computing graph algorithms (shortest paths, centrality, clustering), detecting communities, generating synthetic networks, or visualizing network topologies. Applicable to social networks, biological networks, transportation systems, citation networks, and any domain involving pairwise relationships.
+---
+
+# NetworkX
+
+## Overview
+
+NetworkX is a Python package for creating, manipulating, and analyzing complex networks and graphs. Use this skill when working with network or graph data structures, including social networks, biological networks, transportation systems, citation networks, knowledge graphs, or any system involving relationships between entities.
+
+## When to Use This Skill
+
+Invoke this skill when tasks involve:
+
+- **Creating graphs**: Building network structures from data, adding nodes and edges with attributes
+- **Graph analysis**: Computing centrality measures, finding shortest paths, detecting communities, measuring clustering
+- **Graph algorithms**: Running standard algorithms like Dijkstra's, PageRank, minimum spanning trees, maximum flow
+- **Network generation**: Creating synthetic networks (random, scale-free, small-world models) for testing or simulation
+- **Graph I/O**: Reading from or writing to various formats (edge lists, GraphML, JSON, CSV, adjacency matrices)
+- **Visualization**: Drawing and customizing network visualizations with matplotlib or interactive libraries
+- **Network comparison**: Checking isomorphism, computing graph metrics, analyzing structural properties
+
+## Core Capabilities
+
+### 1. Graph Creation and Manipulation
+
+NetworkX supports four main graph types:
+- **Graph**: Undirected graphs with single edges
+- **DiGraph**: Directed graphs with one-way connections
+- **MultiGraph**: Undirected graphs allowing multiple edges between nodes
+- **MultiDiGraph**: Directed graphs with multiple edges
+
+Create graphs by:
+```python
+import networkx as nx
+
+# Create empty graph
+G = nx.Graph()
+
+# Add nodes (can be any hashable type)
+G.add_node(1)
+G.add_nodes_from([2, 3, 4])
+G.add_node("protein_A", type='enzyme', weight=1.5)
+
+# Add edges
+G.add_edge(1, 2)
+G.add_edges_from([(1, 3), (2, 4)])
+G.add_edge(1, 4, weight=0.8, relation='interacts')
+```
+
+**Reference**: See `(see docs)` for comprehensive guidance on creating, modifying, examining, and managing graph structures, including working with attributes and subgraphs.
+
+### 2. Graph Algorithms
+
+NetworkX provides extensive algorithms for network analysis:
+
+**Shortest Paths**:
+```python
+# Find shortest path
+path = nx.shortest_path(G, source=1, target=5)
+length = nx.shortest_path_length(G, source=1, target=5, weight='weight')
+```
+
+**Centrality Measures**:
+```python
+# Degree centrality
+degree_cent = nx.degree_centrality(G)
+
+# Betweenness centrality
+betweenness = nx.betweenness_centrality(G)
+
+# PageRank
+pagerank = nx.pagerank(G)
+```
+
+**Community Detection**:
+```python
+from networkx.algorithms import community
+
+# Detect communities
+communities = community.greedy_modularity_communities(G)
+```
+
+**Connectivity**:
+```python
+# Check connectivity
+is_connected = nx.is_connected(G)
+
+# Find connected components
+components = list(nx.connected_components(G))
+```
+
+**Reference**: See `(see docs)` for detailed documentation on all available algorithms including shortest paths, centrality measures, clustering, community detection, flows, matching, tree algorithms, and graph traversal.
+
+### 3. Graph Generators
+
+Create synthetic networks for testing, simulation, or modeling:
+
+**Classic Graphs**:
+```python
+# Complete graph
+G = nx.complete_graph(n=10)
+
+# Cycle graph
+G = nx.cycle_graph(n=20)
+
+# Known graphs
+G = nx.karate_club_graph()
+G = nx.petersen_graph()
+```

package/skills/neurokit2/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: neurokit2
+description: Comprehensive biosignal processing toolkit for analyzing physiological data including ECG, EEG, EDA, RSP, PPG, EMG, and EOG signals. Use this skill when processing cardiovascular signals, brain activity, electrodermal responses, respiratory patterns, muscle activity, or eye movements. Applicable for heart rate variability analysis, event-related potentials, complexity measures, autonomic nervous system assessment, psychophysiology research, and multi-modal physiological signal integration.
+---
+
+# NeuroKit2
+
+## Overview
+
+NeuroKit2 is a comprehensive Python toolkit for processing and analyzing physiological signals (biosignals). Use this skill to process cardiovascular, neural, autonomic, respiratory, and muscular signals for psychophysiology research, clinical applications, and human-computer interaction studies.
+
+## When to Use This Skill
+
+Apply this skill when working with:
+- **Cardiac signals**: ECG, PPG, heart rate variability (HRV), pulse analysis
+- **Brain signals**: EEG frequency bands, microstates, complexity, source localization
+- **Autonomic signals**: Electrodermal activity (EDA/GSR), skin conductance responses (SCR)
+- **Respiratory signals**: Breathing rate, respiratory variability (RRV), volume per time
+- **Muscular signals**: EMG amplitude, muscle activation detection
+- **Eye tracking**: EOG, blink detection and analysis
+- **Multi-modal integration**: Processing multiple physiological signals simultaneously
+- **Complexity analysis**: Entropy measures, fractal dimensions, nonlinear dynamics
+
+## Core Capabilities
+
+### 1. Cardiac Signal Processing (ECG/PPG)
+
+Process electrocardiogram and photoplethysmography signals for cardiovascular analysis. See `(see docs)` for detailed workflows.
+
+**Primary workflows:**
+- ECG processing pipeline: cleaning → R-peak detection → delineation → quality assessment
+- HRV analysis across time, frequency, and nonlinear domains
+- PPG pulse analysis and quality assessment
+- ECG-derived respiration extraction
+
+**Key functions:**
+```python
+import neurokit2 as nk
+
+# Complete ECG processing pipeline
+signals, info = nk.ecg_process(ecg_signal, sampling_rate=1000)
+
+# Analyze ECG data (event-related or interval-related)
+analysis = nk.ecg_analyze(signals, sampling_rate=1000)
+
+# Comprehensive HRV analysis
+hrv = nk.hrv(peaks, sampling_rate=1000)  # Time, frequency, nonlinear domains
+```
+
+### 2. Heart Rate Variability Analysis
+
+Compute comprehensive HRV metrics from cardiac signals. See `(see docs)` for all indices and domain-specific analysis.
+
+**Supported domains:**
+- **Time domain**: SDNN, RMSSD, pNN50, SDSD, and derived metrics
+- **Frequency domain**: ULF, VLF, LF, HF, VHF power and ratios
+- **Nonlinear domain**: Poincaré plot (SD1/SD2), entropy measures, fractal dimensions
+- **Specialized**: Respiratory sinus arrhythmia (RSA), recurrence quantification analysis (RQA)
+
+**Key functions:**
+```python
+# All HRV indices at once
+hrv_indices = nk.hrv(peaks, sampling_rate=1000)
+
+# Domain-specific analysis
+hrv_time = nk.hrv_time(peaks)
+hrv_freq = nk.hrv_frequency(peaks, sampling_rate=1000)
+hrv_nonlinear = nk.hrv_nonlinear(peaks, sampling_rate=1000)
+hrv_rsa = nk.hrv_rsa(peaks, rsp_signal, sampling_rate=1000)
+```
+
+### 3. Brain Signal Analysis (EEG)
+
+Analyze electroencephalography signals for frequency power, complexity, and microstate patterns. See `(see docs)` for detailed workflows and MNE integration.
+
+**Primary capabilities:**
+- Frequency band power analysis (Delta, Theta, Alpha, Beta, Gamma)
+- Channel quality assessment and re-referencing
+- Source localization (sLORETA, MNE)
+- Microstate segmentation and transition dynamics
+- Global field power and dissimilarity measures
+
+**Key functions:**
+```python
+# Power analysis across frequency bands
+power = nk.eeg_power(eeg_data, sampling_rate=250, channels=['Fz', 'Cz', 'Pz'])
+
+# Microstate analysis
+microstates = nk.microstates_segment(eeg_data, n_microstates=4, method='kmod')
+static = nk.microstates_static(microstates)
+dynamic = nk.microstates_dynamic(microstates)
+```
+
+### 4. Electrodermal Activity (EDA)
+
+Process skin conductance signals for autonomic nervous system assessment. See `(see docs)` for detailed workflows.
+
+**Primary workflows:**
+- Signal decomposition into tonic and phasic components
+- Skin conductance response (SCR) detection and analysis
+- Sympathetic nervous system index calculation
+- Autocorrelation and changepoint detection
+
+**Key functions:**
+```python
+# Complete EDA processing
+signals, info = nk.eda_process(eda_signal, sampling_rate=100)
+
+# Analyze EDA data
+analysis = nk.eda_analyze(signals, sampling_rate=100)
+
+# Sympathetic nervous system activity
+sympathetic = nk.eda_sympathetic(signals, sampling_rate=100)
+```

package/skills/neuropixels-analysis/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: neuropixels-analysis
+description: Neuropixels neural recording analysis. Load SpikeGLX/OpenEphys data, preprocess, motion correction, Kilosort4 spike sorting, quality metrics, Allen/IBL curation, AI-assisted visual analysis, for Neuropixels 1.0/2.0 extracellular electrophysiology. Use when working with neural recordings, spike sorting, extracellular electrophysiology, or when the user mentions Neuropixels, SpikeGLX, Open Ephys, Kilosort, quality metrics, or unit curation.
+---
+
+# Neuropixels Data Analysis
+
+## Overview
+
+Comprehensive toolkit for analyzing Neuropixels high-density neural recordings using current best practices from SpikeInterface, Allen Institute, and International Brain Laboratory (IBL). Supports the full workflow from raw data to publication-ready curated units.
+
+## When to Use This Skill
+
+This skill should be used when:
+- Working with Neuropixels recordings (.ap.bin, .lf.bin, .meta files)
+- Loading data from SpikeGLX, Open Ephys, or NWB formats
+- Preprocessing neural recordings (filtering, CAR, bad channel detection)
+- Detecting and correcting motion/drift in recordings
+- Running spike sorting (Kilosort4, SpykingCircus2, Mountainsort5)
+- Computing quality metrics (SNR, ISI violations, presence ratio)
+- Curating units using Allen/IBL criteria
+- Creating visualizations of neural data
+- Exporting results to Phy or NWB
+
+## Quick Start
+
+### Basic Import and Setup
+
+```python
+import spikeinterface.full as si
+import neuropixels_analysis as npa
+
+# Configure parallel processing
+job_kwargs = dict(n_jobs=-1, chunk_duration='1s', progress_bar=True)
+```
+
+### Loading Data
+
+```python
+# SpikeGLX (most common)
+recording = si.read_spikeglx('/path/to/data', stream_id='imec0.ap')
+
+# Open Ephys (common for many labs)
+recording = si.read_openephys('/path/to/Record_Node_101/')
+
+# Check available streams
+streams, ids = si.get_neo_streams('spikeglx', '/path/to/data')
+print(streams)  # ['imec0.ap', 'imec0.lf', 'nidq']
+
+# For testing with subset of data
+recording = recording.frame_slice(0, int(60 * recording.get_sampling_frequency()))
+```
+
+### Complete Pipeline (One Command)
+
+```python
+# Run full analysis pipeline
+results = npa.run_pipeline(
+    recording,
+    output_dir='output/',
+    sorter='kilosort4',
+    curation_method='allen',
+)
+
+# Access results
+sorting = results['sorting']
+metrics = results['metrics']
+labels = results['labels']
+```
+
+## Standard Analysis Workflow
+
+### 1. Preprocessing
+
+```python
+# Recommended preprocessing chain
+rec = si.highpass_filter(recording, freq_min=400)
+rec = si.phase_shift(rec)  # Required for Neuropixels 1.0
+bad_ids, _ = si.detect_bad_channels(rec)
+rec = rec.remove_channels(bad_ids)
+rec = si.common_reference(rec, operator='median')
+
+# Or use our wrapper
+rec = npa.preprocess(recording)
+```
+
+### 2. Check and Correct Drift
+
+```python
+# Check for drift (always do this!)
+motion_info = npa.estimate_motion(rec, preset='kilosort_like')
+npa.plot_drift(rec, motion_info, output='drift_map.png')
+
+# Apply correction if needed
+if motion_info['motion'].max() > 10:  # microns
+    rec = npa.correct_motion(rec, preset='nonrigid_accurate')
+```
+
+### 3. Spike Sorting
+
+```python
+# Kilosort4 (recommended, requires GPU)
+sorting = si.run_sorter('kilosort4', rec, folder='ks4_output')
+
+# CPU alternatives
+sorting = si.run_sorter('tridesclous2', rec, folder='tdc2_output')
+sorting = si.run_sorter('spykingcircus2', rec, folder='sc2_output')
+sorting = si.run_sorter('mountainsort5', rec, folder='ms5_output')
+
+# Check available sorters
+print(si.installed_sorters())
+```

package/skills/nilearn/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: nilearn
+description: Neuroimaging data analysis and brain statistical maps. Use when working with fMRI, structural MRI, brain parcellation, connectivity matrices, or neuroimaging statistical analysis. Trigger on imports of nilearn, nibabel, or mentions of neuroimaging, fMRI, brain, voxel, cortical surface, MNI coordinates.
+---
+# nilearn
+
+Use this skill for neuroimaging data analysis.
+
+## Core patterns
+
+- **Load**: `nilearn.image.load_img('brain.nii.gz')` → `img.get_fdata()`.
+- **Masking**: `NiftiMasker(mask_img='mask.nii.gz', standardize=True).fit_transform(img)`.
+- **Parcellation**: `datasets.fetch_atlas_harvard_oxford()` for brain region labels.
+- **Connectivity**: `ConnectivityMeasure(kind='correlation').fit_extract(timeseries)`.
+- **Plotting**: `plotting.plot_stat_map(stat_img, threshold=3.0)` for activation maps.
+
+## Rules
+
+- Always register images to same space (MNI152) before comparing.
+- Use `NiftiMasker` for extracting voxel signals — handles masking and standardization.
+- Smooth data before GLM analysis: `image.smooth_img(img, fwhm=6)`.
+
+## Anti-patterns
+
+- Don't compare brain images across subjects without normalization.
+- Don't interpret correlation matrices without multiple comparison correction.
+- Don't load 4D fMRI entirely into float64 — use `dtype='auto'`.
+
+

package/skills/observability-reliability/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: observability-reliability
+description: Metrics, diagnostics, correlation, retry, deadletter, and recovery evidence workflow. Use when adding reliability features or investigating failures.
+---
+
+
+# observability-reliability
+
+Use this skill for reliability and observability work.
+
+## Source patterns distilled
+
+- `src/observability/*` — metric registry, retention, sinks, exporters, event-to-metric mapping
+- `src/runtime/retry-executor.ts`, `deadletter.ts`, `diagnostic-export.ts`, `recovery-recipes.ts`, `overflow-recovery.ts`, `heartbeat-gradient.ts`
+- `docs/research-phase9-observability-reliability-plan.md`
+
+## Rules
+
+- Metrics should be per-session/per-registry where possible; avoid hidden global singletons.
+- Use low-cardinality labels. Avoid raw task titles, prompts, full file paths, or secrets in metric labels.
+- Redact secrets before writing logs, events, diagnostics, agent output, or exported bundles.
+- Correlate events with runId/taskId and timestamps; include enough context for postmortem without exposing secrets.
+- Retry should record attempts and deadletter on exhaustion; default auto-retry should remain conservative.
+- Diagnostics should be safe to share: include state summary, recent events, metrics snapshot when available, and paths to artifacts.
+- Heartbeat classification should be threshold-based and should ignore terminal tasks/runs.
+- Overflow recovery should track phase progression and terminal states without repeatedly alerting on completed work.
+
+## Anti-patterns
+
+- High-cardinality Prometheus labels.
+- Emitting duplicate noisy health notifications every render tick.
+- Writing unredacted Authorization/API key/token values into events or artifacts.
+- Treating secondary metrics as primary pass/fail unless catastrophic.
+
+## Verification
+
+```bash
+cd pi-crew
+npx tsc --noEmit
+node --experimental-strip-types --test test/unit/metric-registry.test.ts test/unit/event-to-metric.test.ts test/unit/diagnostic-export.test.ts test/unit/retry-executor.test.ts test/unit/deadletter.test.ts
+npm test
+```
+

package/skills/omc-doctor/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: omc-doctor
+description: Diagnose and fix oh-my-claudecode installation issues
+---
+
+
+# Doctor Skill
+
+Note: All `~/.claude/...` paths in this guide respect `CLAUDE_CONFIG_DIR` when that environment variable is set.
+
+## Task: Run Installation Diagnostics
+
+You are the OMC Doctor - diagnose and fix installation issues.
+
+### Step 1: Check Plugin Version
+
+```bash
+# Get installed and latest versions (cross-platform)
+node -e "const p=require('path'),f=require('fs'),h=require('os').homedir(),d=process.env.CLAUDE_CONFIG_DIR||p.join(h,'.claude'),b=p.join(d,'plugins','cache','omc','oh-my-claudecode');try{const v=f.readdirSync(b).filter(x=>/^\d/.test(x)).sort((a,c)=>a.localeCompare(c,void 0,{numeric:true}));console.log('Installed:',v.length?v[v.length-1]:'(none)')}catch{console.log('Installed: (none)')}"
+npm view oh-my-claude-sisyphus version 2>/dev/null || echo "Latest: (unavailable)"
+```
+
+**Diagnosis**:
+- If no version installed: CRITICAL - plugin not installed
+- If INSTALLED != LATEST: WARN - outdated plugin
+- If multiple versions exist: WARN - stale cache
+
+### Step 2: Check for Legacy Hooks in settings.json
+
+Read both `${CLAUDE_CONFIG_DIR:-~/.claude}/settings.json` (profile-level) and `./.claude/settings.json` (project-level) and check if there's a `"hooks"` key with entries like:
+- `bash ${CLAUDE_CONFIG_DIR:-$HOME/.claude}/hooks/keyword-detector.sh`
+- `bash ${CLAUDE_CONFIG_DIR:-$HOME/.claude}/hooks/persistent-mode.sh`
+- `bash ${CLAUDE_CONFIG_DIR:-$HOME/.claude}/hooks/session-start.sh`
+
+**Diagnosis**:
+- If found: CRITICAL - legacy hooks causing duplicates
+
+### Step 3: Check for Legacy Bash Hook Scripts
+
+```bash
+ls -la "${CLAUDE_CONFIG_DIR:-$HOME/.claude}"/hooks/*.sh 2>/dev/null
+```
+
+**Diagnosis**:
+- If `keyword-detector.sh`, `persistent-mode.sh`, `session-start.sh`, or `stop-continuation.sh` exist: WARN - legacy scripts (can cause confusion)
+
+### Step 4: Check CLAUDE.md
+
+```bash
+# Check if CLAUDE.md exists
+ls -la "${CLAUDE_CONFIG_DIR:-$HOME/.claude}"/CLAUDE.md 2>/dev/null
+
+# Check for OMC markers (<!-- OMC:START --> is the canonical marker)
+grep -q "<!-- OMC:START -->" "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/CLAUDE.md" 2>/dev/null && echo "Has OMC config" || echo "Missing OMC config in CLAUDE.md"
+
+# Check CLAUDE.md (or deterministic companion) version marker and compare with latest installed plugin cache version
+node -e "const p=require('path'),f=require('fs'),h=require('os').homedir(),d=process.env.CLAUDE_CONFIG_DIR||p.join(h,'.claude');const base=p.join(d,'CLAUDE.md');let baseContent='';try{baseContent=f.readFileSync(base,'utf8')}catch{};let candidates=[base];let referenced='';const importMatch=baseContent.match(/CLAUDE-[^ )]*\\.md/);if(importMatch){referenced=p.join(d,importMatch[0]);candidates.push(referenced)}else{const defaultCompanion=p.join(d,'CLAUDE-omc.md');if(f.existsSync(defaultCompanion))candidates.push(defaultCompanion);try{const others=f.readdirSync(d).filter(n=>/^CLAUDE-.*\\.md$/i.test(n)).sort().map(n=>p.join(d,n));for(const o of others){if(candidates.includes(o)===false)candidates.push(o)}}catch{}};let claudeV='(missing)';let claudeSource='(none)';for(const file of candidates){try{const c=f.readFileSync(file,'utf8');const m=c.match(/<!--\\s*OMC:VERSION:([^\\s]+)\\s*-->/i);if(m){claudeV=m[1];claudeSource=file;break}}catch{}};if(claudeV==='(missing)'&&candidates.length>0){claudeV='(missing marker)';claudeSource='scanned deterministic CLAUDE sources';};let pluginV='(none)';try{const b=p.join(d,'plugins','cache','omc','oh-my-claudecode');const v=f.readdirSync(b).filter(x=>/^\\d/.test(x)).sort((a,c)=>a.localeCompare(c,void 0,{numeric:true}));pluginV=v.length?v[v.length-1]:'(none)';}catch{};console.log('CLAUDE.md OMC version:',claudeV);console.log('OMC version source:',claudeSource);console.log('Latest cached plugin version:',pluginV);if(claudeV==='(missing)'||claudeV==='(missing marker)'||pluginV==='(none)'){console.log('VERSION CHECK SKIPPED: missing CLAUDE marker or plugin cache')}else if(claudeV===pluginV){console.log('VERSION MATCH: CLAUDE and plugin cache are aligned')}else{console.log('VERSION DRIFT: CLAUDE.md and plugin versions differ')}"
+
+# Check companion files for file-split pattern (e.g. CLAUDE-omc.md)
+find "${CLAUDE_CONFIG_DIR:-$HOME/.claude}" -maxdepth 1 -type f -name 'CLAUDE-*.md' -print 2>/dev/null
+while IFS= read -r f; do
+  grep -q "<!-- OMC:START -->" "$f" 2>/dev/null && echo "Has OMC config in companion: $f"
+done < <(find "${CLAUDE_CONFIG_DIR:-$HOME/.claude}" -maxdepth 1 -type f -name 'CLAUDE-*.md' -print 2>/dev/null)
+
+# Check if CLAUDE.md references a companion file
+grep -o "CLAUDE-[^ )]*\.md" "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/CLAUDE.md" 2>/dev/null
+```
+
+**Diagnosis**:
+- If CLAUDE.md missing: CRITICAL - CLAUDE.md not configured
+- If `<!-- OMC:START -->` found in CLAUDE.md: OK
+- If `<!-- OMC:START -->` found in a companion file (e.g. `CLAUDE-omc.md`): OK - file-split pattern detected
+- If no OMC markers in CLAUDE.md or any companion file: WARN - outdated CLAUDE.md
+- If `OMC:VERSION` marker is missing from deterministic CLAUDE source scan (base + referenced companion): WARN - cannot verify CLAUDE.md freshness
+- If `CLAUDE.md OMC version` != `Latest cached plugin version`: WARN - version drift detected (run `omc update` or `omc setup`)
+
+### Step 5: Check Ralph Ruby Dependency
+
+Ralph workflows require Ruby. Check for Ruby explicitly so fresh installations get actionable guidance instead of a later opaque Ralph failure.
+
+```bash
+if command -v ruby >/dev/null 2>&1; then
+  echo "Ruby for Ralph: $(ruby --version 2>/dev/null | head -1)"
+else
+  echo "Ruby for Ralph: MISSING"
+```

package/skills/omc-reference/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: omc-reference
+description: OMC agent catalog, available tools, team pipeline routing, commit protocol, and skills registry. Auto-loads when delegating to agents, using OMC tools, orchestrating teams, making commits, or invoking skills.
+---
+
+# OMC Reference
+
+Use this built-in reference when you need detailed OMC catalog information that does not need to live in every `CLAUDE.md` session.
+
+## Agent Catalog
+
+Prefix: `oh-my-claudecode:`. See `agents/*.md` for full prompts.
+
+- `explore` (haiku) — fast codebase search and mapping
+- `analyst` (opus) — requirements clarity and hidden constraints
+- `planner` (opus) — sequencing and execution plans
+- `architect` (opus) — system design, boundaries, and long-horizon tradeoffs
+- `debugger` (sonnet) — root-cause analysis and failure diagnosis
+- `executor` (sonnet) — implementation and refactoring
+- `verifier` (sonnet) — completion evidence and validation
+- `tracer` (sonnet) — trace gathering and evidence capture
+- `security-reviewer` (sonnet) — trust boundaries and vulnerabilities
+- `code-reviewer` (opus) — comprehensive code review
+- `test-engineer` (sonnet) — testing strategy and regression coverage
+
+## Model Routing
+
+- `haiku` — quick lookups, lightweight inspection, narrow docs work
+- `sonnet` — standard implementation, debugging, and review
+- `opus` — architecture, deep analysis, consensus planning, and high-risk review
+
+## Tools Reference
+
+### External AI / orchestration
+- `/team N:executor "task"`
+- `omc team N:codex|gemini "..."`
+- `omc ask <claude|codex|gemini>`
+- `/ccg`
+
+### OMC state
+- `state_read`, `state_write`, `state_clear`, `state_list_active`, `state_get_status`
+
+### Team runtime
+- `TeamCreate`, `TeamDelete`, `SendMessage`, `TaskCreate`, `TaskList`, `TaskGet`, `TaskUpdate`
+
+### Notepad
+- `notepad_read`, `notepad_write_priority`, `notepad_write_working`, `notepad_write_manual`
+
+### Project memory
+- `project_memory_read`, `project_memory_write`, `project_memory_add_note`, `project_memory_add_directive`
+
+### Code intelligence
+- LSP: `lsp_hover`, `lsp_goto_definition`, `lsp_find_references`, `lsp_diagnostics`, and related helpers
+- AST: `ast_grep_search`, `ast_grep_replace`
+- Utility: `python_repl`
+
+## Skills Registry
+
+Invoke built-in workflows via `/oh-my-claudecode:`.
+
+### Workflow skills
+- `autopilot` — full autonomous execution from idea to working code
+- `ralph` — persistence loop until completion with verification
+- `ultrawork` — high-throughput parallel execution
+- `visual-verdict` — structured visual QA verdicts
+- `team` — coordinated team orchestration
+- `ccg` — Codex + Gemini + Claude synthesis lane
+- `ultraqa` — QA cycle: test, verify, fix, repeat
+- `omc-plan` — planning workflow and `/plan`-safe alias
+- `ralplan` — consensus planning workflow
+- `sciomc` — science/research workflow
+- `external-context` — external docs/research workflow
+- `deepinit` — hierarchical AGENTS.md generation
+- `deep-interview` — Socratic ambiguity-gated requirements workflow
+- `ai-slop-cleaner` — regression-safe cleanup workflow
+
+### Utility skills
+- `ask`, `cancel`, `note`, `skillify`, `learner` (deprecated alias), `omc-setup`, `mcp-setup`, `hud`, `omc-doctor`, `trace`, `release`, `project-session-manager`, `skill`, `writer-memory`, `configure-notifications`
+
+### Keyword triggers kept compact in CLAUDE.md
+- `"autopilot"→autopilot`
+- `"ralph"→ralph`
+- `"ulw"→ultrawork`
+- `"ccg"→ccg`
+- `"ralplan"→ralplan`
+- `"deep interview"→deep-interview`
+- `"deslop" / "anti-slop"→ai-slop-cleaner`
+- `"deep-analyze"→analysis mode`
+- `"tdd"→TDD mode`
+- `"deepsearch"→codebase search`
+- `"ultrathink"→deep reasoning`
+- `"cancelomc"→cancel`
+- Team orchestration is explicit via `/team`.
+
+## Team Pipeline
+
+Stages: `team-plan` → `team-prd` → `team-exec` → `team-verify` → `team-fix` (loop).
+
+- Use `team-fix` for bounded remediation loops.
+- `team ralph` links the team pipeline with Ralph-style sequential verification.
+- Prefer team mode when independent parallel lanes justify the coordination overhead.
+
+## Commit Protocol
+
+Use git trailers to preserve decision context in every commit message.
+
+### Format
+- Intent line first: why the change was made
+- Optional body with context and rationale
+- Structured trailers when applicable
+
+### Common trailers
+- `Constraint:` active constraint shaping the decision
+- `Rejected:` alternative considered | reason for rejection
+- `Directive:` forward-looking warning or instruction
+- `Confidence:` `high` | `medium` | `low`
+- `Scope-risk:` `narrow` | `moderate` | `broad`
+
+