Task Input
    │
    ▼
┌─────────────────────────────┐
│  AgentBoosterPreprocessor   │
│  detectIntent(task)         │
└─────────────────────────────┘
    │
    ├── confidence >= 0.8 ──► Tier 1: Agent Booster (WASM)
    │                         • var-to-const
    │                         • add-types
    │                         • add-error-handling
    │                         • async-await
    │                         • add-logging
    │                         • remove-console
    │
    ├── confidence < 0.8 ──► AST Complexity Analysis
    │                         │
    │                         ▼
    │                   ┌───────────────┐
    │                   │ getComplexity │
    │                   └───────────────┘
    │                         │
    │                         ├── complexity < 0.3 ──► Tier 2: Haiku
    │                         │
    │                         ├── complexity 0.3-0.6 ──► Tier 2/3: Sonnet
    │                         │
    │                         └── complexity > 0.6 ──► Tier 3: Opus
    │
    └── No code intent ──► tiny-dancer model router (existing)

// v3/@claude-flow/cli/src/ruvector/model-router.ts

import { AgentBoosterPreprocessor, EditIntent, PreprocessorResult } from 'agentic-flow';

export interface EnhancedRouteResult {
  tier: 1 | 2 | 3;
  handler: 'agent-booster' | 'haiku' | 'sonnet' | 'opus';
  model?: 'haiku' | 'sonnet' | 'opus';
  confidence: number;
  complexity?: number;
  reasoning: string;

  // Agent Booster specific
  agentBoosterIntent?: EditIntent;
  canSkipLLM?: boolean;
  estimatedLatencyMs: number;
  estimatedCost: number;
}

export interface EnhancedModelRouterConfig {
  // Agent Booster settings
  agentBoosterEnabled: boolean;
  agentBoosterConfidenceThreshold: number;  // Default: 0.8
  enabledIntents: string[];  // Default: all

  // Complexity thresholds
  complexityThresholds: {
    haiku: number;   // Default: 0.3
    sonnet: number;  // Default: 0.6
    opus: number;    // Default: 1.0
  };

  // Existing tiny-dancer settings
  preferCost: boolean;
  preferQuality: boolean;
}

// v3/@claude-flow/cli/src/ruvector/model-router.ts

export class EnhancedModelRouter {
  private preprocessor: AgentBoosterPreprocessor;
  private tinyDancerRouter: ReturnType<typeof getModelRouter>;
  private config: EnhancedModelRouterConfig;

  constructor(config?: Partial<EnhancedModelRouterConfig>) {
    this.config = {
      agentBoosterEnabled: true,
      agentBoosterConfidenceThreshold: 0.8,
      enabledIntents: [
        'var-to-const',
        'add-types',
        'add-error-handling',
        'async-await',
        'add-logging',
        'remove-console'
      ],
      complexityThresholds: {
        haiku: 0.3,
        sonnet: 0.6,
        opus: 1.0
      },
      preferCost: false,
      preferQuality: false,
      ...config
    };

    this.preprocessor = new AgentBoosterPreprocessor({
      confidenceThreshold: this.config.agentBoosterConfidenceThreshold,
      enabledIntents: this.config.enabledIntents
    });
  }

  async route(task: string, context?: { filePath?: string }): Promise<EnhancedRouteResult> {
    // Step 1: Try Agent Booster intent detection
    if (this.config.agentBoosterEnabled) {
      const intent = this.preprocessor.detectIntent(task);

      if (intent && intent.confidence >= this.config.agentBoosterConfidenceThreshold) {
        return {
          tier: 1,
          handler: 'agent-booster',
          confidence: intent.confidence,
          reasoning: `Agent Booster can handle "${intent.type}" with ${(intent.confidence * 100).toFixed(0)}% confidence`,
          agentBoosterIntent: intent,
          canSkipLLM: true,
          estimatedLatencyMs: 1,
          estimatedCost: 0
        };
      }
    }

    // Step 2: AST complexity analysis (if file path provided)
    let complexity: number | undefined;
    if (context?.filePath) {
      try {
        const { analyzeAST } = await import('./adapters/ast-adapter.js');
        const analysis = await analyzeAST({ path: context.filePath });
        complexity = analysis.summary.avgComplexity / 100; // Normalize to 0-1
      } catch {
        // AST analysis not available, continue with text-based routing
      }
    }

    // Step 3: Text-based complexity + tiny-dancer routing
    const tinyDancerResult = await this.tinyDancerRouter.route(task);

    // Step 4: Combine AST complexity with tiny-dancer result
    const finalComplexity = complexity !== undefined
      ? (complexity + tinyDancerResult.complexity) / 2
      : tinyDancerResult.complexity;

    // Step 5: Determine tier based on complexity
    const { haiku, sonnet } = this.config.complexityThresholds;

    if (finalComplexity < haiku) {
      return {
        tier: 2,
        handler: 'haiku',
        model: 'haiku',
        confidence: tinyDancerResult.confidence,
        complexity: finalComplexity,
        reasoning: `Low complexity (${(finalComplexity * 100).toFixed(0)}%) - using haiku`,
        canSkipLLM: false,
        estimatedLatencyMs: 500,
        estimatedCost: 0.0002
      };
    }

    if (finalComplexity < sonnet) {
      return {
        tier: 2,
        handler: 'sonnet',
        model: 'sonnet',
        confidence: tinyDancerResult.confidence,
        complexity: finalComplexity,
        reasoning: `Medium complexity (${(finalComplexity * 100).toFixed(0)}%) - using sonnet`,
        canSkipLLM: false,
        estimatedLatencyMs: 2000,
        estimatedCost: 0.003
      };
    }

    return {
      tier: 3,
      handler: 'opus',
      model: 'opus',
      confidence: tinyDancerResult.confidence,
      complexity: finalComplexity,
      reasoning: `High complexity (${(finalComplexity * 100).toFixed(0)}%) - using opus`,
      canSkipLLM: false,
      estimatedLatencyMs: 5000,
      estimatedCost: 0.015
    };
  }

  /**
   * Execute task using the appropriate tier
   */
  async execute(task: string, context?: { filePath?: string; originalCode?: string }): Promise<{
    result: string | PreprocessorResult;
    routeResult: EnhancedRouteResult;
  }> {
    const routeResult = await this.route(task, context);

    if (routeResult.tier === 1 && routeResult.agentBoosterIntent) {
      // Execute with Agent Booster (skip LLM entirely)
      const abResult = await this.preprocessor.tryApply(routeResult.agentBoosterIntent);
      return { result: abResult, routeResult };
    }

    // Return routing result - caller handles LLM invocation
    return { result: routeResult.reasoning, routeResult };
  }
}

// v3/@claude-flow/cli/src/commands/hooks.ts (update preTaskCommand)

// In pre-task action, after existing logic:

// Enhanced model routing with Agent Booster AST
try {
  const { EnhancedModelRouter } = await import('../ruvector/enhanced-model-router.js');
  const router = new EnhancedModelRouter();
  const routeResult = await router.route(description, { filePath: ctx.flags.file as string });

  output.writeln();
  output.writeln(output.bold('Intelligent Model Routing'));

  if (routeResult.tier === 1) {
    // Agent Booster can handle this
    output.writeln(output.success(`  Tier 1: Agent Booster (WASM)`));
    output.writeln(output.dim(`  Intent: ${routeResult.agentBoosterIntent?.type}`));
    output.writeln(output.dim(`  Latency: <1ms | Cost: $0`));
    output.writeln();
    output.writeln(output.bold(output.success(`[AGENT_BOOSTER_AVAILABLE] Skip LLM - use Agent Booster for "${routeResult.agentBoosterIntent?.type}"`)));
  } else {
    // LLM required
    output.writeln(`  Tier ${routeResult.tier}: ${routeResult.handler.toUpperCase()}`);
    output.writeln(output.dim(`  Complexity: ${((routeResult.complexity || 0) * 100).toFixed(0)}%`));
    output.writeln(output.dim(`  Est. Latency: ${routeResult.estimatedLatencyMs}ms | Cost: $${routeResult.estimatedCost.toFixed(4)}`));
    output.writeln();

    // Clear instruction for Claude
    output.writeln(output.dim('─'.repeat(60)));
    output.writeln(output.bold(output.success(`[TASK_MODEL_RECOMMENDATION] Use model="${routeResult.model}" for this task`)));
    output.writeln(output.dim(`Complexity: ${((routeResult.complexity || 0) * 100).toFixed(0)}% | Confidence: ${(routeResult.confidence * 100).toFixed(0)}%`));
    output.writeln(output.dim('─'.repeat(60)));
  }

  (result as Record<string, unknown>).routeResult = routeResult;
} catch {
  // Enhanced router not available, continue with basic routing
}

// v3/@claude-flow/cli/src/mcp-tools/agent-tools.ts (update determineAgentModel)

import { EnhancedModelRouter } from '../ruvector/enhanced-model-router.js';

async function determineAgentModel(
  agentType: string,
  config: Record<string, unknown>,
  task?: string
): Promise<{
  model: ClaudeModel;
  routedBy: 'explicit' | 'router' | 'agent-booster' | 'default';
  canSkipLLM?: boolean;
  agentBoosterIntent?: string;
}> {
  // 1. Explicit model in config
  if (config.model && ['haiku', 'sonnet', 'opus', 'inherit'].includes(config.model as string)) {
    return { model: config.model as ClaudeModel, routedBy: 'explicit' };
  }

  // 2. Enhanced routing with Agent Booster AST
  if (task) {
    try {
      const router = new EnhancedModelRouter();
      const routeResult = await router.route(task, { filePath: config.filePath as string });

      if (routeResult.tier === 1) {
        // Agent Booster can handle this
        return {
          model: 'haiku',  // Use haiku as fallback if AB fails
          routedBy: 'agent-booster',
          canSkipLLM: true,
          agentBoosterIntent: routeResult.agentBoosterIntent?.type
        };
      }

      return {
        model: routeResult.model!,
        routedBy: 'router'
      };
    } catch {
      // Fall through to defaults
    }
  }

  // 3. Agent type defaults
  const defaultModel = AGENT_TYPE_MODEL_DEFAULTS[agentType];
  if (defaultModel) {
    return { model: defaultModel, routedBy: 'default' };
  }

  // 4. Fallback to sonnet
  return { model: 'sonnet', routedBy: 'default' };
}

### 🤖 AGENT BOOSTER INTEGRATION (AUTOMATIC)

**The routing system now has 3 tiers for optimal cost/performance:**

| Tier | Handler | When Used |
|------|---------|-----------|
| **1** | Agent Booster | Simple code transforms (var→const, add types, etc.) - **Skip LLM entirely** |
| **2** | Haiku | Simple tasks, low complexity (<30%) |
| **3** | Sonnet/Opus | Complex tasks, high complexity (>30%) |

**When you see these recommendations:**

1. `[AGENT_BOOSTER_AVAILABLE]` → The task can be handled by Agent Booster (352x faster, $0)
   - Use the `agent_booster_edit_file` MCP tool instead of Task tool
   - Example: `mcp__agentic-flow__agent_booster_edit_file({ target_filepath: "...", instructions: "...", code_edit: "..." })`

2. `[TASK_MODEL_RECOMMENDATION] Use model="X"` → Use that model in Task tool
   - Example: `Task({ ..., model: "opus" })`

**Agent Booster Intent Types (Tier 1):**
- `var-to-const` - Convert var to const/let
- `add-types` - Add TypeScript types
- `add-error-handling` - Wrap in try/catch
- `async-await` - Convert callbacks to async/await
- `add-logging` - Add console.log statements
- `remove-console` - Remove console.* calls

v3/@claude-flow/cli/src/
├── ruvector/
│   ├── model-router.ts           # Existing tiny-dancer router
│   ├── enhanced-model-router.ts  # NEW: Agent Booster + AST integration
│   └── adapters/
│       └── ast-adapter.ts        # Existing: AST analysis
├── mcp-tools/
│   └── agent-tools.ts            # UPDATED: Enhanced routing
└── commands/
    └── hooks.ts                  # UPDATED: Enhanced pre-task output

═══════════════════════════════════════════════════════════════════
  ADR-026 VALIDATION & BENCHMARK
═══════════════════════════════════════════════════════════════════

Task Description                                     Expected  Actual   Status
─────────────────────────────────────────────────────────────────────────────
Add type annotations to file                         T1-Boost  T1-Boost ✓ PASS
Convert var to const in module                       T1-Boost  T1-Boost ✓ PASS
Remove console.log statements                        T1-Boost  T1-Boost ✓ PASS
Add error handling to function                       T1-Boost  T1-Boost ✓ PASS
Convert callback to async/await                      T1-Boost  T1-Boost ✓ PASS
Fix bug in authentication flow                       T2-Sonnet T2-Sonnet ✓ PASS
Refactor user service module                         T2-Sonnet T2-Sonnet ✓ PASS
Add pagination to API endpoint                       T2-Sonnet T2-Sonnet ✓ PASS
Implement caching for database queries               T2-Sonnet T2-Sonnet ✓ PASS
Design microservices architecture for payment system T3-Opus   T3-Opus   ✓ PASS
Implement OAuth2 with PKCE and refresh token rotation T3-Opus   T3-Opus   ✓ PASS
Create distributed consensus algorithm               T3-Opus   T3-Opus   ✓ PASS

┌─────────────────────────────────────────────────────────────────┐
│  RESULTS                                                        │
├─────────────────────────────────────────────────────────────────┤
│  Accuracy:     100% (12/12 tests passed)                        │
│  Avg Latency:  0.57ms per routing decision                      │
│  Total Time:   6.82ms for all 12 tests                          │
└─────────────────────────────────────────────────────────────────┘