@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/routing/qe-agent-registry.ts

@@ -1,963 +0,0 @@
-/**
- * QE Agent Registry
- * ADR-022: Adaptive QE Agent Routing
- *
- * Registry of all 80 QE agents with their capabilities, domains, and performance metrics.
- * This registry is used by the QETaskRouter to select the optimal agent for each task.
- *
- * Agent Categories:
- * - V3 QE Agents (35): Core quality engineering agents
- * - n8n Agents (15): n8n workflow testing agents
- * - General Agents (7): Versatile general-purpose agents
- * - V3 Specialized (11): Advanced v3-specific agents
- * - Swarm Agents (8): Multi-agent coordination
- * - Consensus Agents (4): Distributed consensus protocols
- */
-
-import type {
-  QEAgentProfile,
-  AgentCapability,
-  ProgrammingLanguage,
-  TestFramework,
-  ComplexityLevel,
-} from './types.js';
-import type { QEDomain } from '../learning/qe-patterns.js';
-
-// ============================================================================
-// Helper Functions
-// ============================================================================
-
-/**
- * Create an agent profile with defaults
- */
-function createAgentProfile(
-  partial: Omit<QEAgentProfile, 'performanceScore' | 'tasksCompleted' | 'successRate' | 'avgDurationMs'>
-): QEAgentProfile {
-  return {
-    ...partial,
-    performanceScore: 0.7, // Default performance score
-    tasksCompleted: 0,
-    successRate: 0,
-    avgDurationMs: 0,
-  };
-}
-
-// ============================================================================
-// V3 QE Agents (Core Quality Engineering)
-// ============================================================================
-
-const v3QEAgents: QEAgentProfile[] = [
-  // Test Generation Domain
-  createAgentProfile({
-    id: 'qe-test-generator',
-    name: 'QE Test Generator',
-    description: 'AI-powered test generation with sublinear optimization and multi-framework support',
-    domains: ['test-generation'],
-    capabilities: ['test-generation', 'unit-test', 'integration-test', 'e2e-test', 'tdd', 'bdd'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    frameworks: ['jest', 'vitest', 'pytest', 'junit', 'go-test'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['ai-powered', 'multi-framework'],
-  }),
-  createAgentProfile({
-    id: 'qe-test-writer',
-    name: 'TDD RED Phase Specialist',
-    description: 'TDD RED phase specialist - writes failing tests that define expected behavior before implementation',
-    domains: ['test-generation'],
-    capabilities: ['test-generation', 'tdd', 'unit-test'],
-    languages: ['typescript', 'javascript', 'python'],
-    frameworks: ['jest', 'vitest', 'pytest'],
-    complexity: { min: 'simple', max: 'medium' },
-    tags: ['tdd', 'red-phase'],
-  }),
-  createAgentProfile({
-    id: 'qe-test-implementer',
-    name: 'TDD GREEN Phase Specialist',
-    description: 'TDD GREEN phase specialist - implements minimal code to make failing tests pass',
-    domains: ['test-generation'],
-    capabilities: ['test-generation', 'tdd', 'unit-test'],
-    languages: ['typescript', 'javascript', 'python'],
-    frameworks: ['jest', 'vitest', 'pytest'],
-    complexity: { min: 'simple', max: 'medium' },
-    tags: ['tdd', 'green-phase'],
-  }),
-  createAgentProfile({
-    id: 'qe-test-refactorer',
-    name: 'TDD REFACTOR Phase Specialist',
-    description: 'TDD REFACTOR phase specialist - improves code quality while keeping all tests passing',
-    domains: ['test-generation'],
-    capabilities: ['test-generation', 'tdd', 'test-quality'],
-    languages: ['typescript', 'javascript', 'python'],
-    frameworks: ['jest', 'vitest', 'pytest'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['tdd', 'refactor-phase'],
-  }),
-  createAgentProfile({
-    id: 'v3-qe-test-architect',
-    name: 'V3 QE Test Architect',
-    description: 'V3 QE Test Architect for AI-powered test generation strategy, test pyramid design, and cross-framework test orchestration',
-    domains: ['test-generation'],
-    capabilities: ['test-generation', 'test-orchestration', 'unit-test', 'integration-test', 'e2e-test'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    frameworks: ['jest', 'vitest', 'pytest', 'junit', 'playwright', 'cypress'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['v3', 'architect', 'strategy'],
-  }),
-
-  // Test Execution Domain
-  createAgentProfile({
-    id: 'qe-test-executor',
-    name: 'QE Test Executor',
-    description: 'Multi-framework test executor with parallel execution, retry logic, and real-time reporting',
-    domains: ['test-execution'],
-    capabilities: ['test-orchestration', 'retry', 'flaky-detection'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    frameworks: ['jest', 'vitest', 'pytest', 'junit', 'go-test', 'playwright', 'cypress'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['parallel', 'retry', 'reporting'],
-  }),
-  createAgentProfile({
-    id: 'qe-flaky-test-hunter',
-    name: 'QE Flaky Test Hunter',
-    description: 'Detects, analyzes, and stabilizes flaky tests through pattern recognition and auto-remediation',
-    domains: ['test-execution'],
-    capabilities: ['flaky-detection', 'test-stability', 'retry'],
-    frameworks: ['jest', 'vitest', 'pytest', 'playwright', 'cypress'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['flaky', 'stability', 'remediation'],
-  }),
-  createAgentProfile({
-    id: 'qe-flaky-investigator',
-    name: 'QE Flaky Investigator',
-    description: 'Detects flaky tests, analyzes root causes, and suggests stabilization fixes',
-    domains: ['test-execution'],
-    capabilities: ['flaky-detection', 'test-stability'],
-    frameworks: ['jest', 'vitest', 'pytest', 'playwright', 'cypress'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['investigation', 'root-cause'],
-  }),
-
-  // Coverage Analysis Domain
-  createAgentProfile({
-    id: 'qe-coverage-analyzer',
-    name: 'QE Coverage Analyzer',
-    description: 'Coverage gap detection with sublinear algorithms (O(log n) analysis)',
-    domains: ['coverage-analysis'],
-    capabilities: ['coverage-analysis', 'gap-detection', 'sublinear-analysis', 'risk-scoring'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['sublinear', 'gap-detection'],
-  }),
-  createAgentProfile({
-    id: 'qe-coverage-gap-analyzer',
-    name: 'QE Coverage Gap Analyzer',
-    description: 'Identifies coverage gaps, risk-scores untested code, and recommends tests',
-    domains: ['coverage-analysis'],
-    capabilities: ['coverage-analysis', 'gap-detection', 'risk-scoring'],
-    languages: ['typescript', 'javascript', 'python', 'java'],
-    complexity: { min: 'simple', max: 'medium' },
-    tags: ['gap-analysis', 'recommendations'],
-  }),
-  createAgentProfile({
-    id: 'v3-qe-coverage-specialist',
-    name: 'V3 QE Coverage Specialist',
-    description: 'V3 QE Coverage Specialist for O(log n) sublinear coverage analysis, risk-weighted gap detection, and intelligent test prioritization',
-    domains: ['coverage-analysis'],
-    capabilities: ['coverage-analysis', 'gap-detection', 'sublinear-analysis', 'risk-scoring', 'branch-coverage'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['v3', 'sublinear', 'prioritization'],
-  }),
-
-  // Quality Assessment Domain
-  createAgentProfile({
-    id: 'qe-quality-gate',
-    name: 'QE Quality Gate',
-    description: 'Quality gate decisions with risk assessment and policy validation',
-    domains: ['quality-assessment'],
-    capabilities: ['quality-gate', 'deployment-readiness', 'risk-scoring'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['gate', 'deployment', 'policy'],
-  }),
-  createAgentProfile({
-    id: 'qe-quality-analyzer',
-    name: 'QE Quality Analyzer',
-    description: 'Comprehensive quality metrics analysis with trend detection, predictive analytics, and actionable insights',
-    domains: ['quality-assessment'],
-    capabilities: ['quality-gate', 'risk-scoring'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['metrics', 'trends', 'analytics'],
-  }),
-  createAgentProfile({
-    id: 'qe-deployment-readiness',
-    name: 'QE Deployment Readiness',
-    description: 'Aggregates quality signals for deployment risk assessment and go/no-go decisions',
-    domains: ['quality-assessment'],
-    capabilities: ['deployment-readiness', 'quality-gate', 'risk-scoring'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['deployment', 'go-no-go'],
-  }),
-  createAgentProfile({
-    id: 'qe-code-reviewer',
-    name: 'QE Code Reviewer',
-    description: 'Enforce quality standards, linting, complexity, and security',
-    domains: ['quality-assessment'],
-    capabilities: ['quality-gate', 'security-scanning'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['code-review', 'standards'],
-  }),
-  createAgentProfile({
-    id: 'qe-code-complexity',
-    name: 'QE Code Complexity',
-    description: 'AI-powered code complexity analysis with refactoring recommendations',
-    domains: ['quality-assessment'],
-    capabilities: ['quality-gate', 'risk-scoring'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['complexity', 'refactoring'],
-  }),
-
-  // Security & Compliance Domain
-  createAgentProfile({
-    id: 'qe-security-scanner',
-    name: 'QE Security Scanner',
-    description: 'Security scanning with SAST/DAST, vulnerability detection, and compliance validation',
-    domains: ['security-compliance'],
-    capabilities: ['sast', 'dast', 'vulnerability', 'owasp', 'security-scanning'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['sast', 'dast', 'owasp'],
-  }),
-  createAgentProfile({
-    id: 'qe-security-auditor',
-    name: 'QE Security Auditor',
-    description: 'Audits code for security vulnerabilities and compliance',
-    domains: ['security-compliance'],
-    capabilities: ['sast', 'vulnerability', 'owasp', 'security-scanning'],
-    languages: ['typescript', 'javascript', 'python', 'java'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['audit', 'compliance'],
-  }),
-
-  // API & Contract Testing Domain
-  createAgentProfile({
-    id: 'qe-api-contract-validator',
-    name: 'QE API Contract Validator',
-    description: 'Validates API contracts, detects breaking changes, and ensures backward compatibility with consumer-driven contract testing',
-    domains: ['contract-testing'],
-    capabilities: ['api-testing', 'contract-testing', 'pact', 'openapi'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['contract', 'api', 'pact'],
-  }),
-  createAgentProfile({
-    id: 'qe-integration-tester',
-    name: 'QE Integration Tester',
-    description: 'Validates component interactions and system integration',
-    domains: ['contract-testing'],
-    capabilities: ['integration-test', 'api-testing', 'contract-testing'],
-    languages: ['typescript', 'javascript', 'python', 'java'],
-    frameworks: ['jest', 'vitest', 'pytest', 'junit'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['integration', 'component'],
-  }),
-
-  // Visual & Accessibility Domain
-  createAgentProfile({
-    id: 'qe-visual-tester',
-    name: 'QE Visual Tester',
-    description: 'Visual regression testing with AI-powered screenshot comparison and accessibility validation',
-    domains: ['visual-accessibility'],
-    capabilities: ['visual-regression', 'screenshot', 'percy', 'chromatic', 'wcag', 'aria'],
-    frameworks: ['playwright', 'cypress'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['visual', 'regression', 'screenshots'],
-  }),
-  createAgentProfile({
-    id: 'qe-a11y-ally',
-    name: 'QE Accessibility Ally',
-    description: 'Developer-focused accessibility agent delivering copy-paste ready fixes, WCAG 2.2 compliance, and AI-powered video caption generation',
-    domains: ['visual-accessibility'],
-    capabilities: ['wcag', 'aria', 'screen-reader', 'contrast'],
-    frameworks: ['playwright', 'cypress'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['wcag', 'a11y', 'accessibility'],
-  }),
-
-  // Performance Domain
-  createAgentProfile({
-    id: 'qe-performance-tester',
-    name: 'QE Performance Tester',
-    description: 'Performance testing with load orchestration and bottleneck detection',
-    domains: ['chaos-resilience'],
-    capabilities: ['load-testing', 'stress-testing', 'k6', 'artillery', 'benchmark'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['load', 'stress', 'performance'],
-  }),
-  createAgentProfile({
-    id: 'qe-performance-validator',
-    name: 'QE Performance Validator',
-    description: 'Validates performance metrics against SLAs and benchmarks',
-    domains: ['chaos-resilience'],
-    capabilities: ['benchmark', 'load-testing'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['sla', 'validation', 'benchmark'],
-  }),
-
-  // Chaos & Resilience Domain
-  createAgentProfile({
-    id: 'qe-chaos-engineer',
-    name: 'QE Chaos Engineer',
-    description: 'Resilience testing with controlled fault injection and blast radius management',
-    domains: ['chaos-resilience'],
-    capabilities: ['chaos-testing', 'resilience', 'fault-injection'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['chaos', 'fault-injection', 'resilience'],
-  }),
-
-  // Test Data Domain
-  createAgentProfile({
-    id: 'qe-test-data-architect',
-    name: 'QE Test Data Architect',
-    description: 'Generates realistic, schema-aware test data at 10k+ records/sec with referential integrity and GDPR compliance',
-    domains: ['test-generation'],
-    capabilities: ['test-data'],
-    languages: ['typescript', 'javascript', 'python'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['data', 'generation', 'gdpr'],
-  }),
-  createAgentProfile({
-    id: 'qe-test-data-architect-sub',
-    name: 'QE Test Data Architect Sub',
-    description: 'Designs and generates high-volume test datasets with relationship preservation',
-    domains: ['test-generation'],
-    capabilities: ['test-data'],
-    languages: ['typescript', 'javascript', 'python'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['data', 'relationships'],
-  }),
-  createAgentProfile({
-    id: 'qe-data-generator',
-    name: 'QE Data Generator',
-    description: 'Generates realistic test data for various scenarios',
-    domains: ['test-generation'],
-    capabilities: ['test-data'],
-    languages: ['typescript', 'javascript', 'python'],
-    complexity: { min: 'simple', max: 'medium' },
-    tags: ['data', 'generation'],
-  }),
-
-  // Code Intelligence Domain
-  createAgentProfile({
-    id: 'qe-code-intelligence',
-    name: 'QE Code Intelligence',
-    description: 'Knowledge graph-based code understanding with 80% token reduction via semantic search and AST analysis',
-    domains: ['code-intelligence'],
-    capabilities: ['coverage-analysis', 'gap-detection'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['knowledge-graph', 'ast', 'semantic'],
-  }),
-
-  // Requirements & Defect Domain
-  createAgentProfile({
-    id: 'qe-requirements-validator',
-    name: 'QE Requirements Validator',
-    description: 'Validates requirements testability and generates BDD scenarios before development begins',
-    domains: ['requirements-validation'],
-    capabilities: ['bdd', 'test-generation'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['requirements', 'bdd', 'testability'],
-  }),
-  createAgentProfile({
-    id: 'qe-production-intelligence',
-    name: 'QE Production Intelligence',
-    description: 'Converts production data into test scenarios through incident replay and RUM analysis',
-    domains: ['defect-intelligence'],
-    capabilities: ['test-generation'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['production', 'incidents', 'rum'],
-  }),
-  createAgentProfile({
-    id: 'qe-regression-risk-analyzer',
-    name: 'QE Regression Risk Analyzer',
-    description: 'Analyzes code changes to predict regression risk and intelligently select minimal test suites',
-    domains: ['defect-intelligence'],
-    capabilities: ['risk-scoring', 'coverage-analysis'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['regression', 'risk', 'selection'],
-  }),
-
-  // Fleet & Orchestration Domain
-  createAgentProfile({
-    id: 'qe-fleet-commander',
-    name: 'QE Fleet Commander',
-    description: 'Hierarchical fleet coordinator for 50+ agent orchestration with dynamic topology management and resource optimization',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['fleet', 'orchestration', 'coordination'],
-  }),
-  createAgentProfile({
-    id: 'v3-qe-queen-coordinator',
-    name: 'V3 QE Queen Coordinator',
-    description: 'V3 QE Queen Coordinator for multi-agent concurrent swarm orchestration, quality engineering workflows, and cross-agent coordination',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration', 'quality-gate'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['v3', 'queen', 'swarm'],
-  }),
-  createAgentProfile({
-    id: 'qx-partner',
-    name: 'QX Partner',
-    description: 'Quality Experience (QX) analysis combining QA advocacy and UX perspectives to co-create quality for all stakeholders',
-    domains: ['quality-assessment'],
-    capabilities: ['quality-gate'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['qx', 'ux', 'advocacy'],
-  }),
-];
-
-// ============================================================================
-// n8n Workflow Testing Agents
-// ============================================================================
-
-const n8nAgents: QEAgentProfile[] = [
-  createAgentProfile({
-    id: 'n8n-base-agent',
-    name: 'n8n Base Agent',
-    description: 'Abstract base agent for n8n workflow automation testing - provides common utilities for all n8n testing agents',
-    domains: ['test-generation'],
-    capabilities: ['test-generation', 'test-orchestration'],
-    complexity: { min: 'simple', max: 'simple' },
-    tags: ['n8n', 'base', 'workflow'],
-  }),
-  createAgentProfile({
-    id: 'n8n-workflow-executor',
-    name: 'n8n Workflow Executor',
-    description: 'Execute and validate n8n workflows programmatically with test data injection, output assertions, and data flow validation',
-    domains: ['test-execution'],
-    capabilities: ['test-orchestration', 'integration-test'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['n8n', 'execution', 'validation'],
-  }),
-  createAgentProfile({
-    id: 'n8n-unit-tester',
-    name: 'n8n Unit Tester',
-    description: 'Unit test custom n8n node functions with Jest/Vitest integration, function isolation, mock data injection, and coverage reporting',
-    domains: ['test-generation'],
-    capabilities: ['unit-test', 'test-generation'],
-    frameworks: ['jest', 'vitest'],
-    complexity: { min: 'simple', max: 'medium' },
-    tags: ['n8n', 'unit', 'isolation'],
-  }),
-  createAgentProfile({
-    id: 'n8n-integration-test',
-    name: 'n8n Integration Tester',
-    description: 'Test n8n node integrations with external services including API contract validation, authentication flows, rate limiting, and error handling',
-    domains: ['contract-testing'],
-    capabilities: ['integration-test', 'api-testing', 'contract-testing'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['n8n', 'integration', 'api'],
-  }),
-  createAgentProfile({
-    id: 'n8n-trigger-test',
-    name: 'n8n Trigger Tester',
-    description: 'Test n8n workflow triggers including webhooks, schedules, polling triggers, and event-driven activation',
-    domains: ['test-execution'],
-    capabilities: ['integration-test', 'test-generation'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['n8n', 'triggers', 'webhooks'],
-  }),
-  createAgentProfile({
-    id: 'n8n-node-validator',
-    name: 'n8n Node Validator',
-    description: 'Validate n8n node configurations, connections, data mappings, and conditional routing logic',
-    domains: ['contract-testing'],
-    capabilities: ['contract-testing', 'test-generation'],
-    complexity: { min: 'simple', max: 'medium' },
-    tags: ['n8n', 'validation', 'nodes'],
-  }),
-  createAgentProfile({
-    id: 'n8n-performance-tester',
-    name: 'n8n Performance Tester',
-    description: 'Load and stress testing for n8n workflows using k6/Artillery with execution time analysis, rate limit testing, and bottleneck detection',
-    domains: ['chaos-resilience'],
-    capabilities: ['load-testing', 'stress-testing', 'k6', 'artillery', 'benchmark'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['n8n', 'performance', 'load'],
-  }),
-  createAgentProfile({
-    id: 'n8n-security-auditor',
-    name: 'n8n Security Auditor',
-    description: 'Security vulnerability scanning for n8n workflows including credential exposure, injection risks, OWASP compliance, and secret detection',
-    domains: ['security-compliance'],
-    capabilities: ['sast', 'vulnerability', 'owasp', 'security-scanning'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['n8n', 'security', 'owasp'],
-  }),
-  createAgentProfile({
-    id: 'n8n-compliance-validator',
-    name: 'n8n Compliance Validator',
-    description: 'Regulatory compliance testing for n8n workflows including GDPR, CCPA, HIPAA, SOC2, and PCI-DSS validation',
-    domains: ['security-compliance'],
-    capabilities: ['security-scanning'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['n8n', 'compliance', 'gdpr'],
-  }),
-  createAgentProfile({
-    id: 'n8n-bdd-scenario-tester',
-    name: 'n8n BDD Scenario Tester',
-    description: 'BDD/Gherkin scenario testing for n8n workflows with Cucumber integration, business requirement mapping, and stakeholder-friendly reports',
-    domains: ['requirements-validation'],
-    capabilities: ['bdd', 'test-generation'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['n8n', 'bdd', 'gherkin'],
-  }),
-  createAgentProfile({
-    id: 'n8n-expression-validator',
-    name: 'n8n Expression Validator',
-    description: 'Validate n8n expressions and data transformations with syntax checking, context-aware testing, and security analysis',
-    domains: ['code-intelligence'],
-    capabilities: ['test-generation', 'security-scanning'],
-    complexity: { min: 'simple', max: 'medium' },
-    tags: ['n8n', 'expressions', 'validation'],
-  }),
-  createAgentProfile({
-    id: 'n8n-version-comparator',
-    name: 'n8n Version Comparator',
-    description: 'Workflow version diff and regression detection with JSON comparison, change impact analysis, migration validation, and rollback testing',
-    domains: ['defect-intelligence'],
-    capabilities: ['risk-scoring', 'test-generation'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['n8n', 'version', 'diff'],
-  }),
-  createAgentProfile({
-    id: 'n8n-chaos-tester',
-    name: 'n8n Chaos Tester',
-    description: 'Chaos engineering for n8n workflows with controlled fault injection, service failure simulation, recovery validation, and resilience testing',
-    domains: ['chaos-resilience'],
-    capabilities: ['chaos-testing', 'resilience', 'fault-injection'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['n8n', 'chaos', 'resilience'],
-  }),
-  createAgentProfile({
-    id: 'n8n-ci-orchestrator',
-    name: 'n8n CI Orchestrator',
-    description: 'CI/CD pipeline integration for n8n workflows with REST API triggers, automated regression testing, GitHub Actions/Jenkins integration, and test scheduling',
-    domains: ['test-execution'],
-    capabilities: ['test-orchestration', 'integration-test'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['n8n', 'ci', 'cd'],
-  }),
-  createAgentProfile({
-    id: 'n8n-monitoring-validator',
-    name: 'n8n Monitoring Validator',
-    description: 'Validate monitoring and alerting configurations for n8n workflows including error tracking, alert rules, SLA compliance, and observability checks',
-    domains: ['quality-assessment'],
-    capabilities: ['quality-gate', 'deployment-readiness'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['n8n', 'monitoring', 'alerting'],
-  }),
-];
-
-// ============================================================================
-// General Purpose Agents (with QE capabilities)
-// ============================================================================
-
-const generalAgents: QEAgentProfile[] = [
-  createAgentProfile({
-    id: 'tester',
-    name: 'Tester',
-    description: 'Comprehensive testing and quality assurance specialist with AI-powered test generation',
-    domains: ['test-generation', 'test-execution'],
-    capabilities: ['test-generation', 'unit-test', 'integration-test', 'e2e-test'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go', 'rust'],
-    frameworks: ['jest', 'vitest', 'mocha', 'pytest', 'junit', 'go-test', 'rust-test', 'playwright', 'cypress'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['general', 'versatile'],
-  }),
-  createAgentProfile({
-    id: 'reviewer',
-    name: 'Reviewer',
-    description: 'Code review and quality assurance specialist with AI-powered pattern detection',
-    domains: ['quality-assessment'],
-    capabilities: ['quality-gate', 'security-scanning'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go', 'rust'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['general', 'code-review'],
-  }),
-  createAgentProfile({
-    id: 'security-auditor',
-    name: 'Security Auditor',
-    description: 'Advanced security auditor with self-learning vulnerability detection, CVE database search, and compliance auditing',
-    domains: ['security-compliance'],
-    capabilities: ['sast', 'dast', 'vulnerability', 'owasp', 'security-scanning'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go', 'rust'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['security', 'cve', 'compliance'],
-  }),
-  createAgentProfile({
-    id: 'security-architect',
-    name: 'Security Architect',
-    description: 'V3 Security Architecture specialist with ReasoningBank learning, HNSW threat pattern search, and zero-trust design capabilities',
-    domains: ['security-compliance'],
-    capabilities: ['sast', 'vulnerability', 'owasp', 'security-scanning'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['architecture', 'zero-trust'],
-  }),
-  createAgentProfile({
-    id: 'performance-engineer',
-    name: 'Performance Engineer',
-    description: 'V3 Performance Engineering Agent specialized in Flash Attention optimization, WASM SIMD acceleration, and comprehensive performance profiling',
-    domains: ['chaos-resilience'],
-    capabilities: ['load-testing', 'stress-testing', 'benchmark'],
-    languages: ['typescript', 'javascript', 'python', 'go', 'rust'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['performance', 'optimization'],
-  }),
-  createAgentProfile({
-    id: 'code-analyzer',
-    name: 'Code Analyzer',
-    description: 'Advanced code quality analysis agent for comprehensive code reviews and improvements',
-    domains: ['code-intelligence', 'quality-assessment'],
-    capabilities: ['coverage-analysis', 'gap-detection', 'quality-gate'],
-    languages: ['typescript', 'javascript', 'python', 'java', 'go', 'rust'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['analysis', 'quality'],
-  }),
-  createAgentProfile({
-    id: 'cicd-engineer',
-    name: 'CI/CD Engineer',
-    description: 'Specialized agent for GitHub Actions CI/CD pipeline creation and optimization',
-    domains: ['test-execution'],
-    capabilities: ['test-orchestration', 'deployment-readiness'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['cicd', 'github-actions'],
-  }),
-];
-
-// ============================================================================
-// V3 Specialized Agents
-// ============================================================================
-
-const v3SpecializedAgents: QEAgentProfile[] = [
-  createAgentProfile({
-    id: 'reasoningbank-learner',
-    name: 'ReasoningBank Learner',
-    description: 'V3 ReasoningBank integration specialist for trajectory tracking, verdict judgment, pattern distillation, and experience replay using HNSW-indexed memory',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['v3', 'reasoningbank', 'learning'],
-  }),
-  createAgentProfile({
-    id: 'adr-architect',
-    name: 'ADR Architect',
-    description: 'V3 Architecture Decision Record specialist that documents, tracks, and enforces architectural decisions with ReasoningBank integration for pattern learning',
-    domains: ['learning-optimization'],
-    capabilities: ['quality-gate'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['v3', 'adr', 'architecture'],
-  }),
-  createAgentProfile({
-    id: 'ddd-domain-expert',
-    name: 'DDD Domain Expert',
-    description: 'V3 Domain-Driven Design specialist for bounded context identification, aggregate design, domain modeling, and ubiquitous language enforcement',
-    domains: ['code-intelligence'],
-    capabilities: ['quality-gate'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['v3', 'ddd', 'domain'],
-  }),
-  createAgentProfile({
-    id: 'v3-integration-architect',
-    name: 'V3 Integration Architect',
-    description: 'V3 deep agentic-flow integration specialist implementing ADR-001 for eliminating duplicate code and building claude-flow as a specialized extension',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['v3', 'integration', 'agentic-flow'],
-  }),
-  createAgentProfile({
-    id: 'memory-specialist',
-    name: 'Memory Specialist',
-    description: 'V3 memory optimization specialist with HNSW indexing, hybrid backend management, vector quantization, and EWC++ for preventing catastrophic forgetting',
-    domains: ['learning-optimization'],
-    capabilities: ['sublinear-analysis'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['v3', 'memory', 'hnsw'],
-  }),
-  createAgentProfile({
-    id: 'claims-authorizer',
-    name: 'Claims Authorizer',
-    description: 'V3 Claims-based authorization specialist implementing ADR-010 for fine-grained access control across swarm agents and MCP tools',
-    domains: ['security-compliance'],
-    capabilities: ['security-scanning'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['v3', 'claims', 'authorization'],
-  }),
-  createAgentProfile({
-    id: 'sparc-orchestrator',
-    name: 'SPARC Orchestrator',
-    description: 'V3 SPARC methodology orchestrator that coordinates Specification, Pseudocode, Architecture, Refinement, and Completion phases with ReasoningBank learning',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['v3', 'sparc', 'methodology'],
-  }),
-  createAgentProfile({
-    id: 'sona-learning-optimizer',
-    name: 'SONA Learning Optimizer',
-    description: 'V3 SONA-powered self-optimizing agent using claude-flow neural tools for adaptive learning, pattern discovery, and continuous quality improvement with sub-millisecond overhead',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['v3', 'sona', 'self-learning'],
-  }),
-  createAgentProfile({
-    id: 'safla-neural',
-    name: 'SAFLA Neural',
-    description: 'Self-Aware Feedback Loop Algorithm (SAFLA) neural specialist that creates intelligent, memory-persistent AI systems with self-learning capabilities',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['v3', 'safla', 'neural'],
-  }),
-  createAgentProfile({
-    id: 'production-validator',
-    name: 'Production Validator',
-    description: 'Production validation specialist ensuring applications are fully implemented and deployment-ready',
-    domains: ['quality-assessment'],
-    capabilities: ['deployment-readiness', 'quality-gate'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['production', 'validation'],
-  }),
-  createAgentProfile({
-    id: 'tdd-london-swarm',
-    name: 'TDD London Swarm',
-    description: 'TDD London School specialist for mock-driven development within swarm coordination',
-    domains: ['test-generation'],
-    capabilities: ['tdd', 'unit-test', 'test-generation'],
-    languages: ['typescript', 'javascript', 'python'],
-    frameworks: ['jest', 'vitest', 'pytest'],
-    complexity: { min: 'medium', max: 'complex' },
-    tags: ['tdd', 'london', 'mocks'],
-  }),
-];
-
-// ============================================================================
-// Swarm & Coordination Agents
-// ============================================================================
-
-const swarmAgents: QEAgentProfile[] = [
-  createAgentProfile({
-    id: 'queen-coordinator',
-    name: 'Queen Coordinator',
-    description: 'The sovereign orchestrator of hierarchical hive operations, managing strategic decisions, resource allocation, and maintaining hive coherence',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['queen', 'hive', 'orchestration'],
-  }),
-  createAgentProfile({
-    id: 'swarm-memory-manager',
-    name: 'Swarm Memory Manager',
-    description: 'V3 distributed memory manager for cross-agent state synchronization, CRDT replication, and namespace coordination across the swarm',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['swarm', 'memory', 'crdt'],
-  }),
-  createAgentProfile({
-    id: 'worker-specialist',
-    name: 'Worker Specialist',
-    description: 'Dedicated task execution specialist that carries out assigned work with precision, continuously reporting progress through memory coordination',
-    domains: ['test-execution'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'simple', max: 'complex' },
-    tags: ['worker', 'execution'],
-  }),
-  createAgentProfile({
-    id: 'collective-intelligence-coordinator',
-    name: 'Collective Intelligence Coordinator',
-    description: 'Hive-mind collective decision making with Byzantine fault-tolerant consensus, attention-based coordination, and emergent intelligence patterns',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['collective', 'consensus'],
-  }),
-  createAgentProfile({
-    id: 'scout-explorer',
-    name: 'Scout Explorer',
-    description: 'Information reconnaissance specialist that explores unknown territories, gathers intelligence, and reports findings to the hive mind',
-    domains: ['code-intelligence'],
-    capabilities: ['coverage-analysis', 'gap-detection'],
-    complexity: { min: 'simple', max: 'medium' },
-    tags: ['scout', 'exploration'],
-  }),
-  createAgentProfile({
-    id: 'adaptive-coordinator',
-    name: 'Adaptive Coordinator',
-    description: 'Dynamic topology switching coordinator with self-organizing swarm patterns and real-time optimization',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['adaptive', 'topology'],
-  }),
-  createAgentProfile({
-    id: 'mesh-coordinator',
-    name: 'Mesh Coordinator',
-    description: 'Peer-to-peer mesh network swarm with distributed decision making and fault tolerance',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration', 'resilience'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['mesh', 'p2p'],
-  }),
-  createAgentProfile({
-    id: 'hierarchical-coordinator',
-    name: 'Hierarchical Coordinator',
-    description: 'Queen-led hierarchical swarm coordination with specialized worker delegation',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['hierarchical', 'delegation'],
-  }),
-];
-
-// ============================================================================
-// Consensus Agents
-// ============================================================================
-
-const consensusAgents: QEAgentProfile[] = [
-  createAgentProfile({
-    id: 'consensus-coordinator',
-    name: 'Consensus Coordinator',
-    description: 'Distributed consensus agent that uses sublinear solvers for fast agreement protocols in multi-agent systems',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration', 'resilience'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['consensus', 'distributed'],
-  }),
-  createAgentProfile({
-    id: 'byzantine-coordinator',
-    name: 'Byzantine Coordinator',
-    description: 'Coordinates Byzantine fault-tolerant consensus protocols with malicious actor detection',
-    domains: ['security-compliance'],
-    capabilities: ['resilience', 'security-scanning'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['byzantine', 'fault-tolerance'],
-  }),
-  createAgentProfile({
-    id: 'raft-manager',
-    name: 'Raft Manager',
-    description: 'Manages Raft consensus algorithm with leader election and log replication',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration', 'resilience'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['raft', 'leader-election'],
-  }),
-  createAgentProfile({
-    id: 'crdt-synchronizer',
-    name: 'CRDT Synchronizer',
-    description: 'Implements Conflict-free Replicated Data Types for eventually consistent state synchronization',
-    domains: ['learning-optimization'],
-    capabilities: ['test-orchestration'],
-    complexity: { min: 'complex', max: 'complex' },
-    tags: ['crdt', 'eventual-consistency'],
-  }),
-];
-
-// ============================================================================
-// Registry Export
-// ============================================================================
-
-/**
- * All QE agents in the registry
- */
-export const QE_AGENT_REGISTRY: readonly QEAgentProfile[] = Object.freeze([
-  ...v3QEAgents,
-  ...n8nAgents,
-  ...generalAgents,
-  ...v3SpecializedAgents,
-  ...swarmAgents,
-  ...consensusAgents,
-]);
-
-/**
- * Get all agents for a specific domain
- */
-export function getAgentsByDomain(domain: QEDomain): QEAgentProfile[] {
-  return QE_AGENT_REGISTRY.filter(agent => agent.domains.includes(domain));
-}
-
-/**
- * Get all agents with a specific capability
- */
-export function getAgentsByCapability(capability: AgentCapability): QEAgentProfile[] {
-  return QE_AGENT_REGISTRY.filter(agent => agent.capabilities.includes(capability));
-}
-
-/**
- * Get all agents that support a specific language
- */
-export function getAgentsByLanguage(language: ProgrammingLanguage): QEAgentProfile[] {
-  return QE_AGENT_REGISTRY.filter(agent => agent.languages?.includes(language));
-}
-
-/**
- * Get all agents that support a specific framework
- */
-export function getAgentsByFramework(framework: TestFramework): QEAgentProfile[] {
-  return QE_AGENT_REGISTRY.filter(agent => agent.frameworks?.includes(framework));
-}
-
-/**
- * Get all agents that can handle a specific complexity level
- */
-export function getAgentsByComplexity(complexity: ComplexityLevel): QEAgentProfile[] {
-  const complexityOrder: Record<ComplexityLevel, number> = {
-    simple: 0,
-    medium: 1,
-    complex: 2,
-  };
-
-  return QE_AGENT_REGISTRY.filter(agent => {
-    const minOrder = complexityOrder[agent.complexity.min];
-    const maxOrder = complexityOrder[agent.complexity.max];
-    const targetOrder = complexityOrder[complexity];
-    return targetOrder >= minOrder && targetOrder <= maxOrder;
-  });
-}
-
-/**
- * Get an agent by ID
- */
-export function getAgentById(id: string): QEAgentProfile | undefined {
-  return QE_AGENT_REGISTRY.find(agent => agent.id === id);
-}
-
-/**
- * Get agent count by category
- */
-export function getAgentCounts(): {
-  v3QE: number;
-  n8n: number;
-  general: number;
-  v3Specialized: number;
-  swarm: number;
-  consensus: number;
-  total: number;
-} {
-  return {
-    v3QE: v3QEAgents.length,
-    n8n: n8nAgents.length,
-    general: generalAgents.length,
-    v3Specialized: v3SpecializedAgents.length,
-    swarm: swarmAgents.length,
-    consensus: consensusAgents.length,
-    total: QE_AGENT_REGISTRY.length,
-  };
-}