/============================================================================/ /* AGENT-SELECTOR SKILL :: VERILINGUA x VERIX EDITION / /============================================================================*/

name: agent-selector version: 2.1.0 description: | [assert|neutral] Intelligent agent selection from 203-agent registry using semantic matching and capability analysis [ground:given] [conf:0.95] [state:confirmed] category: orchestration tags:

• general author: System cognitive_frame: primary: evidential goal_analysis: first_order: "Execute agent-selector workflow" second_order: "Ensure quality and consistency" third_order: "Enable systematic orchestration processes"

/----------------------------------------------------------------------------/ /* S0 META-IDENTITY / /----------------------------------------------------------------------------*/

[define|neutral] SKILL := { name: "agent-selector", category: "orchestration", version: "2.1.0", layer: L1 } [ground:given] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* S1 COGNITIVE FRAME / /----------------------------------------------------------------------------*/

[define|neutral] COGNITIVE_FRAME := { frame: "Evidential", source: "Turkish", force: "How do you know?" } [ground:cognitive-science] [conf:0.92] [state:confirmed]

Kanitsal Cerceve (Evidential Frame Activation)

Kaynak dogrulama modu etkin.

/----------------------------------------------------------------------------/ /* S2 TRIGGER CONDITIONS / /----------------------------------------------------------------------------*/

[define|neutral] TRIGGER_POSITIVE := { keywords: ["agent-selector", "orchestration", "workflow"], context: "user needs agent-selector capability" } [ground:given] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* S3 CORE CONTENT / /----------------------------------------------------------------------------*/

Agent Selector Micro-Skill

Kanitsal Cerceve (Evidential Frame Activation)

Kaynak dogrulama modu etkin.

Phase 0: Expertise Loading

Before selecting agents:

1. Detect Domain: Identify task domain from request
2. Check Expertise: Look for .claude/expertise/agent-selection.yaml
3. Load Context: If exists, load agent performance history and preferences
4. Apply Configuration: Use expertise for optimal agent matching

Purpose

Intelligently selects the most appropriate specialized agent from the 203-agent registry based on:

• Task requirements and complexity
• Agent capabilities and specializations
• Domain expertise (category/subcategory)
• Tool and MCP requirements
• Phase alignment (planning, development, testing, etc.)

Critical for Phase 4 routing to ensure Claude Code uses specialized agents instead of generic ones.

When to Use

• Before any Task() invocation in Phase 5 execution
• When planning multi-agent workflows and need optimal agent assignment
• When you're unsure which specialized agent to use for a task
• To validate that a generic agent name has a specialized alternative

How It Works

4-Step Process:

1. Parse Task Requirements

   • Extract domain (backend, frontend, database, testing, etc.)
   • Identify key capabilities needed (Express.js, PostgreSQL, TDD, etc.)
   • Determine phase (planning, development, testing, deployment)
   • Note tool/MCP requirements

2. Semantic Search (Memory MCP)

   • Query Memory MCP with task description
   • Get top 5-10 candidate agents ranked by similarity
   • Filter by category/phase if known

3. Capability Matching

   • Score each candidate agent based on:
     • Exact capability matches (highest priority)
     • Domain specialization (category/subcategory)
     • Tool/MCP alignment
     • Phase alignment
   • Apply fallback rules if no perfect match

4. Return Selection + Reasoning

   • Selected agent name
   • Agent source (file path in registry)
   • Capabilities that matched
   • Alternatives considered
   • Selection reasoning

Usage

// Skill invocation
Skill("agent-selector")

// Agent will prompt you for:
// 1. Task description (what needs to be done)
// 2. Domain hint (optional: backend, frontend, testing, etc.)
// 3. Phase hint (optional: development, testing, deployment)

// Output:
{
  "selected_agent": "dev-backend-api",
  "agent_source": "delivery/development/backend/dev-backend-api.md",
  "agent_category": "delivery/development/backend",
  "capabilities": ["Express.js", "REST APIs", "JWT", "OpenAPI"],
  "selection_reasoning": "Specialized backend API agent with exact match for Express.js + REST requirements",
  "alternatives_considered": [
    {
      "name": "backend-specialist",
      "score": 0.82,
      "reason": "Less API-specific, more general backend work"
    }
  ],
  "confidence": 0.95
}

Integration with Phase 4 Routing

Automatic Integration:

When Phase 4 routing runs, it MUST use this skill (or inline equivalent) to select agents:

// Phase 4 Routing
for (const task of plan.tasks) {
  // Invoke agent-selector
  const agentSelection = Skill("agent-selector", {
    task: task.description,
    domain: task.domain,
    phase: task.phase
  });

  // Use selected agent in Phase 5
  task.agent = agentSelection.selected_agent;
  task.agent_source = agentSelection.agent_source;
  task.agent_capabilities = agentSelection.capabilities;
  task.agent_reasoning = agentSelection.selection_reasoning;
}

Agent Selection Criteria (Priority Order)

1. Exact Capability Match (score: 1.0)

   • Agent metadata lists exact task requirement
   • Example: "Express.js API development" → dev-backend-api

2. Domain Specialization (score: 0.9)

   • Agent is in correct category/subcategory
   • Example: Backend task → delivery/development/backend agents

3. Tool Requirements (score: 0.8)

   • Agent has required tools/MCP servers
   • Example: Needs Post

/----------------------------------------------------------------------------/ /* S4 SUCCESS CRITERIA / /----------------------------------------------------------------------------*/

[define|neutral] SUCCESS_CRITERIA := { primary: "Skill execution completes successfully", quality: "Output meets quality thresholds", verification: "Results validated against requirements" } [ground:given] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* S5 MCP INTEGRATION / /----------------------------------------------------------------------------*/

[define|neutral] MCP_INTEGRATION := { memory_mcp: "Store execution results and patterns", tools: ["mcp__memory-mcp__memory_store", "mcp__memory-mcp__vector_search"] } [ground:witnessed:mcp-config] [conf:0.95] [state:confirmed]

/----------------------------------------------------------------------------/ /* S6 MEMORY NAMESPACE / /----------------------------------------------------------------------------*/

[define|neutral] MEMORY_NAMESPACE := { pattern: "skills/orchestration/agent-selector/{project}/{timestamp}", store: ["executions", "decisions", "patterns"], retrieve: ["similar_tasks", "proven_patterns"] } [ground:system-policy] [conf:1.0] [state:confirmed]

[define|neutral] MEMORY_TAGGING := { WHO: "agent-selector-{session_id}", WHEN: "ISO8601_timestamp", PROJECT: "{project_name}", WHY: "skill-execution" } [ground:system-policy] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* S7 SKILL COMPLETION VERIFICATION / /----------------------------------------------------------------------------*/

[direct|emphatic] COMPLETION_CHECKLIST := { agent_spawning: "Spawn agents via Task()", registry_validation: "Use registry agents only", todowrite_called: "Track progress with TodoWrite", work_delegation: "Delegate to specialized agents" } [ground:system-policy] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* S8 ABSOLUTE RULES / /----------------------------------------------------------------------------*/

[direct|emphatic] RULE_NO_UNICODE := forall(output): NOT(unicode_outside_ascii) [ground:windows-compatibility] [conf:1.0] [state:confirmed]

[direct|emphatic] RULE_EVIDENCE := forall(claim): has(ground) AND has(confidence) [ground:verix-spec] [conf:1.0] [state:confirmed]

[direct|emphatic] RULE_REGISTRY := forall(agent): agent IN AGENT_REGISTRY [ground:system-policy] [conf:1.0] [state:confirmed]

/----------------------------------------------------------------------------/ /* PROMISE / /----------------------------------------------------------------------------*/

[commit|confident] AGENT_SELECTOR_VERILINGUA_VERIX_COMPLIANT [ground:self-validation] [conf:0.99] [state:confirmed]