name: smart-routing description: > Intelligent request routing for /toh command. Analyzes user intent, assesses confidence, detects IDE environment, and routes to the appropriate agent(s). Memory-first approach ensures context awareness. Triggers: /toh command, natural language requests, ambiguous inputs.

Smart Routing Skill

Intelligent routing engine for the /toh smart command. Routes any natural language request to the right agent(s).

🧠 Routing Pipeline

┌─────────────────────────────────────────────────────────────────┐
│                    USER REQUEST                                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  STEP 0: MEMORY CHECK (ALWAYS FIRST!)                          │
│  ├── Read .toh/memory/active.md                                │
│  ├── Read .toh/memory/summary.md                               │
│  ├── Read .toh/memory/decisions.md                             │
│  └── Build context understanding                               │
│                                                                 │
│  STEP 1: INTENT CLASSIFICATION                                 │
│  ├── Pattern matching (keywords, phrases)                      │
│  ├── Context inference (from memory)                           │
│  └── Scope detection (simple/complex)                          │
│                                                                 │
│  STEP 2: CONFIDENCE SCORING                                    │
│  ├── HIGH (80%+) → Direct execution                            │
│  ├── MEDIUM (50-80%) → Plan Agent first                        │
│  └── LOW (<50%) → Ask for clarification                        │
│                                                                 │
│  STEP 3: IDE DETECTION                                         │
│  ├── Claude Code → Parallel execution enabled                  │
│  └── Other IDEs → Sequential execution only                    │
│                                                                 │
│  STEP 4: AGENT SELECTION & EXECUTION                           │
│  └── Route to appropriate agent(s)                             │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

📊 Intent Classification Matrix

Primary Patterns → Agent Mapping

Pattern Category	Keywords (EN)	Keywords (TH)	Primary Agent	Confidence
Create UI	create, add, make, build + page/component/UI	สร้าง, เพิ่ม, ทำ + หน้า/component	UI Agent	HIGH
Add Logic	logic, state, function, hook, validation	logic, state, function, เพิ่ม logic	Dev Agent	HIGH
Fix Bug	bug, error, broken, fix, not working	bug, error, พัง, ไม่ทำงาน, แก้	Fix Agent	HIGH
Improve Design	prettier, beautiful, design, polish, style	สวย, design, ปรับ design	Design Agent	HIGH
Testing	test, check, verify	test, ทดสอบ, เช็ค	Test Agent	HIGH
Connect Backend	connect, database, Supabase, API, backend	เชื่อม, database, Supabase	Connect Agent	HIGH
Deploy	deploy, ship, production, publish	deploy, ship, ขึ้น production	Ship Agent	HIGH
LINE Platform	LINE, LIFF, Mini App	LINE, LIFF	LINE Agent	HIGH
Mobile Platform	mobile, iOS, Android, Expo, React Native	mobile, มือถือ	Mobile Agent	HIGH
New Project	new project, start, build app, create system	project ใหม่, สร้าง app	Vibe Agent	HIGH
Planning	plan, analyze, PRD, architecture	วางแผน, วิเคราะห์	Plan Agent	HIGH
AI/Prompt	prompt, AI, chatbot, system prompt	prompt, AI, chatbot	Dev Agent + prompt-optimizer	HIGH
Continue	continue, resume, go on	ทำต่อ, ต่อ	Memory → Last Agent	MEDIUM
Complex Request	Multiple features, system, e-commerce, etc.	ระบบ + หลาย features	Plan Agent	MEDIUM
Vague Request	help, fix it, make better (without context)	ช่วยด้วย, แก้ที	Ask Clarification	LOW

🎯 Confidence Scoring Algorithm

interface ConfidenceFactors {
  keywordMatch: number;      // 0-40 points
  contextClarity: number;    // 0-30 points
  memorySupport: number;     // 0-20 points
  scopeDefinition: number;   // 0-10 points
}

function calculateConfidence(request: string, memory: Memory): number {
  let score = 0;
  
  // Keyword matching (0-40 points)
  // Strong match with primary patterns = 40
  // Partial match = 20
  // No match = 0
  score += keywordMatchScore(request);
  
  // Context clarity (0-30 points)
  // Specific page/component mentioned = 30
  // General area mentioned = 15
  // No specifics = 0
  score += contextClarityScore(request);
  
  // Memory support (0-20 points)
  // Request relates to active task = 20
  // Request relates to project = 10
  // No memory context = 0
  score += memorySupportScore(request, memory);
  
  // Scope definition (0-10 points)
  // Single clear task = 10
  // Multiple related tasks = 5
  // Unclear scope = 0
  score += scopeDefinitionScore(request);
  
  return score; // 0-100
}

// Thresholds
const HIGH_CONFIDENCE = 80;    // Execute directly
const MEDIUM_CONFIDENCE = 50;  // Route to Plan Agent
// Below 50 = Ask for clarification

🖥️ IDE Detection

Detection Method

function detectIDE(): 'claude-code' | 'cursor' | 'gemini' | 'codex' | 'unknown' {
  // Check for IDE-specific markers
  
  // Claude Code detection
  if (hasClaudeCodeMarkers()) {
    return 'claude-code';
  }
  
  // Cursor detection
  if (hasCursorRules()) {
    return 'cursor';
  }
  
  // Gemini CLI detection
  if (hasGeminiConfig()) {
    return 'gemini';
  }
  
  // Codex CLI detection
  if (hasCodexConfig()) {
    return 'codex';
  }
  
  return 'unknown';
}

Execution Strategy by IDE

IDE	Multi-Agent Strategy	Reason
Claude Code	Parallel (spawn sub-agents)	Native support for parallel tool calls
Cursor	Sequential	More predictable, follows diff flow
Gemini CLI	Sequential	Safer execution model
Codex CLI	Sequential	Linear task processing
Unknown	Sequential (default)	Safe fallback

🔄 Routing Decision Tree

Request arrives
      │
      ▼
┌─────────────────────────────────────┐
│ 1. Load Memory Context              │
└─────────────────────────────────────┘
      │
      ▼
┌─────────────────────────────────────┐
│ 2. Is request "continue"/"ทำต่อ"?   │
├── YES → Read memory, resume task   │
└── NO → Continue analysis           │
      │
      ▼
┌─────────────────────────────────────┐
│ 3. Calculate Confidence Score       │
└─────────────────────────────────────┘
      │
      ├── Score >= 80 (HIGH)
      │   └─→ Select agent based on intent
      │       └─→ Execute directly
      │
      ├── Score 50-79 (MEDIUM)
      │   └─→ Route to Plan Agent
      │       └─→ Plan Agent analyzes & routes
      │
      └── Score < 50 (LOW)
          └─→ Ask clarifying question
              └─→ Wait for user response

📋 Clarification Patterns

When to Ask

Situation	Example	Action
No verb/action	"the login"	Ask: "What would you like to do with login?"
No target	"make it work"	Ask: "Which page/component should I fix?"
Multiple interpretations	"improve it"	Ask: "Design, performance, or features?"
Missing context + no memory	"fix it"	Ask: "What's broken? Describe the issue."

When NOT to Ask

Situation	Example	Action
Clear intent	"create login page"	Execute directly
Memory provides context	"continue" + active task exists	Resume from memory
Reasonable default exists	"add a button"	Add to current page context

🎨 Skill Loading by Intent

Detected Intent	Skills to Load
New Project	vibe-orchestrator, design-mastery, business-context, response-format
Create UI	ui-first-builder, design-excellence, response-format
Add Logic	dev-engineer, error-handling, response-format
Fix Bug	debug-protocol, error-handling, response-format
Connect Backend	backend-engineer, integrations, response-format
Improve Design	design-excellence, design-mastery, response-format
AI/Chatbot	prompt-optimizer, dev-engineer, response-format
Testing	test-engineer, error-handling, response-format
Planning	plan-orchestrator, business-context, response-format

Note: response-format skill is ALWAYS loaded for proper output formatting.

💾 Memory Integration

Pre-Routing Memory Check

Before routing, ALWAYS:
1. Read .toh/memory/active.md
   - Current task context
   - In-progress work
   - Blockers
   
2. Read .toh/memory/summary.md
   - Project overview
   - Completed features
   - Tech stack used
   
3. Read .toh/memory/decisions.md
   - Past architectural decisions
   - Design choices
   - Naming conventions

Use memory to:
- Boost confidence (if request matches active work)
- Provide context (for ambiguous "it" references)
- Maintain consistency (follow established patterns)

Post-Execution Memory Save

After routing completes, ALWAYS:
1. Update .toh/memory/active.md
   - Mark completed items
   - Update current focus
   - Set next steps
   
2. Add to .toh/memory/decisions.md
   - If new decisions were made
   
3. Update .toh/memory/summary.md
   - If feature was completed

⚠️ NEVER finish without saving memory!

📌 Examples

Example 1: High Confidence → Direct

Request: "/toh สร้างหน้า dashboard"

Analysis:
- Keyword match: "สร้าง" + "หน้า" = Create UI (40 pts)
- Context clarity: "dashboard" = specific page (30 pts)
- Memory: Project has other pages (15 pts)
- Scope: Single page (10 pts)
Total: 95 pts = HIGH

Route: UI Agent (direct)

Example 2: Medium Confidence → Plan First

Request: "/toh build e-commerce"

Analysis:
- Keyword match: "build" = Create (40 pts)
- Context clarity: "e-commerce" = general concept (10 pts)
- Memory: New project (0 pts)
- Scope: Multiple features (0 pts)
Total: 50 pts = MEDIUM

Route: Plan Agent first → then execute plan

Example 3: Low Confidence → Ask

Request: "/toh fix it"

Analysis:
- Keyword match: "fix" (20 pts)
- Context clarity: "it" = unclear (0 pts)
- Memory: No recent bugs (0 pts)
- Scope: Unknown (0 pts)
Total: 20 pts = LOW

Action: Ask "What would you like me to fix? Please describe the issue."

⚠️ Critical Rules

Memory ALWAYS first - Never route without checking context
Confidence drives action - Trust the scoring system
Plan Agent is your friend - When in doubt, route to Plan
IDE awareness matters - Parallel only in Claude Code
response-format always loaded - Every response needs 3 sections

Smart Routing Skill v1.0.0 - Intelligent Request Routing Engine

smart-routing

$ Instalar