name: ai-orchestrator
description: "🎯 AI Orchestrator - Ultimate natural language to expert prompt translator. Analyzes intent with UltraThink, routes to specialized agents, and verifies execution. Use for: orchestrate, translate commands, delegate work, smart routing, multi-agent coordination."
triggers:
- orchestrate
- translate command
- delegate task
- route to expert
- smart execute

🎯 AI Orchestrator - Ultimate Edition

Natural Language → Intent Analysis → Expert Prompt → Smart Routing → Verified Execution

⚡ Quick Start

User: "สร้างเว็บขาย sneakers"
  ↓
AI Orchestrator:
  1. Intent Analysis (UltraThink): {type: "development", domain: "e-commerce"}
  2. Route Selection: code-architect + docker-expert + security-expert
  3. Expert Prompt: Full technical spec with patterns
  4. Execution: Parallel skill invocation
  5. Verification: Quality gates + Memory save

🏗️ Architecture

┌────────────────────────────────────────────────────────────────────┐
│                    AI ORCHESTRATOR PIPELINE                        │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐         │
│  │   INTAKE     │───▶│   ANALYZE    │───▶│    ROUTE     │         │
│  │  (Natural    │    │ (UltraThink) │    │  (Skill      │         │
│  │   Language)  │    │   + Memory   │    │   Matcher)   │         │
│  └──────────────┘    └──────────────┘    └──────────────┘         │
│         │                   │                   │                  │
│         ▼                   ▼                   ▼                  │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐         │
│  │   Context    │    │  Confidence  │    │   Expert     │         │
│  │   Loading    │───▶│    Gate      │───▶│   Prompt     │         │
│  │ (Memory+Docs)│    │   (>0.7?)    │    │  Generator   │         │
│  └──────────────┘    └──────────────┘    └──────────────┘         │
│                                                 │                  │
│                                                 ▼                  │
│                           ┌──────────────────────────────┐        │
│                           │        EXECUTION             │        │
│                           │  ┌─────┐ ┌─────┐ ┌─────┐    │        │
│                           │  │Skill│ │Skill│ │Skill│    │        │
│                           │  │  A  │ │  B  │ │  C  │    │        │
│                           │  └─────┘ └─────┘ └─────┘    │        │
│                           └──────────────────────────────┘        │
│                                          │                        │
│                                          ▼                        │
│                           ┌──────────────────────────────┐        │
│                           │   VERIFY + LEARN             │        │
│                           │   Quality Check → Memory     │        │
│                           └──────────────────────────────┘        │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

📊 Intent Classification Matrix

🧠 Phase 1: Intent Analysis

async function analyzeIntent(userInput) {
  // Step 1: Memory Prime - Check for similar past tasks
  const pastPatterns = await mcp_Memory_search_nodes(
    `task pattern: ${extractKeywords(userInput)}`
  );

  // Step 2: Deep Intent Analysis with UltraThink
  const analysis = await mcp_UltraThink_ultrathink({
    thought: `
      # Intent Analysis: "${userInput}"

      ## 1. Primary Goal Extraction
      - What is the user trying to achieve?
      - What is the expected outcome?

      ## 2. Task Classification
      - Type: [development|debugging|security|architecture|learning|performance|review|agent-dev|devops|testing]
      - Domain: [web|mobile|backend|frontend|devops|security|ai|data|general]
      - Complexity: [simple|moderate|complex|enterprise]

      ## 3. Requirements Breakdown
      - Explicit requirements (stated)
      - Implicit requirements (inferred)
      - Constraints and limitations

      ## 4. Skill Routing
      - Primary skill needed
      - Supporting skills
      - MCP servers required

      ## 5. Success Criteria
      - What defines success?
      - Quality metrics
      - Verification approach

      ## Past Patterns Found
      ${pastPatterns.map(p => `- ${p.name}: ${p.observations[0]}`).join('\n')}
    `,
    total_thoughts: 15,
    confidence: null,
    assumptions: [
      { id: "A1", text: "User wants production-quality output", critical: true, confidence: 0.9 },
      { id: "A2", text: "Standard best practices apply", critical: false, confidence: 0.95 }
    ]
  });

  return {
    taskType: analysis.extracted.taskType,
    domain: analysis.extracted.domain,
    complexity: analysis.extracted.complexity,
    requirements: analysis.extracted.requirements,
    skills: analysis.extracted.skills,
    mcpServers: analysis.extracted.mcpServers,
    successCriteria: analysis.extracted.successCriteria,
    confidence: analysis.confidence
  };
}

🔀 Phase 2: Smart Routing

const SKILL_ROUTER = {
  development: {
    primary: ['code-architect'],
    supporting: ['docker-expert', 'security-expert', 'tdd-workflow'],
    mcpServers: ['Context7', 'MongoDB', 'Filesystem', 'Memory']
  },
  debugging: {
    primary: ['debugger'],
    supporting: ['tdd-workflow', 'verification-before-completion'],
    mcpServers: ['Memory', 'UltraThink', 'Filesystem']
  },
  security: {
    primary: ['security-expert', 'ethical-hacking-methodology'],
    supporting: ['debugger'],
    mcpServers: ['Brave', 'Memory', 'UltraThink']
  },
  architecture: {
    primary: ['code-architect'],
    supporting: ['performance-optimizer', 'security-expert'],
    mcpServers: ['UltraThink', 'Context7', 'Memory']
  },
  learning: {
    primary: ['knowledge-graph'],
    supporting: [],
    mcpServers: ['Context7', 'NotebookLM', 'Brave', 'Memory']
  },
  performance: {
    primary: ['performance-optimizer'],
    supporting: ['debugger'],
    mcpServers: ['MongoDB', 'UltraThink', 'Memory']
  },
  review: {
    primary: ['code-review-checklist', 'requesting-code-review'],
    supporting: ['security-expert'],
    mcpServers: ['UltraThink', 'SequentialThinking']
  },
  'agent-dev': {
    primary: ['langgraph', 'ai-agents-architect'],
    supporting: ['autonomous-agents', 'agent-memory-systems'],
    mcpServers: ['UltraThink', 'Memory', 'Context7']
  },
  devops: {
    primary: ['docker-expert', 'github-workflow-automation'],
    supporting: ['security-expert'],
    mcpServers: ['Filesystem', 'Memory']
  },
  testing: {
    primary: ['e2e-testing', 'tdd-workflow'],
    supporting: ['verification-before-completion'],
    mcpServers: ['Brave', 'Filesystem', 'Memory']
  }
};

function selectRoute(intent) {
  const route = SKILL_ROUTER[intent.taskType];

  // Adjust based on complexity
  if (intent.complexity === 'enterprise') {
    route.supporting.push('planning-with-files', 'parallel-agents');
  }

  // Add domain-specific skills
  if (intent.domain === 'ai') {
    route.supporting.push('ai-ml-expert', 'prompt-master');
  }

  return route;
}

✨ Phase 3: Expert Prompt Generation

const EXPERT_PROMPT_TEMPLATES = {

  development: (intent, context) => `
# Expert Development Task

## Role
คุณคือ Principal Software Architect ระดับโลก ผู้เชี่ยวชาญ ${intent.domain}

## Background Context
${context.docsContext ? `### Documentation\n${context.docsContext.substring(0, 2000)}` : ''}
${context.memoryContext?.length ? `### Past Patterns\n${context.memoryContext.map(m => `- ${m.name}`).join('\n')}` : ''}

## Task Requirements
${intent.requirements.explicit.map(r => `- ${r}`).join('\n')}

## Implicit Requirements (Inferred)
${intent.requirements.implicit.map(r => `- ${r}`).join('\n')}

## Technical Standards (MANDATORY)
- TypeScript strict mode
- Comprehensive error handling with recovery
- Input validation at all boundaries (Zod)
- Structured logging with correlation IDs
- Security-first approach (OWASP Top 10)
- Performance optimized (Core Web Vitals targets)
- Full test coverage (unit + integration)

## Architecture Patterns
- Clean Architecture / Hexagonal
- Repository Pattern for data access
- Factory Pattern for object creation
- Strategy Pattern for algorithms
- Circuit Breaker for external calls

## Success Criteria
${intent.successCriteria.map(c => `- [ ] ${c}`).join('\n')}

## Deliverables
1. Implementation with full code
2. Tests
3. Documentation
4. Docker configuration (if applicable)
`,

  debugging: (intent, context) => `
# Expert Debugging Task

## Role
คุณคือ Senior Debugging Specialist ผู้เชี่ยวชาญ root cause analysis

## Problem Statement
${intent.requirements.explicit[0] || 'Unspecified bug'}

## Past Similar Bugs
${context.memoryContext?.map(m => `- ${m.name}: ${m.observations[0]}`).join('\n') || 'None found'}

## Debugging Methodology
1. **Reproduce** - Confirm the issue exists
2. **Hypothesize** - Generate 3 possible causes
3. **Test** - Systematically eliminate hypotheses
4. **Fix** - Apply minimal, focused fix
5. **Verify** - Confirm fix works and no regressions
6. **Document** - Record for future reference

## Output Requirements
- Root cause identification
- Fix with explanation
- Verification steps
- Memory entry for future reference
`,

  security: (intent, context) => `
# Expert Security Assessment Task

## Role
คุณคือ Senior Security Engineer (OSCP, CEH, CISSP equivalent)

## Target
${intent.requirements.explicit[0] || 'Unspecified target'}

## Scope
${intent.requirements.constraints?.scope || 'To be defined'}

## Methodology: PTES Framework
1. **Reconnaissance** - Information gathering
2. **Scanning** - Vulnerability scanning
3. **Exploitation** - Controlled exploitation (if authorized)
4. **Post-Exploitation** - Assess impact
5. **Reporting** - Document findings

## Ethical Boundaries
- Only authorized testing
- Do not cause damage
- Report all findings responsibly
- Follow rules of engagement

## Output
- Vulnerability report with severity ratings
- Remediation recommendations
- Proof of concept (where appropriate)
`,

  architecture: (intent, context) => `
# Expert Architecture Design Task

## Role
คุณคือ Principal Architect ออกแบบระบบ scale ถึง millions of users

## Design Context
${intent.requirements.explicit.map(r => `- ${r}`).join('\n')}

## Documentation Reference
${context.docsContext?.substring(0, 1500) || 'None loaded'}

## Deliverables
1. **Architecture Diagram** (Mermaid format)
2. **Component Specifications**
3. **Data Flow Diagrams**
4. **API Contracts**
5. **Security Considerations**
6. **Scalability Analysis**
7. **Cost Estimation**

## Quality Attributes (NFRs)
- Performance: Response time < 200ms P95
- Scalability: 10x current load
- Availability: 99.9% uptime
- Security: OWASP compliant
- Maintainability: Clean code, documentation
`,

  learning: (intent, context) => `
# Expert Learning & Research Task

## Role
คุณคือนักวิจัยระดับ PhD ผู้เชี่ยวชาญการสังเคราะห์ความรู้

## Topic
${intent.requirements.explicit[0] || 'Topic to research'}

## Research Approach
1. Gather information from multiple sources
2. Cross-reference and validate
3. Synthesize key insights
4. Create actionable knowledge

## Sources to Use
- Context7: Framework documentation
- NotebookLM: Research papers
- Brave: Latest articles and tutorials
- Memory: Past learnings

## Output
- Comprehensive summary
- Key insights (bullet points)
- Code examples (if applicable)
- Memory entry for persistence
`
};

async function generateExpertPrompt(intent, userInput) {
  // Load context in parallel
  const [memoryContext, docsContext, webContext] = await Promise.all([
    mcp_Memory_search_nodes(intent.domain + ' ' + intent.taskType),
    intent.domain !== 'general' 
      ? mcp_Context7_query_docs(getLibraryId(intent.domain), userInput) 
      : null,
    intent.complexity === 'complex' || intent.complexity === 'enterprise'
      ? mcp_Brave_brave_web_search(`${intent.domain} best practices 2026`)
      : null
  ]);

  const context = { memoryContext, docsContext, webContext };
  const template = EXPERT_PROMPT_TEMPLATES[intent.taskType];

  if (!template) {
    // Fallback to generic expert prompt
    return generateGenericExpertPrompt(intent, context, userInput);
  }

  return template(intent, context);
}

🚀 Phase 4: Execution

async function executeWithSkills(route, expertPrompt, intent) {
  // Load all required skills
  for (const skill of [...route.primary, ...route.supporting]) {
    console.log(`Loading skill: ${skill}`);
    // Skills are auto-loaded by the system
  }

  // Execute primary task
  const result = await executeTask(expertPrompt);

  return result;
}

✅ Phase 5: Verification & Learning

async function verifyAndLearn(result, intent, userInput) {
  // Verify output quality
  const verification = await mcp_UltraThink_ultrathink({
    thought: `
      # Output Verification

      ## Success Criteria Check
      ${intent.successCriteria.map(c => `- [ ] ${c}`).join('\n')}

      ## Quality Assessment
      - Completeness: Does it address all requirements?
      - Correctness: Is the solution technically sound?
      - Best Practices: Does it follow standards?
      - Security: Any vulnerabilities?
      - Performance: Any obvious issues?

      ## Overall Score
      Rate 1-10 with justification
    `,
    total_thoughts: 5,
    confidence: null
  });

  // Save successful pattern to Memory
  if (verification.confidence > 0.8) {
    await mcp_Memory_create_entities([{
      name: `Orchestration_${intent.taskType}_${Date.now()}`,
      entityType: 'OrchestrationPattern',
      observations: [
        `Input: ${userInput}`,
        `TaskType: ${intent.taskType}`,
        `Domain: ${intent.domain}`,
        `Skills: ${[...route.primary, ...route.supporting].join(', ')}`,
        `Success: ${verification.confidence}`,
        `Timestamp: ${new Date().toISOString()}`
      ]
    }]);

    // Link to related patterns
    await mcp_Memory_create_relations([
      { from: `Orchestration_${intent.taskType}_${Date.now()}`, to: intent.taskType, relationType: 'is_type_of' }
    ]);
  }

  return verification;
}

🎯 Complete Orchestration Example

// User says: "สร้างเว็บ e-commerce ขาย sneakers"

async function orchestrate(userInput) {
  console.log("🎯 AI Orchestrator: Starting...");

  // Phase 1: Analyze Intent
  const intent = await analyzeIntent(userInput);
  console.log(`📊 Intent: ${intent.taskType} (${intent.confidence} confidence)`);

  // Confidence Gate
  if (intent.confidence < 0.6) {
    return { needsClarification: true, questions: intent.uncertainties };
  }

  // Phase 2: Select Route
  const route = selectRoute(intent);
  console.log(`🔀 Route: ${route.primary.join(', ')}`);

  // Phase 3: Generate Expert Prompt
  const expertPrompt = await generateExpertPrompt(intent, userInput);
  console.log("✨ Expert Prompt Generated");

  // Phase 4: Execute
  const result = await executeWithSkills(route, expertPrompt, intent);
  console.log("🚀 Execution Complete");

  // Phase 5: Verify & Learn
  const verification = await verifyAndLearn(result, intent, userInput);
  console.log(`✅ Verification: ${verification.confidence}`);

  return {
    success: verification.confidence > 0.7,
    result,
    verification,
    patternSaved: verification.confidence > 0.8
  };
}

🔧 Integration Points

With Workflows

• /orchestrate - Direct orchestration command
• /smart - Auto-detects and uses Orchestrator
• /god - Ultimate mode with Orchestrator

With Skills

• Auto-loads relevant skills based on intent
• Coordinates multi-skill execution
• Manages skill dependencies

With MCP Servers

• UltraThink: Deep intent analysis
• Memory: Pattern storage and retrieval
• Context7: Documentation loading
• Brave/DuckDuckGo: Web research
• NotebookLM: Deep research

⚠️ Anti-Patterns

📚 Related Skills

• prompt-master - Advanced prompt engineering
• parallel-agents - Multi-agent execution
• planning-with-files - Complex task planning
• knowledge-graph - Memory management
• omni-skill - Full skill integration

Remember: The Orchestrator is the brain that understands, routes, and verifies.
It transforms simple requests into expert-level executions.