agentic-qe 3.10.2 → 3.10.3

package/dist/mcp/handlers/core-handlers.js

@@ -463,8 +463,8 @@ export async function handleAQEHealth() {
             ? Date.now() - state.initTime.getTime()
             : 0;
         // Collect memory stats
-        let memoryStats = { connected: false, totalEntries: 0, namespaces: 0 };
-        let hnswStats = { enabled: false, vectorCount: 0 };
+        const memoryStats = { connected: false, totalEntries: 0, namespaces: 0 };
+        const hnswStats = { enabled: false, vectorCount: 0 };
         let patternCount = 0;
         if (isInit && state.kernel) {
             const mem = state.kernel.memory;

package/dist/mcp/handlers/cross-phase-handlers.js

@@ -82,9 +82,11 @@ export async function handleCrossPhaseQuery(params) {
             signals = await memory.queryRiskSignals();
             break;
         case 'tactical':
-            const featureFilter = params.filter?.featureContext;
-            signals = await memory.querySFDIPOTSignals(featureFilter);
-            break;
+            {
+                const featureFilter = params.filter?.featureContext;
+                signals = await memory.querySFDIPOTSignals(featureFilter);
+                break;
+            }
         case 'operational':
             signals = await memory.queryTestHealthSignals();
             break;

package/dist/mcp/handlers/handler-factory.d.ts

@@ -135,6 +135,11 @@ export declare function detectAntiPatterns(sourceCode: string, language: string)
     severity: string;
     suggestion: string;
 }>;
+/**
+ * Race a promise against a timeout, resolving to `fallback` if it doesn't settle
+ * in time. The underlying promise is left to settle in the background.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, fallback: T): Promise<T>;
 /**
  * Get or create the task executor
  */

package/dist/mcp/handlers/handler-factory.js

@@ -336,6 +336,40 @@ let taskExecutor = null;
 let _feedbackLoopPromise = null;
 // Cached learning engine for pattern search (declared here for use in resetTaskExecutor)
 let cachedLearningEngine = null;
+/**
+ * Advisory-routing budget. Pattern search + model routing are optional hints, so
+ * they must never block a tool call. If they exceed this budget (e.g. a slow or
+ * stuck learning-engine init), we abandon the hint and proceed with default
+ * routing. Defense-in-depth after the QEReasoningBank init recursion that hung
+ * every MCP domain tool — a future async stall here can no longer block tools.
+ */
+const ROUTE_ADVISORY_TIMEOUT_MS = Number(process.env.AQE_ROUTE_TIMEOUT_MS) || 5000;
+/**
+ * Race a promise against a timeout, resolving to `fallback` if it doesn't settle
+ * in time. The underlying promise is left to settle in the background.
+ */
+export function withTimeout(promise, ms, fallback) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                resolve(fallback);
+            }
+        }, ms);
+        if (typeof timer.unref === 'function')
+            timer.unref();
+        promise.then((v) => { if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            resolve(v);
+        } }, () => { if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            resolve(fallback);
+        } });
+    });
+}
 /**
  * Get or create the task executor
  */
@@ -389,11 +423,14 @@ async function getLearningEngine() {
         }
         const { createAQELearningEngine } = await import('../../learning/aqe-learning-engine.js');
         const memory = kernel.memory;
-        cachedLearningEngine = createAQELearningEngine(memory, {
+        const engine = createAQELearningEngine(memory, {
             projectRoot: process.cwd(),
             enableClaudeFlow: false, // Don't need Claude Flow for pattern search
         });
-        await cachedLearningEngine.initialize();
+        // Cache only AFTER a successful init so a failed/slow init doesn't leave a
+        // half-initialized engine to be served on the next call.
+        await engine.initialize();
+        cachedLearningEngine = engine;
         return cachedLearningEngine;
     }
     catch (error) {
@@ -557,10 +594,13 @@ export function createDomainHandler(config) {
         const { queen } = getFleetState();
         let routingResult = null;
         try {
-            // Step 2: Route task to optimal model tier (ADR-051)
+            // Step 2: Route task to optimal model tier (ADR-051).
+            // Bounded by ROUTE_ADVISORY_TIMEOUT_MS — routing is an advisory hint and
+            // must never block the tool; on timeout we proceed with null routing
+            // (mapToPayload handles a null routingResult).
             const taskDescription = buildTaskDescription(params);
             const codeContext = includeCodeContext?.(params);
-            routingResult = await routeDomainTask(taskDescription, domain, codeContext);
+            routingResult = await withTimeout(routeDomainTask(taskDescription, domain, codeContext), ROUTE_ADVISORY_TIMEOUT_MS, null);
             // Step 3: Build payload and submit task
             const payload = mapToPayload(params, routingResult);
             const timeout = calculateTimeout?.(params) ?? defaultTimeout;

package/dist/mcp/http-server.js

@@ -715,6 +715,7 @@ class HTTPServerImpl {
                 // Non-fatal, discovery will return empty results
             }
         }
+        // eslint-disable-next-line no-async-promise-executor -- inner awaits are caught; server.on("error", reject) handles startup failures
         return new Promise(async (resolve, reject) => {
             this.server = createServer((req, res) => {
                 this.handleHttpRequest(req, res).catch((error) => {

package/dist/mcp/protocol-server.js

@@ -1387,7 +1387,7 @@ export class MCPProtocolServer {
                     try {
                         unlinkSync(transcriptPath);
                     }
-                    catch { }
+                    catch { /* best-effort cleanup */ }
                     const lines = result.split('\n');
                     let jsonStr = '';
                     let depth = 0;
@@ -1410,7 +1410,7 @@ export class MCPProtocolServer {
                     try {
                         unlinkSync(transcriptPath);
                     }
-                    catch { }
+                    catch { /* best-effort cleanup */ }
                     return { error: err.message?.slice(0, 300) ?? 'Unknown error' };
                 }
             },

package/dist/mcp/tools/code-intelligence/analyze.js

@@ -73,7 +73,7 @@ export class CodeAnalyzeTool extends MCPToolBase {
             if (this.isAborted(context)) {
                 return { success: false, error: 'Operation aborted' };
             }
-            let result = { action };
+            const result = { action };
             switch (action) {
                 case 'index':
                     result.indexResult = await this.executeIndex(paths, incremental, context);

package/dist/mcp/tools/learning-optimization/optimize.js

@@ -55,7 +55,7 @@ export class LearningOptimizeTool extends MCPToolBase {
             if (this.isAborted(context)) {
                 return { success: false, error: 'Operation aborted' };
             }
-            let result = { action };
+            const result = { action };
             switch (action) {
                 case 'learn':
                     result.learnResult = await this.executeLearn(domain, experienceIds, context);

package/dist/mcp/tools/qx-analysis/heuristics-engine.js

@@ -51,140 +51,150 @@ export class QXHeuristicsEngine {
                 }
                 break;
             case QXHeuristic.INTUITIVE_DESIGN:
-                const hasNav = context.domMetrics?.semanticStructure?.hasNav;
-                const focusable = context.accessibility?.focusableElementsCount || 0;
-                if (hasNav && focusable > 10) {
-                    score = 82;
-                    findings.push('Intuitive navigation and interaction design');
+                {
+                    const hasNav = context.domMetrics?.semanticStructure?.hasNav;
+                    const focusable = context.accessibility?.focusableElementsCount || 0;
+                    if (hasNav && focusable > 10) {
+                        score = 82;
+                        findings.push('Intuitive navigation and interaction design');
+                    }
+                    else {
+                        score = 55;
+                        issues.push({ description: 'Navigation or interaction patterns unclear', severity: 'medium' });
+                    }
+                    break;
                 }
-                else {
-                    score = 55;
-                    issues.push({ description: 'Navigation or interaction patterns unclear', severity: 'medium' });
-                }
-                break;
             case QXHeuristic.EXACTNESS_AND_CLARITY:
-                score = 70;
-                const hasSemanticStructure = context.domMetrics?.semanticStructure;
-                const structureScore = [
-                    hasSemanticStructure?.hasHeader,
-                    hasSemanticStructure?.hasMain,
-                    hasSemanticStructure?.hasNav,
-                    hasSemanticStructure?.hasFooter,
-                ].filter(Boolean).length;
-                score = 50 + structureScore * 10;
-                if (structureScore >= 3) {
-                    findings.push('Strong visual hierarchy with semantic HTML elements');
-                }
-                else if (structureScore >= 2) {
-                    findings.push('Moderate visual hierarchy - some semantic elements present');
-                    recommendations.push('Add more semantic HTML5 elements for clarity');
-                }
-                else {
-                    issues.push({ description: 'Weak visual hierarchy - missing semantic structure', severity: 'high' });
-                    recommendations.push('Implement semantic HTML5: header, nav, main, footer');
+                {
+                    score = 70;
+                    const hasSemanticStructure = context.domMetrics?.semanticStructure;
+                    const structureScore = [
+                        hasSemanticStructure?.hasHeader,
+                        hasSemanticStructure?.hasMain,
+                        hasSemanticStructure?.hasNav,
+                        hasSemanticStructure?.hasFooter,
+                    ].filter(Boolean).length;
+                    score = 50 + structureScore * 10;
+                    if (structureScore >= 3) {
+                        findings.push('Strong visual hierarchy with semantic HTML elements');
+                    }
+                    else if (structureScore >= 2) {
+                        findings.push('Moderate visual hierarchy - some semantic elements present');
+                        recommendations.push('Add more semantic HTML5 elements for clarity');
+                    }
+                    else {
+                        issues.push({ description: 'Weak visual hierarchy - missing semantic structure', severity: 'high' });
+                        recommendations.push('Implement semantic HTML5: header, nav, main, footer');
+                    }
+                    if (context.metadata?.description && context.metadata.description.length > 20) {
+                        score += 10;
+                        findings.push('Page has descriptive metadata');
+                    }
+                    break;
                 }
-                if (context.metadata?.description && context.metadata.description.length > 20) {
-                    score += 10;
-                    findings.push('Page has descriptive metadata');
-                }
-                break;
             case QXHeuristic.COUNTER_INTUITIVE_DESIGN:
-                score = 85; // High score means few counter-intuitive elements (good)
-                const confusingNav = !context.domMetrics?.semanticStructure?.hasNav && (context.domMetrics?.interactiveElements || 0) > 10;
-                const poorStructure = !context.domMetrics?.semanticStructure?.hasHeader && !context.domMetrics?.semanticStructure?.hasFooter;
-                if (confusingNav) {
-                    score = 45;
-                    issues.push({ description: 'Navigation structure may be counter-intuitive', severity: 'high' });
-                    recommendations.push('Add semantic navigation elements');
-                }
-                if (poorStructure) {
-                    score -= 15;
-                    issues.push({ description: 'Page structure lacks expected header/footer', severity: 'medium' });
+                {
+                    score = 85; // High score means few counter-intuitive elements (good)
+                    const confusingNav = !context.domMetrics?.semanticStructure?.hasNav && (context.domMetrics?.interactiveElements || 0) > 10;
+                    const poorStructure = !context.domMetrics?.semanticStructure?.hasHeader && !context.domMetrics?.semanticStructure?.hasFooter;
+                    if (confusingNav) {
+                        score = 45;
+                        issues.push({ description: 'Navigation structure may be counter-intuitive', severity: 'high' });
+                        recommendations.push('Add semantic navigation elements');
+                    }
+                    if (poorStructure) {
+                        score -= 15;
+                        issues.push({ description: 'Page structure lacks expected header/footer', severity: 'medium' });
+                    }
+                    if (score > 75) {
+                        findings.push('No counter-intuitive design patterns detected');
+                    }
+                    break;
                 }
-                if (score > 75) {
-                    findings.push('No counter-intuitive design patterns detected');
-                }
-                break;
             // ========== Impact Analysis Heuristics (H5.x) ==========
             case QXHeuristic.USER_FEELINGS_IMPACT:
-                const altCoverage = context.accessibility?.altTextsCoverage || 0;
-                const loadTime = context.performance?.loadTime || 0;
-                const ariaLabels = context.accessibility?.ariaLabelsCount || 0;
-                const focusableElements = context.accessibility?.focusableElementsCount || 0;
-                score = 60;
-                // Accessibility impact on feelings (35% weight)
-                if (altCoverage >= 90) {
-                    score += 20;
-                    findings.push('Excellent accessibility (90%+ alt coverage) creates inclusive, positive experience');
-                }
-                else if (altCoverage >= 70) {
-                    score += 12;
-                    findings.push('Good accessibility creates generally positive user feelings');
-                }
-                else if (altCoverage < 50) {
-                    score -= 15;
-                    issues.push({
-                        description: 'Poor accessibility (<50% alt coverage) frustrates users with disabilities',
-                        severity: 'high',
-                    });
-                    recommendations.push('Improve alt text coverage to at least 80% for better accessibility');
-                }
-                // ARIA support impact
-                if (ariaLabels > 5) {
-                    score += 8;
-                    findings.push('Strong ARIA labeling enhances screen reader experience');
-                }
-                // Performance impact on feelings (35% weight)
-                if (loadTime < 1500) {
-                    score += 15;
-                    findings.push('Very fast load time (<1.5s) delights users');
-                }
-                else if (loadTime < 2500) {
-                    score += 8;
-                    findings.push('Fast load time enhances user satisfaction');
-                }
-                else if (loadTime > 4000) {
-                    score -= 20;
-                    issues.push({ description: 'Very slow load time (>4s) causes significant frustration', severity: 'critical' });
-                    recommendations.push('Optimize page load time - target under 2.5 seconds');
-                }
-                else if (loadTime > 3000) {
-                    score -= 12;
-                    issues.push({ description: 'Slow load time causes user frustration', severity: 'high' });
-                }
-                // Error visibility impact
-                if (context.errorIndicators?.hasErrorMessages) {
-                    score -= 12;
-                    issues.push({ description: 'Visible errors reduce user confidence and satisfaction', severity: 'high' });
-                    recommendations.push('Review and fix visible error messages');
-                }
-                // Interaction capability
-                if (focusableElements > 20) {
-                    score += 5;
-                    findings.push('Rich interactive elements provide user control and engagement');
-                }
-                else if (focusableElements < 5) {
-                    score -= 8;
-                    issues.push({ description: 'Limited interactivity may feel restrictive', severity: 'medium' });
+                {
+                    const altCoverage = context.accessibility?.altTextsCoverage || 0;
+                    const loadTime = context.performance?.loadTime || 0;
+                    const ariaLabels = context.accessibility?.ariaLabelsCount || 0;
+                    const focusableElements = context.accessibility?.focusableElementsCount || 0;
+                    score = 60;
+                    // Accessibility impact on feelings (35% weight)
+                    if (altCoverage >= 90) {
+                        score += 20;
+                        findings.push('Excellent accessibility (90%+ alt coverage) creates inclusive, positive experience');
+                    }
+                    else if (altCoverage >= 70) {
+                        score += 12;
+                        findings.push('Good accessibility creates generally positive user feelings');
+                    }
+                    else if (altCoverage < 50) {
+                        score -= 15;
+                        issues.push({
+                            description: 'Poor accessibility (<50% alt coverage) frustrates users with disabilities',
+                            severity: 'high',
+                        });
+                        recommendations.push('Improve alt text coverage to at least 80% for better accessibility');
+                    }
+                    // ARIA support impact
+                    if (ariaLabels > 5) {
+                        score += 8;
+                        findings.push('Strong ARIA labeling enhances screen reader experience');
+                    }
+                    // Performance impact on feelings (35% weight)
+                    if (loadTime < 1500) {
+                        score += 15;
+                        findings.push('Very fast load time (<1.5s) delights users');
+                    }
+                    else if (loadTime < 2500) {
+                        score += 8;
+                        findings.push('Fast load time enhances user satisfaction');
+                    }
+                    else if (loadTime > 4000) {
+                        score -= 20;
+                        issues.push({ description: 'Very slow load time (>4s) causes significant frustration', severity: 'critical' });
+                        recommendations.push('Optimize page load time - target under 2.5 seconds');
+                    }
+                    else if (loadTime > 3000) {
+                        score -= 12;
+                        issues.push({ description: 'Slow load time causes user frustration', severity: 'high' });
+                    }
+                    // Error visibility impact
+                    if (context.errorIndicators?.hasErrorMessages) {
+                        score -= 12;
+                        issues.push({ description: 'Visible errors reduce user confidence and satisfaction', severity: 'high' });
+                        recommendations.push('Review and fix visible error messages');
+                    }
+                    // Interaction capability
+                    if (focusableElements > 20) {
+                        score += 5;
+                        findings.push('Rich interactive elements provide user control and engagement');
+                    }
+                    else if (focusableElements < 5) {
+                        score -= 8;
+                        issues.push({ description: 'Limited interactivity may feel restrictive', severity: 'medium' });
+                    }
+                    score = Math.max(20, Math.min(100, score));
+                    break;
                 }
-                score = Math.max(20, Math.min(100, score));
-                break;
             case QXHeuristic.GUI_FLOW_IMPACT:
-                const interactiveElements = context.domMetrics?.interactiveElements || 0;
-                const forms = context.domMetrics?.forms || 0;
-                if (interactiveElements > 20) {
-                    score = 75;
-                    findings.push(`${interactiveElements} interactive elements provide user control`);
-                }
-                if (forms > 0) {
-                    findings.push(`${forms} forms impact user input flows`);
-                    score = Math.min(100, score + 10);
-                }
-                if (interactiveElements === 0) {
-                    score = 30;
-                    issues.push({ description: 'Limited user interaction capability', severity: 'high' });
+                {
+                    const interactiveElements = context.domMetrics?.interactiveElements || 0;
+                    const forms = context.domMetrics?.forms || 0;
+                    if (interactiveElements > 20) {
+                        score = 75;
+                        findings.push(`${interactiveElements} interactive elements provide user control`);
+                    }
+                    if (forms > 0) {
+                        findings.push(`${forms} forms impact user input flows`);
+                        score = Math.min(100, score + 10);
+                    }
+                    if (interactiveElements === 0) {
+                        score = 30;
+                        issues.push({ description: 'Limited user interaction capability', severity: 'high' });
+                    }
+                    break;
                 }
-                break;
             case QXHeuristic.CROSS_FUNCTIONAL_IMPACT:
                 score = 70;
                 if (context.accessibility && (context.accessibility.altTextsCoverage || 0) < 100) {
@@ -232,14 +242,16 @@ export class QXHeuristicsEngine {
                 break;
             // ========== User Needs Heuristics (H2.x) ==========
             case QXHeuristic.USER_NEEDS_IDENTIFICATION:
-                score = userNeeds.alignmentScore;
-                findings.push(`${userNeeds.needs.length} user needs identified`);
-                const mustHave = userNeeds.needs.filter((n) => n.priority === 'must-have').length;
-                findings.push(`${mustHave} must-have features`);
-                if (userNeeds.challenges.length > 0) {
-                    issues.push({ description: `${userNeeds.challenges.length} user need challenges found`, severity: 'medium' });
+                {
+                    score = userNeeds.alignmentScore;
+                    findings.push(`${userNeeds.needs.length} user needs identified`);
+                    const mustHave = userNeeds.needs.filter((n) => n.priority === 'must-have').length;
+                    findings.push(`${mustHave} must-have features`);
+                    if (userNeeds.challenges.length > 0) {
+                        issues.push({ description: `${userNeeds.challenges.length} user need challenges found`, severity: 'medium' });
+                    }
+                    break;
                 }
-                break;
             case QXHeuristic.USER_NEEDS_SUITABILITY:
                 score =
                     userNeeds.suitability === 'excellent'
@@ -252,10 +264,12 @@ export class QXHeuristicsEngine {
                 findings.push(`User needs suitability: ${userNeeds.suitability}`);
                 break;
             case QXHeuristic.USER_NEEDS_VALIDATION:
-                const addressedNeeds = userNeeds.needs.filter((n) => n.addressed).length;
-                score = userNeeds.needs.length > 0 ? (addressedNeeds / userNeeds.needs.length) * 100 : 50;
-                findings.push(`${addressedNeeds}/${userNeeds.needs.length} needs validated and addressed`);
-                break;
+                {
+                    const addressedNeeds = userNeeds.needs.filter((n) => n.addressed).length;
+                    score = userNeeds.needs.length > 0 ? (addressedNeeds / userNeeds.needs.length) * 100 : 50;
+                    findings.push(`${addressedNeeds}/${userNeeds.needs.length} needs validated and addressed`);
+                    break;
+                }
             // ========== Business Needs Heuristics (H3.x) ==========
             case QXHeuristic.BUSINESS_NEEDS_IDENTIFICATION:
                 score = businessNeeds.alignmentScore;
@@ -264,16 +278,18 @@ export class QXHeuristicsEngine {
                 findings.push(`${businessNeeds.crossTeamImpact.length} cross-team impacts`);
                 break;
             case QXHeuristic.USER_VS_BUSINESS_BALANCE:
-                const balanceScore = 100 - Math.abs(userNeeds.alignmentScore - businessNeeds.alignmentScore);
-                score = balanceScore;
-                if (balanceScore > 80) {
-                    findings.push('Good balance between user and business needs');
-                }
-                else {
-                    issues.push({ description: 'Imbalance between user and business priorities', severity: 'medium' });
-                    recommendations.push('Align user and business objectives more closely');
+                {
+                    const balanceScore = 100 - Math.abs(userNeeds.alignmentScore - businessNeeds.alignmentScore);
+                    score = balanceScore;
+                    if (balanceScore > 80) {
+                        findings.push('Good balance between user and business needs');
+                    }
+                    else {
+                        issues.push({ description: 'Imbalance between user and business priorities', severity: 'medium' });
+                        recommendations.push('Align user and business objectives more closely');
+                    }
+                    break;
                 }
-                break;
             case QXHeuristic.KPI_IMPACT_ANALYSIS:
                 score = businessNeeds.impactsKPIs ? 85 : 50;
                 findings.push(`KPIs impacted: ${businessNeeds.kpisAffected.join(', ')}`);
@@ -297,18 +313,20 @@ export class QXHeuristicsEngine {
                 }
                 break;
             case QXHeuristic.SUPPORTING_DATA_ANALYSIS:
-                score = 75;
-                const hasData = (context.domMetrics?.forms || 0) > 0 || (context.domMetrics?.interactiveElements || 0) > 20;
-                if (hasData) {
-                    score = 82;
-                    findings.push('Sufficient data points for informed decision-making');
-                }
-                else {
-                    score = 60;
-                    issues.push({ description: 'Limited data for comprehensive analysis', severity: 'medium' });
-                    recommendations.push('Collect more user interaction data');
+                {
+                    score = 75;
+                    const hasData = (context.domMetrics?.forms || 0) > 0 || (context.domMetrics?.interactiveElements || 0) > 20;
+                    if (hasData) {
+                        score = 82;
+                        findings.push('Sufficient data points for informed decision-making');
+                    }
+                    else {
+                        score = 60;
+                        issues.push({ description: 'Limited data for comprehensive analysis', severity: 'medium' });
+                        recommendations.push('Collect more user interaction data');
+                    }
+                    break;
                 }
-                break;
             // ========== Creativity Heuristics (H6.x) ==========
             case QXHeuristic.COMPETITIVE_ANALYSIS:
                 score = 70;
@@ -324,27 +342,31 @@ export class QXHeuristicsEngine {
                 }
                 break;
             case QXHeuristic.DOMAIN_INSPIRATION:
-                score = 72;
-                const hasModernElements = context.accessibility && (context.accessibility.ariaLabelsCount || 0) > 0;
-                if (hasModernElements) {
-                    score = 80;
-                    findings.push('Modern accessibility patterns show domain inspiration');
-                }
-                else {
-                    recommendations.push('Research domain-specific design patterns and best practices');
+                {
+                    score = 72;
+                    const hasModernElements = context.accessibility && (context.accessibility.ariaLabelsCount || 0) > 0;
+                    if (hasModernElements) {
+                        score = 80;
+                        findings.push('Modern accessibility patterns show domain inspiration');
+                    }
+                    else {
+                        recommendations.push('Research domain-specific design patterns and best practices');
+                    }
+                    break;
                 }
-                break;
             case QXHeuristic.INNOVATIVE_SOLUTIONS:
-                score = 65;
-                const hasAdvancedFeatures = (context.accessibility?.landmarkRoles || 0) > 3;
-                if (hasAdvancedFeatures) {
-                    score = 75;
-                    findings.push('Advanced accessibility features show innovative thinking');
+                {
+                    score = 65;
+                    const hasAdvancedFeatures = (context.accessibility?.landmarkRoles || 0) > 3;
+                    if (hasAdvancedFeatures) {
+                        score = 75;
+                        findings.push('Advanced accessibility features show innovative thinking');
+                    }
+                    else {
+                        recommendations.push('Explore innovative UX patterns to differentiate experience');
+                    }
+                    break;
                 }
-                else {
-                    recommendations.push('Explore innovative UX patterns to differentiate experience');
-                }
-                break;
             default:
                 // Generic heuristic evaluation based on category
                 if (category === 'user-needs') {

package/dist/mcp/tools/visual-accessibility/index.js

@@ -258,7 +258,7 @@ export class A11yAuditTool extends MCPToolBase {
                     }
                 }
                 // Optionally check keyboard navigation
-                let keyboardViolations = [];
+                const keyboardViolations = [];
                 if (checkKeyboard) {
                     const keyboardResult = await service.checkKeyboardNavigation(url);
                     if (keyboardResult.success) {

package/dist/mcp/transport/websocket/websocket-transport.js

@@ -122,6 +122,7 @@ export class WebSocketTransport extends EventEmitter {
      * Handle a manual WebSocket upgrade (for testing or custom servers)
      */
     handleUpgrade(request, socket, head) {
+        // eslint-disable-next-line no-async-promise-executor -- body is wrapped in try/catch that calls reject()
         return new Promise(async (resolve, reject) => {
             if (this.disposed) {
                 socket.write('HTTP/1.1 503 Service Unavailable\r\n\r\n');

package/dist/optimization/auto-tuner.js

@@ -303,7 +303,7 @@ export class AQEAutoTuner {
         const parameterValues = this.algorithm.suggestNextConfiguration(this.parameters, this.evaluationHistory, this.config);
         // Check if we have applicators registered for real system integration
         const hasApplicators = this.applicatorRegistry.getAll().length > 0;
-        let metricValues = {};
+        const metricValues = {};
         if (hasApplicators) {
             // REAL EVALUATION: Apply configuration to actual systems
             try {