home / skills / zpankz / mcp-skillset / skills-router

skills-router skill

safe

This skill routes tasks to appropriate skills using semantic discovery across skill databases to accelerate accurate skill matching and task delegation.

npx playbooks add skill zpankz/mcp-skillset --skill skills-router

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

5.3 KB

---
name: skills-router
description: Routes tasks to skills in skill-db and skill-library using semantic discovery. Triggers on specialized skill requirements, domain-specific tasks, or explicit skill requests. Uses skill-discovery, mcp-skillset, and skill-rag-router for semantic matching.
---

# Skills Router

Routes tasks to appropriate skills using semantic discovery across skill databases.

## Skill Databases

| Database | Location | Count | Purpose |
|:---------|:---------|:------|:--------|
| **skill-db** | ~/.claude/skill-db/ | 67+ | Primary skill source |
| **skill-library** | ~/.claude/skill-library/ | 48+ | Heavy/categorized skills |
| **skills (active)** | ~/.claude/skills/ | Variable | Currently loaded skills |

## Skill Categories

### Reasoning Skills (skill-db)
| Skill | Triggers | Purpose |
|:------|:---------|:--------|
| `think` | think, analyze, mental-model | Cognitive enhancement |
| `reason` | decompose, understand, break-down | Recursive decomposition |
| `AoT` | prove, atomic, formal | Atom of Thoughts |
| `urf` | universal, multi-scale, complex | Universal Reasoning |
| `ontolog` | holarchic, holons, ontology | Holarchic reasoning |
| `telos` | physiology, biological, teleological | Teleological analysis |
| `qp` | quantitative, calculate, physiological | Quantitative physiology |

### Development Skills (skill-db)
| Skill | Triggers | Purpose |
|:------|:---------|:--------|
| `terminal` | tui, cli, terminal-ui | Terminal UI design |
| `component` | command, agent, config | Claude Code components |
| `mcp-builder` | mcp, server, protocol | MCP development |
| `dspy` | dspy, prompts, optimize | DSPy optimization |

### Research Skills (skill-db)
| Skill | Triggers | Purpose |
|:------|:---------|:--------|
| `deep-research` | research, thorough, citations | 7-phase research |
| `notebooklm` | notebook, query, audio | NotebookLM integration |
| `skill-discovery` | find skill, discover, browse | Skill discovery |

### Context Skills (skill-db)
| Skill | Triggers | Purpose |
|:------|:---------|:--------|
| `context-orchestrator` | context, lifelog, ltm, limitless, pieces | Three-CLI context extraction |
| `limitless-cli` | pendant, personal memory, graph sync, extraction pipeline | Limitless CLI project development |

### Heavy Skills (skill-library)
| Skill | Triggers | Purpose |
|:------|:---------|:--------|
| `dialectical` | persuade, thesis, synthesis | Dialectical writing |
| `critique` | evaluate, lens, adversarial | Multi-lens critique |
| `constraints` | deontic, rights, permissions | Formal constraints |
| `saq` | saq, exam, model-answer | SAQ generation |
| `mega` | complex, n-superhypergraph | Meta-architecture |
| `textbook-grounding` | textbook, citations, syntopical | Textbook grounding |

## Routing Logic

```bash
# Semantic skill search
ck --sem "{query}" ~/.claude/skill-db/ --top-k 5

# Skill discovery metasystem
# (Invokes skill-discovery skill)

# mcp-skillset (when available)
mcp-skillset search "{query}"
```

## Decision Tree

```
Skill Task Detected
    │
    ├── Reasoning/Thinking?
    │   ├── Cognitive? → think
    │   ├── Formal proof? → AoT
    │   ├── Decomposition? → reason
    │   └── Complex system? → urf | mega
    │
    ├── Development?
    │   ├── Terminal UI? → terminal
    │   ├── MCP server? → mcp-builder
    │   └── Claude component? → component
    │
    ├── Research?
    │   ├── Deep dive? → deep-research
    │   ├── Skill finding? → skill-discovery
    │   └── NotebookLM? → notebooklm
    │
    ├── Context Extraction?
    │   ├── Personal/lifelog? → context-orchestrator → limitless
    │   ├── Documentation? → context-orchestrator → research
    │   ├── Local code/LTM? → context-orchestrator → pieces
    │   └── Limitless CLI development? → limitless-cli
    │
    ├── Writing?
    │   ├── Persuasive? → dialectical
    │   ├── SAQ/Exam? → saq | textbook-grounding
    │   └── Critique? → critique
    │
    ├── Data/Graph?
    │   ├── Knowledge graph? → hkgb | ontolog
    │   ├── Batch processing? → process | obsidian-batch
    │   └── Graph reasoning? → mega | graph
    │
    └── Domain-specific?
        ├── Physiology? → telos | qp
        ├── Scientific? → rct-appraisal
        └── Code quality? → code-skills/*
```

## Skill Loading Protocol

```yaml
progressive_loading:
  level_0: Read SKILL.md frontmatter only
  level_1: Read full SKILL.md
  level_2: Load references/*.md
  level_3: Load scripts/ and full capability

load_triggers:
  - Explicit skill invocation
  - Semantic match > 0.7
  - Domain keyword match
  - User request
```

## Integration

- **skill-discovery**: Semantic skill search
- **skill-rag-router**: GraphRAG-based routing
- **mcp-skillset**: MCP skill discovery
- **ck**: Semantic code search for skill content

## Quick Reference

```yaml
# Find skill semantically
ck --sem "formal reasoning proof" ~/.claude/skill-db/

# Load skill progressively
1. Check skill-db/{skill}/SKILL.md
2. If not found, check skill-library/{skill}/SKILL.md
3. Load frontmatter, then full skill on demand

# Skill invocation
/skill_name or invoke via Skill tool
```

Overview

This skill routes tasks to the most appropriate capability across multiple skill stores using semantic discovery and rule-based heuristics. I prioritize domain signals, specialized triggers, and explicit skill requests to pick the best skill from skill-db, skill-library, or currently loaded skills. The goal is fast, accurate routing so downstream skills get precise, context-rich tasks.

How this skill works

I perform a semantic search over local skill indexes (skill-db, skill-library, active skills) and combine results with a metasystem (skill-discovery) and mcp-skillset when available. A decision tree maps task intent to categories (reasoning, development, research, context, writing, data, domain-specific) and selects candidate skills by trigger keywords and semantic similarity. Progressive loading fetches only the frontmatter first and loads full capability when match confidence or explicit invocation crosses thresholds.

When to use it

You have a specialized requirement and want the best-fit skill automatically discovered.
A task spans domains and you need semantic matching rather than manual selection.
You want to route tasks to heavyweight or niche skills from multiple local stores.
You need context-aware routing that considers progressive loading and cost.
You are invoking a skill explicitly and want the router to validate alternatives.

Best practices

Provide a concise task description with domain keywords to improve semantic matches.
Prefer explicit skill names when deterministic behavior is required.
Allow progressive loading for faster responses; escalate to full load only when needed.
Set a similarity threshold (e.g., 0.7) and review low-confidence matches before execution.
Combine this router with skill-rag-router for graph-backed retrieval on complex tasks.

Example use cases

Route a formal proof request to AoT or a complex-system analysis to urf/mega.
Find and invoke a terminal UI component skill when building a CLI feature.
Discover deep-research or notebooklm for long-form literature reviews.
Extract personal-lifelog context via context-orchestrator and onward to limitless-cli.
Choose a persuasive writing pipeline (dialectical) or exam-style SAQ generator.

FAQ

How does the router decide between multiple candidate skills?

It ranks candidates by semantic similarity, trigger keyword hits, and decision-tree heuristics; ties are resolved by match confidence and explicit user preference.

Can I force loading of a heavy skill immediately?

Yes—explicit invocation or raising the similarity threshold triggers full loading rather than progressive frontmatter-only loading.