@bryan-thompson/inspector-assessment-client 1.31.0 → 1.32.1

package/lib/services/assessment/AssessmentOrchestrator.js

@@ -6,41 +6,18 @@
  * @module AssessmentOrchestrator
  */
 import { DEFAULT_ASSESSMENT_CONFIG, } from "../../lib/assessmentTypes.js";
-// Core assessment modules
-import { FunctionalityAssessor } from "./modules/FunctionalityAssessor.js";
-import { SecurityAssessor } from "./modules/SecurityAssessor.js";
-import { DocumentationAssessor } from "./modules/DocumentationAssessor.js";
-import { ErrorHandlingAssessor } from "./modules/ErrorHandlingAssessor.js";
-import { UsabilityAssessor } from "./modules/UsabilityAssessor.js";
-// Extended assessment modules - unified protocol compliance
-import { ProtocolComplianceAssessor } from "./modules/ProtocolComplianceAssessor.js";
-// New MCP Directory Compliance Gap assessors
-import { AUPComplianceAssessor } from "./modules/AUPComplianceAssessor.js";
-import { ToolAnnotationAssessor } from "./modules/ToolAnnotationAssessor.js";
-import { ProhibitedLibrariesAssessor } from "./modules/ProhibitedLibrariesAssessor.js";
-import { ManifestValidationAssessor } from "./modules/ManifestValidationAssessor.js";
-import { PortabilityAssessor } from "./modules/PortabilityAssessor.js";
-import { ExternalAPIScannerAssessor } from "./modules/ExternalAPIScannerAssessor.js";
-import { TemporalAssessor } from "./modules/TemporalAssessor.js";
-import { AuthenticationAssessor } from "./modules/AuthenticationAssessor.js";
-// New capability assessors
-import { ResourceAssessor } from "./modules/ResourceAssessor.js";
-import { PromptAssessor } from "./modules/PromptAssessor.js";
-import { CrossCapabilitySecurityAssessor } from "./modules/CrossCapabilitySecurityAssessor.js";
-// Code quality assessors
-import { FileModularizationAssessor } from "./modules/FileModularizationAssessor.js";
-// Official MCP conformance testing
-import { ConformanceAssessor } from "./modules/ConformanceAssessor.js";
-// Note: ProtocolConformanceAssessor merged into ProtocolComplianceAssessor (v1.25.2)
-// Pattern configuration for tool annotation assessment
-import { loadPatternConfig, compilePatterns, } from "./config/annotationPatterns.js";
+// Note: All assessor module imports now handled by registry/AssessorDefinitions.ts (Issue #91)
 // Claude Code integration for intelligent analysis
 import { ClaudeCodeBridge, FULL_CLAUDE_CODE_CONFIG, } from "./lib/claudeCodeBridge.js";
 import { TestDataGenerator } from "./TestDataGenerator.js";
 // Structured logging
 import { createLogger, DEFAULT_LOGGING_CONFIG } from "./lib/logger.js";
 // Extracted helpers for testability
-import { emitModuleStartedEvent, emitModuleProgress, determineOverallStatus, generateSummary, generateRecommendations, } from "./orchestratorHelpers.js";
+import { determineOverallStatus, generateSummary, generateRecommendations, } from "./orchestratorHelpers.js";
+// Registry pattern for assessor management (Issue #91)
+import { AssessorRegistry, ASSESSOR_DEFINITIONS } from "./registry/index.js";
+// Module scoring for dual-key output (Issue #124)
+import { calculateModuleScore } from "../../lib/moduleScoring.js";
 /**
  * Main orchestrator class for running MCP server assessments
  *
@@ -61,32 +38,9 @@ export class AssessmentOrchestrator {
     // Claude Code Bridge for intelligent analysis
     claudeBridge;
     claudeEnabled = false;
-    // Core assessors (optional to support --skip-modules)
-    functionalityAssessor;
-    securityAssessor;
-    documentationAssessor;
-    errorHandlingAssessor;
-    usabilityAssessor;
-    // Extended assessors - unified protocol compliance
-    protocolComplianceAssessor;
-    // New MCP Directory Compliance Gap assessors
-    aupComplianceAssessor;
-    toolAnnotationAssessor;
-    prohibitedLibrariesAssessor;
-    manifestValidationAssessor;
-    portabilityAssessor;
-    externalAPIScannerAssessor;
-    temporalAssessor;
-    authenticationAssessor;
-    // New capability assessors
-    resourceAssessor;
-    promptAssessor;
-    crossCapabilityAssessor;
-    // Code quality assessors
-    fileModularizationAssessor;
-    // Official MCP conformance testing (opt-in via --conformance flag)
-    conformanceAssessor;
-    // Note: protocolConformanceAssessor merged into protocolComplianceAssessor (v1.25.2)
+    // Registry for assessor management (Issue #91)
+    // Delegates construction, test count aggregation, and Claude bridge wiring
+    registry;
     constructor(config = {}) {
         this.config = { ...DEFAULT_ASSESSMENT_CONFIG, ...config };
         // Initialize logger
@@ -104,113 +58,22 @@ export class AssessmentOrchestrator {
         if (this.config.claudeCode?.enabled) {
             this.initializeClaudeBridge(this.config.claudeCode);
         }
-        // Initialize core assessors (respects assessmentCategories config for --skip-modules)
-        if (this.config.assessmentCategories?.functionality !== false) {
-            this.functionalityAssessor = new FunctionalityAssessor(this.config);
-        }
-        if (this.config.assessmentCategories?.security !== false) {
-            this.securityAssessor = new SecurityAssessor(this.config);
-            // Wire up Claude bridge for security semantic analysis
-            if (this.claudeBridge) {
-                this.securityAssessor.setClaudeBridge(this.claudeBridge);
-            }
-        }
-        if (this.config.assessmentCategories?.documentation !== false) {
-            this.documentationAssessor = new DocumentationAssessor(this.config);
-        }
-        if (this.config.assessmentCategories?.errorHandling !== false) {
-            this.errorHandlingAssessor = new ErrorHandlingAssessor(this.config);
-        }
-        if (this.config.assessmentCategories?.usability !== false) {
-            this.usabilityAssessor = new UsabilityAssessor(this.config);
-        }
-        // Initialize extended assessors if enabled
-        if (this.config.enableExtendedAssessment) {
-            // Initialize unified protocol compliance assessor
-            // Supports new protocolCompliance flag and deprecated mcpSpecCompliance/protocolConformance
-            if (this.config.assessmentCategories?.protocolCompliance ||
-                this.config.assessmentCategories?.mcpSpecCompliance ||
-                this.config.assessmentCategories?.protocolConformance) {
-                this.protocolComplianceAssessor = new ProtocolComplianceAssessor(this.config);
-            }
-            // Initialize new MCP Directory Compliance Gap assessors
-            if (this.config.assessmentCategories?.aupCompliance) {
-                this.aupComplianceAssessor = new AUPComplianceAssessor(this.config);
-                // Wire up Claude bridge for semantic analysis
-                if (this.claudeBridge) {
-                    this.aupComplianceAssessor.setClaudeBridge(this.claudeBridge);
-                }
-            }
-            if (this.config.assessmentCategories?.toolAnnotations) {
-                this.toolAnnotationAssessor = new ToolAnnotationAssessor(this.config);
-                // Wire up Claude bridge for behavior inference
-                if (this.claudeBridge) {
-                    this.toolAnnotationAssessor.setClaudeBridge(this.claudeBridge);
-                }
-                // Load custom pattern configuration if provided
-                if (this.config.patternConfigPath) {
-                    const patternConfig = loadPatternConfig(this.config.patternConfigPath, this.logger);
-                    const compiledPatterns = compilePatterns(patternConfig);
-                    this.toolAnnotationAssessor.setPatterns(compiledPatterns);
-                }
-            }
-            if (this.config.assessmentCategories?.prohibitedLibraries) {
-                this.prohibitedLibrariesAssessor = new ProhibitedLibrariesAssessor(this.config);
-            }
-            if (this.config.assessmentCategories?.manifestValidation) {
-                this.manifestValidationAssessor = new ManifestValidationAssessor(this.config);
-            }
-            if (this.config.assessmentCategories?.portability) {
-                this.portabilityAssessor = new PortabilityAssessor(this.config);
-            }
-            if (this.config.assessmentCategories?.externalAPIScanner) {
-                this.externalAPIScannerAssessor = new ExternalAPIScannerAssessor(this.config);
-            }
-            if (this.config.assessmentCategories?.temporal) {
-                this.temporalAssessor = new TemporalAssessor(this.config);
-            }
-            if (this.config.assessmentCategories?.authentication) {
-                this.authenticationAssessor = new AuthenticationAssessor(this.config);
-            }
-            // Initialize new capability assessors
-            if (this.config.assessmentCategories?.resources) {
-                this.resourceAssessor = new ResourceAssessor(this.config);
-            }
-            if (this.config.assessmentCategories?.prompts) {
-                this.promptAssessor = new PromptAssessor(this.config);
-            }
-            if (this.config.assessmentCategories?.crossCapability) {
-                this.crossCapabilityAssessor = new CrossCapabilitySecurityAssessor(this.config);
-            }
-            // Initialize code quality assessors
-            if (this.config.assessmentCategories?.fileModularization) {
-                this.fileModularizationAssessor = new FileModularizationAssessor(this.config);
-            }
-            // Initialize official MCP conformance testing (opt-in via --conformance flag)
-            // Requires HTTP/SSE transport with serverUrl available
-            if (this.config.assessmentCategories?.conformance) {
-                this.conformanceAssessor = new ConformanceAssessor(this.config);
-            }
-            // Note: Protocol conformance now handled by unified ProtocolComplianceAssessor above
-        }
-        // Wire up Claude bridge to TestDataGenerator for intelligent test generation
+        // Initialize registry and register all enabled assessors (Issue #91)
+        // The registry handles:
+        // - Conditional instantiation based on config flags
+        // - Deprecated flag OR logic (e.g., protocolCompliance supports 3 flags)
+        // - Custom setup (e.g., ToolAnnotationAssessor pattern config)
+        // - Claude bridge wiring for supporting assessors
+        this.registry = new AssessorRegistry(this.config);
+        this.registry.registerAll(ASSESSOR_DEFINITIONS);
+        // Wire up Claude bridge to registry (handles all supporting assessors)
         if (this.claudeBridge) {
+            this.registry.setClaudeBridge(this.claudeBridge);
             TestDataGenerator.setClaudeBridge(this.claudeBridge);
         }
         // Set logger for TestDataGenerator diagnostic output
         TestDataGenerator.setLogger(this.logger);
     }
-    /**
-     * Get the count of tools that will actually be tested based on selectedToolsForTesting config.
-     * Used for accurate progress estimation in emitModuleStartedEvent calls.
-     */
-    getToolCountForTesting(tools) {
-        if (this.config.selectedToolsForTesting !== undefined) {
-            const selectedNames = new Set(this.config.selectedToolsForTesting);
-            return tools.filter((tool) => selectedNames.has(tool.name)).length;
-        }
-        return tools.length;
-    }
     /**
      * Initialize Claude Code Bridge for intelligent analysis
      * This enables semantic AUP violation analysis, behavior inference, and intelligent test generation
@@ -242,17 +105,9 @@ export class AssessmentOrchestrator {
             enabled: true,
         };
         this.initializeClaudeBridge(bridgeConfig);
-        // Wire up to existing assessors
+        // Wire up to all supporting assessors via registry
         if (this.claudeBridge) {
-            if (this.aupComplianceAssessor) {
-                this.aupComplianceAssessor.setClaudeBridge(this.claudeBridge);
-            }
-            if (this.toolAnnotationAssessor) {
-                this.toolAnnotationAssessor.setClaudeBridge(this.claudeBridge);
-            }
-            if (this.securityAssessor) {
-                this.securityAssessor.setClaudeBridge(this.claudeBridge);
-            }
+            this.registry.setClaudeBridge(this.claudeBridge);
             TestDataGenerator.setClaudeBridge(this.claudeBridge);
         }
     }
@@ -270,55 +125,6 @@ export class AssessmentOrchestrator {
     getClaudeBridge() {
         return this.claudeBridge;
     }
-    /**
-     * Reset test counts for all assessors
-     */
-    resetAllTestCounts() {
-        this.functionalityAssessor?.resetTestCount();
-        this.securityAssessor?.resetTestCount();
-        this.documentationAssessor?.resetTestCount();
-        this.errorHandlingAssessor?.resetTestCount();
-        this.usabilityAssessor?.resetTestCount();
-        if (this.protocolComplianceAssessor) {
-            this.protocolComplianceAssessor.resetTestCount();
-        }
-        // Reset new assessors
-        if (this.aupComplianceAssessor) {
-            this.aupComplianceAssessor.resetTestCount();
-        }
-        if (this.toolAnnotationAssessor) {
-            this.toolAnnotationAssessor.resetTestCount();
-        }
-        if (this.prohibitedLibrariesAssessor) {
-            this.prohibitedLibrariesAssessor.resetTestCount();
-        }
-        if (this.manifestValidationAssessor) {
-            this.manifestValidationAssessor.resetTestCount();
-        }
-        if (this.portabilityAssessor) {
-            this.portabilityAssessor.resetTestCount();
-        }
-        if (this.authenticationAssessor) {
-            this.authenticationAssessor.resetTestCount();
-        }
-        // Reset new capability assessors
-        if (this.resourceAssessor) {
-            this.resourceAssessor.resetTestCount();
-        }
-        if (this.promptAssessor) {
-            this.promptAssessor.resetTestCount();
-        }
-        if (this.crossCapabilityAssessor) {
-            this.crossCapabilityAssessor.resetTestCount();
-        }
-        if (this.fileModularizationAssessor) {
-            this.fileModularizationAssessor.resetTestCount();
-        }
-        // Reset official conformance assessor
-        if (this.conformanceAssessor) {
-            this.conformanceAssessor.resetTestCount();
-        }
-    }
     /**
      * Run a complete assessment on an MCP server
      * @public
@@ -326,298 +132,14 @@ export class AssessmentOrchestrator {
     async runFullAssessment(context) {
         this.startTime = Date.now();
         this.totalTestsRun = 0;
-        this.resetAllTestCounts();
-        // Run assessments in parallel if enabled
-        const assessmentPromises = [];
-        const assessmentResults = {};
-        // PHASE 0: Temporal Assessment (ALWAYS runs first, before parallel/sequential phases)
-        // This ensures temporal captures clean baseline before other modules trigger rug pulls
-        if (this.temporalAssessor) {
-            const toolCount = this.getToolCountForTesting(context.tools);
-            const invocationsPerTool = this.config.temporalInvocations ?? 25;
-            emitModuleStartedEvent("Temporal", toolCount * invocationsPerTool, toolCount);
-            assessmentResults.temporal = await this.temporalAssessor.assess(context);
-            emitModuleProgress("Temporal", assessmentResults.temporal.status, assessmentResults.temporal, this.temporalAssessor.getTestCount());
-        }
-        if (this.config.parallelTesting) {
-            // Calculate estimates for module_started events
-            const toolCount = this.getToolCountForTesting(context.tools);
-            const securityPatterns = this.config.securityPatternsToTest || 17;
-            // Core assessments - only emit and run if not skipped
-            if (this.functionalityAssessor) {
-                emitModuleStartedEvent("Functionality", toolCount * 10, toolCount);
-                assessmentPromises.push(this.functionalityAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Functionality", r.status, r, this.functionalityAssessor.getTestCount());
-                    return (assessmentResults.functionality = r);
-                }));
-            }
-            if (this.securityAssessor) {
-                emitModuleStartedEvent("Security", securityPatterns * toolCount, toolCount);
-                assessmentPromises.push(this.securityAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Security", r.status, r, this.securityAssessor.getTestCount());
-                    return (assessmentResults.security = r);
-                }));
-            }
-            if (this.documentationAssessor) {
-                emitModuleStartedEvent("Documentation", 5, toolCount);
-                assessmentPromises.push(this.documentationAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Documentation", r.status, r, this.documentationAssessor.getTestCount());
-                    return (assessmentResults.documentation = r);
-                }));
-            }
-            if (this.errorHandlingAssessor) {
-                emitModuleStartedEvent("Error Handling", toolCount * 5, toolCount);
-                assessmentPromises.push(this.errorHandlingAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Error Handling", r.status, r, this.errorHandlingAssessor.getTestCount());
-                    return (assessmentResults.errorHandling = r);
-                }));
-            }
-            if (this.usabilityAssessor) {
-                emitModuleStartedEvent("Usability", 10, toolCount);
-                assessmentPromises.push(this.usabilityAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Usability", r.status, r, this.usabilityAssessor.getTestCount());
-                    return (assessmentResults.usability = r);
-                }));
-            }
-            // Extended assessments - unified protocol compliance
-            if (this.protocolComplianceAssessor) {
-                emitModuleStartedEvent("Protocol Compliance", 10, toolCount);
-                assessmentPromises.push(this.protocolComplianceAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Protocol Compliance", r.status, r, this.protocolComplianceAssessor.getTestCount());
-                    return (assessmentResults.mcpSpecCompliance = r);
-                }));
-            }
-            // New MCP Directory Compliance Gap assessments
-            if (this.aupComplianceAssessor) {
-                emitModuleStartedEvent("AUP", 20, toolCount);
-                assessmentPromises.push(this.aupComplianceAssessor.assess(context).then((r) => {
-                    emitModuleProgress("AUP", r.status, r, this.aupComplianceAssessor.getTestCount());
-                    return (assessmentResults.aupCompliance = r);
-                }));
-            }
-            if (this.toolAnnotationAssessor) {
-                emitModuleStartedEvent("Annotations", toolCount, toolCount);
-                assessmentPromises.push(this.toolAnnotationAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Annotations", r.status, r, this.toolAnnotationAssessor.getTestCount());
-                    return (assessmentResults.toolAnnotations = r);
-                }));
-            }
-            if (this.prohibitedLibrariesAssessor) {
-                emitModuleStartedEvent("Libraries", 5, toolCount);
-                assessmentPromises.push(this.prohibitedLibrariesAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Libraries", r.status, r, this.prohibitedLibrariesAssessor.getTestCount());
-                    return (assessmentResults.prohibitedLibraries = r);
-                }));
-            }
-            if (this.manifestValidationAssessor) {
-                emitModuleStartedEvent("Manifest", 10, toolCount);
-                assessmentPromises.push(this.manifestValidationAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Manifest", r.status, r, this.manifestValidationAssessor.getTestCount());
-                    return (assessmentResults.manifestValidation = r);
-                }));
-            }
-            if (this.portabilityAssessor) {
-                emitModuleStartedEvent("Portability", 10, toolCount);
-                assessmentPromises.push(this.portabilityAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Portability", r.status, r, this.portabilityAssessor.getTestCount());
-                    return (assessmentResults.portability = r);
-                }));
-            }
-            if (this.externalAPIScannerAssessor) {
-                emitModuleStartedEvent("External APIs", 10, toolCount);
-                assessmentPromises.push(this.externalAPIScannerAssessor.assess(context).then((r) => {
-                    emitModuleProgress("External APIs", r.status, r, this.externalAPIScannerAssessor.getTestCount());
-                    return (assessmentResults.externalAPIScanner = r);
-                }));
-            }
-            if (this.authenticationAssessor) {
-                const sourceFileCount = context.sourceCodeFiles?.size || 0;
-                emitModuleStartedEvent("Authentication", sourceFileCount, sourceFileCount);
-                assessmentPromises.push(this.authenticationAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Authentication", r.status, r, this.authenticationAssessor.getTestCount());
-                    return (assessmentResults.authentication = r);
-                }));
-            }
-            // NOTE: Temporal runs in PHASE 0 above, not in parallel with other modules
-            // New capability assessors
-            if (this.resourceAssessor) {
-                const resourceCount = (context.resources?.length || 0) +
-                    (context.resourceTemplates?.length || 0);
-                emitModuleStartedEvent("Resources", resourceCount * 5, resourceCount);
-                assessmentPromises.push(this.resourceAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Resources", r.status, r, this.resourceAssessor.getTestCount());
-                    return (assessmentResults.resources = r);
-                }));
-            }
-            if (this.promptAssessor) {
-                const promptCount = context.prompts?.length || 0;
-                emitModuleStartedEvent("Prompts", promptCount * 10, promptCount);
-                assessmentPromises.push(this.promptAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Prompts", r.status, r, this.promptAssessor.getTestCount());
-                    return (assessmentResults.prompts = r);
-                }));
-            }
-            if (this.crossCapabilityAssessor) {
-                const capabilityCount = toolCount +
-                    (context.resources?.length || 0) +
-                    (context.prompts?.length || 0);
-                emitModuleStartedEvent("Cross-Capability", capabilityCount * 3, capabilityCount);
-                assessmentPromises.push(this.crossCapabilityAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Cross-Capability", r.status, r, this.crossCapabilityAssessor.getTestCount());
-                    return (assessmentResults.crossCapability = r);
-                }));
-            }
-            if (this.fileModularizationAssessor) {
-                const sourceFileCount = context.sourceCodeFiles?.size || 0;
-                emitModuleStartedEvent("File Modularization", sourceFileCount, sourceFileCount);
-                assessmentPromises.push(this.fileModularizationAssessor.assess(context).then((r) => {
-                    emitModuleProgress("File Modularization", r.status, r, this.fileModularizationAssessor.getTestCount());
-                    return (assessmentResults.fileModularization = r);
-                }));
-            }
-            // Official MCP conformance testing (opt-in, requires HTTP/SSE transport)
-            if (this.conformanceAssessor) {
-                // Conformance tests ~7 server scenarios
-                emitModuleStartedEvent("Conformance", 7, toolCount);
-                assessmentPromises.push(this.conformanceAssessor.assess(context).then((r) => {
-                    emitModuleProgress("Conformance", r.status, r, this.conformanceAssessor.getTestCount());
-                    return (assessmentResults.conformance = r);
-                }));
-            }
-            // Note: Protocol Conformance now handled by unified ProtocolComplianceAssessor above
-            await Promise.all(assessmentPromises);
-        }
-        else {
-            // Sequential execution with module_started events
-            const toolCount = this.getToolCountForTesting(context.tools);
-            const securityPatterns = this.config.securityPatternsToTest || 17;
-            // NOTE: Temporal runs in PHASE 0 above, before sequential/parallel phases
-            // Core assessments - only emit and run if not skipped
-            if (this.functionalityAssessor) {
-                // Functionality: ~10 scenarios per tool
-                emitModuleStartedEvent("Functionality", toolCount * 10, toolCount);
-                assessmentResults.functionality =
-                    await this.functionalityAssessor.assess(context);
-                emitModuleProgress("Functionality", assessmentResults.functionality.status, assessmentResults.functionality, this.functionalityAssessor.getTestCount());
-            }
-            if (this.securityAssessor) {
-                // Security: patterns × tools
-                emitModuleStartedEvent("Security", securityPatterns * toolCount, toolCount);
-                assessmentResults.security =
-                    await this.securityAssessor.assess(context);
-                emitModuleProgress("Security", assessmentResults.security.status, assessmentResults.security, this.securityAssessor.getTestCount());
-            }
-            if (this.documentationAssessor) {
-                // Documentation: ~5 static tests
-                emitModuleStartedEvent("Documentation", 5, toolCount);
-                assessmentResults.documentation =
-                    await this.documentationAssessor.assess(context);
-                emitModuleProgress("Documentation", assessmentResults.documentation.status, assessmentResults.documentation, this.documentationAssessor.getTestCount());
-            }
-            if (this.errorHandlingAssessor) {
-                // Error Handling: ~5 tests per tool
-                emitModuleStartedEvent("Error Handling", toolCount * 5, toolCount);
-                assessmentResults.errorHandling =
-                    await this.errorHandlingAssessor.assess(context);
-                emitModuleProgress("Error Handling", assessmentResults.errorHandling.status, assessmentResults.errorHandling, this.errorHandlingAssessor.getTestCount());
-            }
-            if (this.usabilityAssessor) {
-                // Usability: ~10 static tests
-                emitModuleStartedEvent("Usability", 10, toolCount);
-                assessmentResults.usability =
-                    await this.usabilityAssessor.assess(context);
-                emitModuleProgress("Usability", assessmentResults.usability.status, assessmentResults.usability, this.usabilityAssessor.getTestCount());
-            }
-            if (this.protocolComplianceAssessor) {
-                emitModuleStartedEvent("Protocol Compliance", 10, toolCount);
-                assessmentResults.mcpSpecCompliance =
-                    await this.protocolComplianceAssessor.assess(context);
-                emitModuleProgress("Protocol Compliance", assessmentResults.mcpSpecCompliance.status, assessmentResults.mcpSpecCompliance, this.protocolComplianceAssessor.getTestCount());
-            }
-            // New MCP Directory Compliance Gap assessments (sequential)
-            if (this.aupComplianceAssessor) {
-                emitModuleStartedEvent("AUP", 20, toolCount);
-                assessmentResults.aupCompliance =
-                    await this.aupComplianceAssessor.assess(context);
-                emitModuleProgress("AUP", assessmentResults.aupCompliance.status, assessmentResults.aupCompliance, this.aupComplianceAssessor.getTestCount());
-            }
-            if (this.toolAnnotationAssessor) {
-                emitModuleStartedEvent("Annotations", toolCount, toolCount);
-                assessmentResults.toolAnnotations =
-                    await this.toolAnnotationAssessor.assess(context);
-                emitModuleProgress("Annotations", assessmentResults.toolAnnotations.status, assessmentResults.toolAnnotations, this.toolAnnotationAssessor.getTestCount());
-            }
-            if (this.prohibitedLibrariesAssessor) {
-                emitModuleStartedEvent("Libraries", 5, toolCount);
-                assessmentResults.prohibitedLibraries =
-                    await this.prohibitedLibrariesAssessor.assess(context);
-                emitModuleProgress("Libraries", assessmentResults.prohibitedLibraries.status, assessmentResults.prohibitedLibraries, this.prohibitedLibrariesAssessor.getTestCount());
-            }
-            if (this.manifestValidationAssessor) {
-                emitModuleStartedEvent("Manifest", 10, toolCount);
-                assessmentResults.manifestValidation =
-                    await this.manifestValidationAssessor.assess(context);
-                emitModuleProgress("Manifest", assessmentResults.manifestValidation.status, assessmentResults.manifestValidation, this.manifestValidationAssessor.getTestCount());
-            }
-            if (this.portabilityAssessor) {
-                emitModuleStartedEvent("Portability", 10, toolCount);
-                assessmentResults.portability =
-                    await this.portabilityAssessor.assess(context);
-                emitModuleProgress("Portability", assessmentResults.portability.status, assessmentResults.portability, this.portabilityAssessor.getTestCount());
-            }
-            if (this.externalAPIScannerAssessor) {
-                emitModuleStartedEvent("External APIs", 10, toolCount);
-                assessmentResults.externalAPIScanner =
-                    await this.externalAPIScannerAssessor.assess(context);
-                emitModuleProgress("External APIs", assessmentResults.externalAPIScanner.status, assessmentResults.externalAPIScanner, this.externalAPIScannerAssessor.getTestCount());
-            }
-            if (this.authenticationAssessor) {
-                const sourceFileCount = context.sourceCodeFiles?.size || 0;
-                emitModuleStartedEvent("Authentication", sourceFileCount, sourceFileCount);
-                assessmentResults.authentication =
-                    await this.authenticationAssessor.assess(context);
-                emitModuleProgress("Authentication", assessmentResults.authentication.status, assessmentResults.authentication, this.authenticationAssessor.getTestCount());
-            }
-            // New capability assessors (sequential)
-            if (this.resourceAssessor) {
-                const resourceCount = (context.resources?.length || 0) +
-                    (context.resourceTemplates?.length || 0);
-                emitModuleStartedEvent("Resources", resourceCount * 5, resourceCount);
-                assessmentResults.resources =
-                    await this.resourceAssessor.assess(context);
-                emitModuleProgress("Resources", assessmentResults.resources.status, assessmentResults.resources, this.resourceAssessor.getTestCount());
-            }
-            if (this.promptAssessor) {
-                const promptCount = context.prompts?.length || 0;
-                emitModuleStartedEvent("Prompts", promptCount * 10, promptCount);
-                assessmentResults.prompts = await this.promptAssessor.assess(context);
-                emitModuleProgress("Prompts", assessmentResults.prompts.status, assessmentResults.prompts, this.promptAssessor.getTestCount());
-            }
-            if (this.crossCapabilityAssessor) {
-                const capabilityCount = toolCount +
-                    (context.resources?.length || 0) +
-                    (context.prompts?.length || 0);
-                emitModuleStartedEvent("Cross-Capability", capabilityCount * 3, capabilityCount);
-                assessmentResults.crossCapability =
-                    await this.crossCapabilityAssessor.assess(context);
-                emitModuleProgress("Cross-Capability", assessmentResults.crossCapability.status, assessmentResults.crossCapability, this.crossCapabilityAssessor.getTestCount());
-            }
-            if (this.fileModularizationAssessor) {
-                const sourceFileCount = context.sourceCodeFiles?.size || 0;
-                emitModuleStartedEvent("File Modularization", sourceFileCount, sourceFileCount);
-                assessmentResults.fileModularization =
-                    await this.fileModularizationAssessor.assess(context);
-                emitModuleProgress("File Modularization", assessmentResults.fileModularization.status, assessmentResults.fileModularization, this.fileModularizationAssessor.getTestCount());
-            }
-            // Official MCP conformance testing (sequential, opt-in)
-            if (this.conformanceAssessor) {
-                emitModuleStartedEvent("Conformance", 7, toolCount);
-                assessmentResults.conformance =
-                    await this.conformanceAssessor.assess(context);
-                emitModuleProgress("Conformance", assessmentResults.conformance.status, assessmentResults.conformance, this.conformanceAssessor.getTestCount());
-            }
-            // Note: Protocol Conformance now handled by unified ProtocolComplianceAssessor above
-        }
+        this.registry.resetAllTestCounts();
+        // Execute all assessors via registry (Issue #91)
+        // Registry handles:
+        // - Phase-ordered execution (Phase 0/PRE always runs first and sequentially)
+        // - Parallel vs sequential based on config.parallelTesting
+        // - JSONL events (module_started, module_progress)
+        // - Test count tracking
+        const assessmentResults = await this.registry.executeAll(context);
         // Integrate temporal findings into security.vulnerabilities for unified view
         if (assessmentResults.temporal?.rugPullsDetected &&
             assessmentResults.temporal.rugPullsDetected > 0 &&
@@ -626,6 +148,41 @@ export class AssessmentOrchestrator {
                 assessmentResults.security.vulnerabilities.push(`RUG_PULL_TEMPORAL: ${detail.tool} - Tool behavior changed after invocation ${detail.firstDeviationAt}. Requires immediate manual review.`);
             }
         }
+        // Issue #124: Dual-key output for v2.0.0 transition
+        // Output BOTH old and new keys to maintain backward compatibility
+        // Old keys (documentation, usability, mcpSpecCompliance) will be removed in v2.0.0
+        // developerExperience (new) = documentation + usability (deprecated)
+        if (assessmentResults.documentation && assessmentResults.usability) {
+            const docScore = calculateModuleScore(assessmentResults.documentation) ?? 50;
+            const usabilityScore = calculateModuleScore(assessmentResults.usability) ?? 50;
+            const combinedStatus = determineOverallStatus({
+                documentation: assessmentResults.documentation,
+                usability: assessmentResults.usability,
+            });
+            assessmentResults.developerExperience = {
+                documentation: assessmentResults.documentation,
+                usability: assessmentResults.usability,
+                status: combinedStatus,
+                score: Math.round((docScore + usabilityScore) / 2),
+            };
+            // Emit deprecation warning for old keys
+            this.logger.warn("Output keys 'documentation' and 'usability' are deprecated. " +
+                "Use 'developerExperience' instead. These keys will be removed in v2.0.0.", {
+                deprecated: ["documentation", "usability"],
+                replacement: "developerExperience",
+            });
+        }
+        // protocolCompliance (new) = mcpSpecCompliance (deprecated)
+        if (assessmentResults.mcpSpecCompliance) {
+            assessmentResults.protocolCompliance =
+                assessmentResults.mcpSpecCompliance;
+            // Emit deprecation warning for old key
+            this.logger.warn("Output key 'mcpSpecCompliance' is deprecated. " +
+                "Use 'protocolCompliance' instead. This key will be removed in v2.0.0.", {
+                deprecated: ["mcpSpecCompliance"],
+                replacement: "protocolCompliance",
+            });
+        }
         // Collect test counts from all assessors
         this.totalTestsRun = this.collectTotalTestCount();
         // Determine overall status
@@ -674,75 +231,8 @@ export class AssessmentOrchestrator {
         return this.runFullAssessment(context);
     }
     collectTotalTestCount() {
-        let total = 0;
-        // Get actual test counts from assessors (optional for --skip-modules support)
-        const functionalityCount = this.functionalityAssessor?.getTestCount() || 0;
-        const securityCount = this.securityAssessor?.getTestCount() || 0;
-        const documentationCount = this.documentationAssessor?.getTestCount() || 0;
-        const errorHandlingCount = this.errorHandlingAssessor?.getTestCount() || 0;
-        const usabilityCount = this.usabilityAssessor?.getTestCount() || 0;
-        const mcpSpecCount = this.protocolComplianceAssessor?.getTestCount() || 0;
-        // New assessor counts
-        const aupCount = this.aupComplianceAssessor?.getTestCount() || 0;
-        const annotationCount = this.toolAnnotationAssessor?.getTestCount() || 0;
-        const librariesCount = this.prohibitedLibrariesAssessor?.getTestCount() || 0;
-        const manifestCount = this.manifestValidationAssessor?.getTestCount() || 0;
-        const portabilityCount = this.portabilityAssessor?.getTestCount() || 0;
-        const authenticationCount = this.authenticationAssessor?.getTestCount() || 0;
-        const externalAPICount = this.externalAPIScannerAssessor?.getTestCount() || 0;
-        const temporalCount = this.temporalAssessor?.getTestCount() || 0;
-        // New capability assessor counts
-        const resourcesCount = this.resourceAssessor?.getTestCount() || 0;
-        const promptsCount = this.promptAssessor?.getTestCount() || 0;
-        const crossCapabilityCount = this.crossCapabilityAssessor?.getTestCount() || 0;
-        // Code quality assessor counts
-        const fileModularizationCount = this.fileModularizationAssessor?.getTestCount() || 0;
-        // Official MCP conformance test count
-        const conformanceCount = this.conformanceAssessor?.getTestCount() || 0;
-        // Note: Protocol conformance now included in mcpSpecCount (unified ProtocolComplianceAssessor)
-        this.logger.debug("Test counts by assessor", {
-            functionality: functionalityCount,
-            security: securityCount,
-            documentation: documentationCount,
-            errorHandling: errorHandlingCount,
-            usability: usabilityCount,
-            mcpSpec: mcpSpecCount,
-            aupCompliance: aupCount,
-            toolAnnotations: annotationCount,
-            prohibitedLibraries: librariesCount,
-            manifestValidation: manifestCount,
-            portability: portabilityCount,
-            authentication: authenticationCount,
-            externalAPIScanner: externalAPICount,
-            temporal: temporalCount,
-            resources: resourcesCount,
-            prompts: promptsCount,
-            crossCapability: crossCapabilityCount,
-            fileModularization: fileModularizationCount,
-            conformance: conformanceCount,
-            // Note: protocolConformance now included in mcpSpec (unified)
-        });
-        total =
-            functionalityCount +
-                securityCount +
-                documentationCount +
-                errorHandlingCount +
-                usabilityCount +
-                mcpSpecCount +
-                aupCount +
-                annotationCount +
-                librariesCount +
-                manifestCount +
-                portabilityCount +
-                authenticationCount +
-                externalAPICount +
-                temporalCount +
-                resourcesCount +
-                promptsCount +
-                crossCapabilityCount +
-                fileModularizationCount +
-                conformanceCount;
-        // Note: protocolConformance now included in mcpSpecCount (unified)
+        // Delegate to registry for centralized test count aggregation (Issue #91)
+        const total = this.registry.getTotalTestCount();
         this.logger.debug("Total test count", { total });
         return total;
     }