Intelligent skill router that analyzes user requests and automatically dispatches to the most appropriate skill(s) or zen-mcp tools...
This skill serves as the central intelligence hub that analyzes user requests and automatically routes them to the most appropriate skill(s) for execution. It acts as a smart dispatcher, understanding user intent and orchestrating the right tools for the job.
Core Capabilities:
Division of Responsibilities:
Standards Compliance:
Active Task Monitoring (CRITICAL - Router Must Not Be Lazy):
Main Router MUST actively monitor the entire task lifecycle and proactively invoke appropriate skills at each stage. Do NOT skip skill invocations to save time - proper skill usage ensures quality and compliance.
Mandatory Workflow Rules:
Planning Phase:
Code Generation → Quality Check Cycle:
Test Code Generation Workflow:
Documentation Generation:
Continuous Monitoring:
Anti-Pattern - Router Being Lazy (FORBIDDEN):
BAD: Main Claude generates code → Main Claude self-reviews → Done
GOOD: Main Claude generates code → Router invokes codex-code-reviewer → Done
BAD: Main Claude writes plan.md directly
GOOD: Router invokes plan-down skill → plan.md generated with validation
BAD: Main Claude generates tests → Run immediately
GOOD: Router invokes simple-gemini → codex validates → Main Claude runs
Use this skill PROACTIVELY for ALL user requests to determine the best execution path.
Typical User Requests:
Router's Decision Process:
User Request → Read Standards (CLAUDE.md) → Intent Analysis → Skill Matching → Auto/Manual Decision → Execution
Operation Modes:
Interactive Mode (Default):
Full Automation Mode (automation_mode - READ FROM SSOT):
automation_mode definition and constraints: See CLAUDE.md「📚 共享概念速查」
This skill's role (Router Layer - Sole Source):
[AUTOMATION_MODE: true/false]Purpose: General Q&A and collaborative thinking partner
Triggers:
Use Cases:
Key Features:
Tool: mcp__zen__chat (direct invocation, not a packaged skill)
Purpose: Multi-stage investigation and reasoning for complex problem analysis
Triggers:
Use Cases:
Key Features:
Tool: mcp__zen__thinkdeep (direct invocation, not a packaged skill)
Purpose: Code quality review with iterative fix-and-recheck cycles
Triggers:
Use Cases:
Key Features:
Tool: mcp__zen__codereview
Purpose: Standard documentation and test code generation
Triggers:
Use Cases:
Key Features:
Tool: mcp__zen__clink (launches gemini CLI in WSL)
Purpose: Deep technical analysis documents with complexity evaluation
Triggers:
Use Cases:
Key Features:
Tools: mcp__zen__clink + mcp__zen__docgen
docgen workflow:
Purpose: Intelligent planning with task decomposition and multi-model validation
CRITICAL: This skill is MANDATORY for all plan.md generation tasks
Triggers:
Use Cases:
Key Features:
Tools: mcp__zen__chat (Phase 0 method clarity judgment) + mcp__zen__planner + mcp__zen__consensus (conditional - only for Automatic + Unclear path) + mcp__zen__clink (when using consensus with codex/gemini)
Model Support (G10 Compliance - CRITICAL):
mcp__zen__clink to establish CLI session first (otherwise 401 error)references/standards/cli_env_g10.mdEnforcement:
IF user requests planning OR plan.md generation:
MUST route to plan-down
NEVER allow Main Claude to create plan.md directly
Reason: plan-down provides superior planning quality through:
- Multi-stage interactive planning
- Multi-model consensus validation
- Standards compliance verification
- Risk assessment and dependency analysis
Purpose: Frontend and mobile development specialist using Gemini CLI with multimodal capabilities
适用场景：
Triggers:
Core Advantages (Based on Gemini 3.0):
Use Cases:
Key Features:
automation_mode and coverage_target from routerTools: mcp__zen__clink (gemini CLI) + mcp__zen__codereview + simple-gemini
Frontend Detection Scoring:
Routing Thresholds:
Enforcement:
IF frontend_score ≥ 80:
Auto-route to gemini-frontend (high confidence)
IF 50 ≤ frontend_score < 80:
Ask user: "检测到前端开发需求，是否使用 gemini-frontend?"
IF frontend_score < 50 AND backend_signals ≥ 2:
Notify user: "检测到全栈项目，建议任务分解：
- 前端部分 → gemini-frontend
- 后端部分 → codex-code-reviewer 或其他技能"
Detailed Examples:
Main Router's Action:
Before ANY routing decision, MUST complete the following two sub-phases:
Read the following files to understand project-specific rules and workflows:
a) Read Global Standards:
/home/vc/.claude/CLAUDE.mdb) Read Project-Specific Standards (if exist):
./CLAUDE.md (current directory)Standards Priority Hierarchy (when conflicts):
核心原则：不假设任何 MCP 工具"一定存在"，运行时动态检测并智能适配。
检测时机：
检测方法：
# 伪代码示例 - 动态 MCP 能力检测
mcp_capabilities = {} # 会话级缓存
def detect_mcp_availability():
"""运行时检测 MCP 工具可用性"""
# 1. 检测 zen-mcp
try:
version_info = call_tool("mcp__zen__version")
mcp_capabilities["zen-mcp"] = {
"available": True,
"version": version_info.get("version"),
"tools": extract_available_tools(version_info)
}
except Exception:
mcp_capabilities["zen-mcp"] = {"available": False}
# 2. 检测 serena-mcp（代码智能）
try:
config = call_tool("mcp__serena__get_current_config")
mcp_capabilities["serena-mcp"] = {
"available": True,
"tools": list_serena_tools()
}
except Exception:
mcp_capabilities["serena-mcp"] = {"available": False}
# 3. 检测 unifuncs-mcp（工具函数）
try:
search_test = call_tool("mcp__unifuncs__web-search", {"query": "test", "count": 1})
mcp_capabilities["unifuncs-mcp"] = {"available": True}
except Exception:
mcp_capabilities["unifuncs-mcp"] = {"available": False}
# 4. 检测其他 MCP（用户自定义）
# 可通过 ListMcpResourcesTool 发现额外 MCP 服务器
return mcp_capabilities
技能与 MCP 工具的依赖分为三类：
动态依赖映射表：
| Skill | 必需工具 | 增强工具 | 降级方案 |
|---|---|---|---|
| zen-chat | mcp__zen__chat | mcp__zen__apilookup mcp__unifuncs__web-search |
降级到主模型直接回答（无多轮协作） |
| zen-thinkdeep | mcp__zen__thinkdeep | mcp__serena__* (代码分析) mcp__zen__debug |
降级到主模型单轮深度分析 |
| codex-code-reviewer | mcp__zen__codereview 或 mcp__zen__clink (codex CLI) |
mcp__serena__* (符号编辑) mcp__zen__precommit |
使用主模型 + Read/Edit 工具进行审查 |
| simple-gemini | mcp__zen__clink (gemini CLI) | mcp__serena__* (代码读取) mcp__unifuncs__web-reader |
降级到主模型直接生成文档/测试 |
| deep-gemini | mcp__zen__clink (gemini CLI) mcp__zen__docgen |
mcp__serena__* (代码分析) mcp__zen__apilookup |
降级到主模型深度分析 |
| plan-down | mcp__zen__chat (方法判断) mcp__zen__planner (任务分解) |
mcp__zen__consensus (自动化模式) mcp__serena__read_memory (项目上下文) mcp__zen__clink (codex/gemini CLI) |
降级到主模型直接规划 |
| gemini-frontend | mcp__zen__clink (gemini CLI) | mcp__serena__* (代码分析) mcp__unifuncs__web-reader (设计参考) |
降级到主模型前端开发 |
G10 合规特殊要求：
mcp__zen__clink 建立 CLI 会话适配原则：
用户显式指定 MCP 工具时：
Router 自动选择技能时：
降级决策树：
IF 技能必需工具全部可用:
→ 正常路由到该技能（最优方案）
ELSE IF 技能必需工具部分缺失:
→ 检查降级方案是否可行
IF 降级方案可行:
→ 使用降级方案（通知用户，如果是显式请求）
ELSE:
→ 通知用户工具缺失，请求确认或提供替代方案
ELSE IF 仅增强工具缺失:
→ 正常路由，静默降级（不通知用户）
降级方案示例：
| 原方案 | 缺失工具 | 降级方案 | 通知用户？ |
|---|---|---|---|
| codex-code-reviewer | zen-mcp 完全不可用 | 主模型 + Read/Edit 工具审查 | ✅ 是（显著功能降级） |
| simple-gemini | clink 不可用 | 主模型直接生成文档 | ✅ 是（质量可能下降） |
| zen-chat | zen__apilookup 不可用 | 仅使用 zen__chat，无 API 查询 | ❌ 否（增强功能，非必需） |
| zen-thinkdeep | serena 不可用 | 使用 Read/Grep 工具代替代码分析 | ❌ 否（自动适配） |
示例 1：用户显式请求使用 codex
用户："use codex to check the code"
Router 执行：
1. 检测 zen-mcp 可用性
- IF zen-mcp 可用 → 路由到 codex-code-reviewer（使用 mcp__zen__codereview）
- IF zen-mcp 不可用但 clink 可用 → 路由到 codex-code-reviewer（使用 mcp__zen__clink + codex CLI）
- IF 两者都不可用 → 通知用户：
"检测到 zen-mcp 和 clink 均不可用。可以使用主模型进行代码审查（功能受限），是否继续？"
示例 2：Router 自动路由到 simple-gemini
Router 判断：需要生成 README 文档 → 路由到 simple-gemini
适配流程：
1. 检测 mcp__zen__clink 可用性
- IF 可用 → 正常调用 simple-gemini（使用 gemini CLI）
- IF 不可用 → 降级到主模型直接生成（通知用户："gemini CLI 不可用，使用主模型生成文档"）
2. 检测增强工具（serena, unifuncs）
- IF serena 可用 → 增强代码读取能力
- IF serena 不可用 → 使用 Read 工具（静默降级，不通知）
示例 3：全自动化模式下的 plan-down
Router 判断：P2 阶段，需要生成 plan.md → 路由到 plan-down
适配流程：
1. 检测必需工具（chat, planner）
- IF 全部可用 → 继续
- IF 任一缺失 → 降级到主模型直接规划（通知："plan-down 依赖工具缺失，使用主模型规划"）
2. 检测增强工具（consensus, clink）
- IF automation_mode=true 且方法模糊 → 需要 consensus
- consensus 可用 → 正常多模型验证
- consensus 不可用 → 降级到单模型规划（通知："多模型验证不可用，使用单模型规划"）
- IF consensus 需要 codex/gemini → 检测 clink
- clink 可用 → 符合 G10，建立 CLI 会话
- clink 不可用 → 跳过 consensus（静默降级）
缓存策略：
缓存数据结构：
# 示例缓存结构
mcp_status_cache = {
"zen-mcp": {
"available": True,
"last_check": "2025-11-19T11:30:00Z",
"tools": ["chat", "thinkdeep", "codereview", "clink", "planner", ...]
},
"serena-mcp": {
"available": True,
"last_check": "2025-11-19T11:30:00Z",
"tools": ["list_dir", "find_file", "search_for_pattern", ...]
},
"unifuncs-mcp": {
"available": False, # 用户未安装
"last_check": "2025-11-19T11:30:00Z",
"error": "Connection refused"
}
}
根据 CLAUDE.md 阶段和 MCP 可用性动态调整路由：
透明通知原则：
coverage_target definition and constraints: See CLAUDE.md「📚 共享概念速查」
This skill's role (Router Layer - Sole Setting Source):
[COVERAGE_TARGET: X%]These rules MUST be applied automatically at specific workflow points:
Rule 1: plan.md Generation → plan-down (MANDATORY)
Rule 2: Code Completed → codex-code-reviewer (MANDATORY)
Rule 3: Test Code Needed → Workflow (MANDATORY)
[COVERAGE_TARGET: X%])[COVERAGE_TARGET: X%])Rule 4: Documentation Needed → Skill-Based (MANDATORY)
Rule 5: P3 Code Changes → Document Linkage (MANDATORY)
Rule 6: P4 Error Fixed → Regression Gate (MANDATORY)
Anti-Lazy Principle:
Main Router's Action:
Analyze the user request to identify:
Primary Intent:
Request Characteristics:
Context Signals:
Decision Tree:
IF user asks general question ("explain", "what is", "how to understand"):
→ zen-chat
ELSE IF user requests deep problem analysis ("deep problem analysis", "investigate bug", "systematic analysis"):
→ zen-thinkdeep
ELSE IF user mentions "codex" OR "code check" OR "code review":
→ codex-code-reviewer
ELSE IF user mentions "gemini" AND ("documentation" OR "test"):
IF mentions "deep" OR "analysis" OR "architecture" OR "performance":
→ deep-gemini
ELSE:
→ simple-gemini
ELSE IF user mentions "planning" OR "plan" OR "roadmap":
→ plan-down
ELSE IF intent is "code review":
→ codex-code-reviewer
ELSE IF intent is "document generation":
IF document type in [README, PROJECTWIKI, CHANGELOG, test]:
→ simple-gemini
ELSE IF analysis type in [architecture, performance, code logic]:
→ deep-gemini
ELSE IF intent is "planning":
→ plan-down
ELSE IF intent is "Q&A" (no code/file operations):
→ zen-chat
ELSE:
→ Main Claude (direct execution, no skill routing)
Confidence Scoring:
For each tool/skill, calculate confidence score (0-100):
confidence_scores = {
"zen-chat": calculate_qa_confidence(request),
"zen-thinkdeep": calculate_deep_investigation_confidence(request),
"codex-code-reviewer": calculate_code_review_confidence(request),
"simple-gemini": calculate_simple_doc_confidence(request),
"deep-gemini": calculate_deep_analysis_confidence(request),
"plan-down": calculate_planning_confidence(request)
}
# Interactive Mode (Default)
if max(confidence_scores.values()) >= 60:
selected_tool = max(confidence_scores, key=confidence_scores.get)
else:
# Ambiguous - ask user for clarification
ask_user_to_clarify()
# Full Automation Mode (if user requested)
if automation_mode_enabled:
if max(confidence_scores.values()) >= 50: # Lower threshold
selected_tool = max(confidence_scores, key=confidence_scores.get)
log_auto_decision(selected_tool, confidence_scores)
else:
# Fallback to Main Claude
selected_tool = "main_claude"
Single Skill Execution:
User Request → Analyze → Match to Skill X → Invoke Skill X → Return Result
Multi-Skill Execution (Sequential):
Example: "Generate docs then check code"
1. Invoke simple-gemini (generate docs)
2. Wait for completion
3. Invoke codex-code-reviewer (check code)
4. Return combined results
Multi-Skill Execution (Parallel - if independent):
Example: "Generate plan and README simultaneously"
1. Invoke plan-down in parallel
2. Invoke simple-gemini in parallel
3. Wait for both to complete
4. Return combined results
When multiple skills could apply:
Option 1: Ask User (Interactive Mode)
Detected that your request can use the following skills:
1. simple-gemini - Generate standard documentation
2. deep-gemini - Generate deep analysis documentation
Please choose:
- Enter 1: Use simple-gemini (fast, standardized)
- Enter 2: Use deep-gemini (in-depth, includes complexity analysis)
Option 2: Auto-Select (Full Automation Mode)
CRITICAL: In Full Automation Mode, DO NOT ask user "continue?" or present choices
Activation: User explicitly requests "full automation"/"complete automation"/"automated process" in initial request
Behavior: Router and Main Claude make ALL decisions without user intervention
Forbidden Actions:
Correct Actions:
Decision Rules:
Exception - Only Ask User When:
Full Automation Mode Decision Template:
[Full Auto Mode - Auto Decision]
Detected: {task_description}
Auto-selected: {selected_tool}
Confidence: {confidence_score}%
Rationale: {rationale based on standards and intent}
Standards basis: {relevant CLAUDE.md rules}
Starting execution...
Main Router's Action:
User: "Help me check the just-generated code"
Router Internal Analysis:
- Keywords detected: "check", "code"
- Intent: Code review
- Target: Recently generated code
- Expected output: Quality report + fixes
Main Router's Action:
Part A: Standards Reading
Standards Reading:
a) Global CLAUDE.md (/home/vc/.claude/CLAUDE.md):
- G1: Documentation First-Class Citizen - code changes must synchronize doc updates
- G3: No Execution Permission Scenario - requires explicit user consent
- Current phase: P3 (Execute Solution) - just completed code generation
b) Global CLAUDE.md (/home/vc/.claude/CLAUDE.md):
- Code standards: Clear, readable
- Quality threshold: Coverage ≥ 70%
c) Project CLAUDE.md (./CLAUDE.md): [If exists]
- Project-specific rules
d) Project CLAUDE.md (./CLAUDE.md): [If exists]
- Model-specific requirements
Standards-Based Decision:
- P3 phase → Code review recommended after code changes (CLAUDE.md requirement)
- G1 rule → Must check if documentation was updated
- User approval needed before fixes (G3)
Part B: MCP Capability Reference (No Pre-check)
MCP Assumptions:
zen-mcp:
Status: Assumed AVAILABLE (default)
Tools: All 13 zen-mcp tools assumed ready
Strategy: Optimistic routing - verify on actual invocation
User-Mentioned MCPs:
Detection: Check if user explicitly mentioned MCP tools in request
Example triggers: "use serena", "use unifuncs to search", "call mcp__serena__find_symbol"
Status: Assumed AVAILABLE (if mentioned by user)
Strategy: Optimistic routing - honor user's explicit tool choice
Optional Enhancement MCPs:
serena: Can be discovered on-demand for code intelligence
unifuncs: Can be discovered on-demand for web capabilities
Strategy: Lazy discovery - only if needed for enhancement
Routing Decision for codex-code-reviewer:
Required: mcp__zen__codereview (assumed available )
Enhancement: serena tools (optional, will discover if needed)
User preference: None mentioned in this request
→ Decision: Proceed with codex-code-reviewer
Rationale: zen-mcp assumed available, no blocking issues
Main Router's Action:
Intent Classification:
- Primary Intent: Code review
- Secondary Intent: None
- Complexity: Standard (not deep analysis)
- Urgency: Normal
Context Signals:
- Git status shows modified files: src/features.py, src/model_training.py
- No explicit skill mentioned by user
- Recent activity: Code generation just completed
Standards Alignment:
- Matches P3 phase requirement for post-code-change review
- Aligns with G1 (need to verify doc updates)
Main Router's Action:
Skill Matching:
- codex-code-reviewer: 95% confidence
- Reason: Intent is code review, has modified files
- Standards support: P3 phase requirement
- zen-mcp: Assumed available (optimistic)
- simple-gemini: 10%
- zen-mcp: Assumed available
- deep-gemini: 15%
- zen-mcp: Assumed available
- plan-down: 5%
- zen-mcp: Assumed available
Decision: Route to codex-code-reviewer
Rationale: Highest confidence + Standards alignment
Note: zen-mcp availability assumed, will verify during execution
Main Router's Action:
Invoking: codex-code-reviewer
Parameters:
- Files to review: [src/features.py, src/model_training.py]
- Review type: full
- User approval: required
MCP Strategy:
Primary tools: zen-mcp (assumed available, no pre-check)
Enhancement tools: serena/unifuncs (can discover on-demand if needed)
Execution:
[codex-code-reviewer executes workflow using zen-mcp tools]
Error Handling (if zen-mcp fails):
1. Skill reports error to router
2. Router notifies user: "mcp__zen__codereview currently unavailable"
3. Router suggests fallback: Main Claude direct code review
4. User chooses: Continue with fallback OR troubleshoot MCP
Main Router's Action:
Code review completed (using codex-code-reviewer):
Review results:
- Reviewed files: 2
- Issues found: 3 (fixed)
- Review rounds: 2 / 5
Standards compliance check:
G1: Verified documentation updates (PROJECTWIKI.md, CHANGELOG.md)
G3: User authorization obtained before fixes
Quality threshold: Coverage reached 75% (exceeds 70% threshold)
Detailed report:
[codex-code-reviewer's output]
Note: For detailed routing examples with comprehensive Chinese descriptions and step-by-step decision processes, please refer to: references/routing_examples.md
The routing_examples.md file contains 14 complete examples demonstrating main-router's decision-making process:
Quick Reference - Example 1 (General Q&A):
User: "Explain what is overfitting in machine learning?"
Router Decision:
Intent: General Q&A
Keywords: "explain", "what is"
Target: Conceptual explanation
Output: Answer/explanation (no file operations)
→ Route to: zen-chat
Rationale:
- Pure conceptual question
- No file/code operations required
- Fast response with zen-chat is sufficient
- No need for complex analysis workflow
Active Monitoring (CRITICAL - Anti-Lazy Principle):
Keyword Detection:
Context Awareness:
Confidence Thresholds:
User Communication:
Error Handling:
Format:
[Decision Notification]
Detected task type: [Task Type]
Selected skill: [Skill Name]
Rationale: [Brief explanation]
Starting execution...
Example:
[Decision Notification]
Detected task type: Code quality review
Selected skill: codex-code-reviewer
Rationale: You requested code quality check, codex-code-reviewer provides comprehensive 5-dimensional review
Starting execution...
| User Intent | Primary Keywords | Selected Tool/Skill | Rationale |
|---|---|---|---|
| General Q&A | explain, what is, how to understand | zen-chat | General Q&A, no file ops |
| Deep Problem Investigation | deeply analyze problem, investigate bug, systematic analysis | zen-thinkdeep | Multi-stage investigation |
| Code Review | check, review, codex | codex-code-reviewer | Code quality validation |
| Standard Documentation | documentation, README, CHANGELOG, test | simple-gemini | Standard doc templates |
| Deep Technical Analysis | deep, analyze, architecture, performance, complexity | deep-gemini | Technical analysis + complexity |
| Planning | plan, planning, decompose | plan-down | Task decomposition + validation |
| Document Generation (Unclear) | generate document | Ask User | Ambiguous - need clarification |
Scenario: User request doesn't match any skill
Action:
Router Analysis:
- No skill confidence > 60%
- Request is outside skill scope
→ Decision: Execute directly with Main Claude
→ Notification: "This task will be handled directly by the main model (no specialized skill needed)"
Scenario: Multiple skills have similar confidence scores
Action:
Router Analysis:
- simple-gemini: 75%
- deep-gemini: 73%
- Difference < 10% → Ambiguous
→ Decision: Ask user to choose
→ Present both options with pros/cons
Scenario A: zen-mcp tool fails during skill execution (discovered at runtime)
Action:
Skill Execution Error:
- Skill: deep-gemini
- Failed MCP call: mcp__zen__docgen
- Error: "MCP tool not available" or "Connection failed"
Router Receives Error and Responds:
→ Notification to User:
"Issue encountered while executing deep-gemini:
mcp__zen__docgen is currently unavailable.
Available options:
1. Use simple-gemini (only requires mcp__zen__clink)
2. Main model generates document directly (no MCP enhancement)
3. Check zen-mcp service status and retry
Please choose (or enter 3 and use /mcp status to check)"
User Choice Handling:
- Choice 1 → Route to simple-gemini
- Choice 2 → Main Claude direct execution
- Choice 3 → Wait for user to troubleshoot, then retry
Note: This only happens when zen-mcp actually fails at runtime,
not during routing phase (optimistic assumption).
Scenario B: User-mentioned MCP tool fails at runtime
Action:
Direct MCP Invocation Error:
- User request: "Use serena's find_symbol to analyze code"
- Failed MCP call: mcp__serena__find_symbol
- Error: "MCP server 'serena' not found" or "Tool not available"
Router Receives Error and Responds:
→ Notification to User:
"Your specified MCP tool is currently unavailable:
mcp__serena__find_symbol
Error details: {error_details}
Available options:
1. Use zen-mcp's code analysis tool (mcp__zen__thinkdeep)
2. Main model reads code directly for analysis
3. Check serena MCP service status and retry (/mcp status)
Please choose handling method:"
User Choice Handling:
- Choice 1 → Route to zen-thinkdeep (alternative analysis)
- Choice 2 → Main Claude manual code reading
- Choice 3 → Wait for user to troubleshoot, then retry original request
Note: User-mentioned MCP tools are assumed available (optimistic),
but must provide clear error feedback if they fail at runtime.
Scenario: User explicitly requests a different skill
User: "Don't use codex, use gemini to analyze"
Action:
Router Analysis:
- Original selection: codex-code-reviewer
- User override: Use gemini (deep-gemini)
→ Decision: Respect user choice
→ Route to: deep-gemini
→ Notification: "Switched to deep-gemini (as per your request)"
Active Task Monitoring (HIGHEST PRIORITY - Anti-Lazy Principle):
Standards-First Approach: ALWAYS read CLAUDE.md before routing decisions
/home/vc/.claude/CLAUDE.md/home/vc/.claude/CLAUDE.md./CLAUDE.md (if exists)./CLAUDE.md (if exists)MCP-Aware Routing: Optimistic assumption with lazy verification
Proactive Usage: Main Router should be invoked for ALL task-related user requests
Standards Compliance: All routing decisions must align with documented rules
Interactive Mode (Default):
Full Automation Mode:
auto_log.md using simple-geminiTransparency: Always inform user which skill/tool was selected and why
Flexibility: Support user overrides and manual skill selection
Efficiency: Prefer simpler skills when ambiguous
Context-Aware: Consider project state, recent activity, git status, and CLAUDE.md phase
Multi-Skill Support: Handle sequential and parallel skill execution
Fallback Strategy: Graceful degradation on runtime failures
Continuous Improvement: Learn from user corrections and overrides
No Redundancy: Don't invoke router for meta-requests about the router itself
The router should NOT route these requests:
The router SHOULD route these requests:
