agentic-qe 3.6.2 → 3.6.3

package/v3/dist/mcp/bundle.js

@@ -19578,7 +19578,7 @@ var init_trajectory_bridge = __esm({
       async checkClaudeFlow() {
         try {
           const { execSync: execSync6 } = await import("child_process");
-          execSync6("npx @claude-flow/cli@latest hooks metrics --period 1h 2>/dev/null", {
+          execSync6("npx @claude-flow/cli@latest hooks metrics --period 1h", {
             encoding: "utf-8",
             timeout: 5e3,
             cwd: this.options.projectRoot
@@ -19598,7 +19598,7 @@ var init_trajectory_bridge = __esm({
             const { execSync: execSync6 } = await import("child_process");
             const agentArg = agent ? `--agent ${this.escapeArg(agent)}` : "";
             const result = execSync6(
-              `npx @claude-flow/cli@latest hooks intelligence trajectory-start --task ${this.escapeArg(task)} ${agentArg} 2>/dev/null`,
+              `npx @claude-flow/cli@latest hooks intelligence trajectory-start --task ${this.escapeArg(task)} ${agentArg}`,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
             const match = result.match(/trajectoryId[:\s]+["']?([^"'\s,}]+)/i);
@@ -19628,7 +19628,7 @@ var init_trajectory_bridge = __esm({
             const resultArg = result ? `--result ${this.escapeArg(result)}` : "";
             const qualityArg = quality !== void 0 ? `--quality ${quality}` : "";
             execSync6(
-              `npx @claude-flow/cli@latest hooks intelligence trajectory-step --trajectory-id ${this.escapeArg(trajectoryId)} --action ${this.escapeArg(action)} ${resultArg} ${qualityArg} 2>/dev/null`,
+              `npx @claude-flow/cli@latest hooks intelligence trajectory-step --trajectory-id ${this.escapeArg(trajectoryId)} --action ${this.escapeArg(action)} ${resultArg} ${qualityArg}`,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
             return;
@@ -19656,7 +19656,7 @@ var init_trajectory_bridge = __esm({
             const { execSync: execSync6 } = await import("child_process");
             const feedbackArg = feedback ? `--feedback ${this.escapeArg(feedback)}` : "";
             execSync6(
-              `npx @claude-flow/cli@latest hooks intelligence trajectory-end --trajectory-id ${this.escapeArg(trajectoryId)} --success ${success} ${feedbackArg} 2>/dev/null`,
+              `npx @claude-flow/cli@latest hooks intelligence trajectory-end --trajectory-id ${this.escapeArg(trajectoryId)} --success ${success} ${feedbackArg}`,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
           } catch {
@@ -19795,7 +19795,7 @@ var init_model_router_bridge = __esm({
       async checkClaudeFlow() {
         try {
           const { execSync: execSync6 } = await import("child_process");
-          execSync6("npx @claude-flow/cli@latest hooks model-stats 2>/dev/null", {
+          execSync6("npx @claude-flow/cli@latest hooks model-stats", {
             encoding: "utf-8",
             timeout: 5e3,
             cwd: this.options.projectRoot
@@ -19813,7 +19813,7 @@ var init_model_router_bridge = __esm({
           try {
             const { execSync: execSync6 } = await import("child_process");
             const result = execSync6(
-              `npx @claude-flow/cli@latest hooks model-route --task ${this.escapeArg(task)} 2>/dev/null`,
+              `npx @claude-flow/cli@latest hooks model-route --task ${this.escapeArg(task)}`,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
             const modelMatch = result.match(/model[:\s]+["']?(haiku|sonnet|opus)/i);
@@ -19844,7 +19844,7 @@ var init_model_router_bridge = __esm({
           try {
             const { execSync: execSync6 } = await import("child_process");
             execSync6(
-              `npx @claude-flow/cli@latest hooks model-outcome --task ${this.escapeArg(outcome.task)} --model ${outcome.model} --outcome ${outcome.outcome} 2>/dev/null`,
+              `npx @claude-flow/cli@latest hooks model-outcome --task ${this.escapeArg(outcome.task)} --model ${outcome.model} --outcome ${outcome.outcome}`,
               { encoding: "utf-8", timeout: 1e4, cwd: this.options.projectRoot }
             );
           } catch (error) {
@@ -19959,7 +19959,7 @@ var init_pretrain_bridge = __esm({
       async checkClaudeFlow() {
         try {
           const { execSync: execSync6 } = await import("child_process");
-          execSync6("npx @claude-flow/cli@latest hooks pretrain --help 2>/dev/null", {
+          execSync6("npx @claude-flow/cli@latest hooks pretrain --help", {
             encoding: "utf-8",
             timeout: 5e3,
             cwd: this.options.projectRoot
@@ -19983,7 +19983,7 @@ var init_pretrain_bridge = __esm({
           try {
             const { execSync: execSync6 } = await import("child_process");
             const result = execSync6(
-              `npx @claude-flow/cli@latest hooks pretrain --path ${this.escapeArg(targetPath)} --depth ${depth} 2>/dev/null`,
+              `npx @claude-flow/cli@latest hooks pretrain --path ${this.escapeArg(targetPath)} --depth ${depth}`,
               { encoding: "utf-8", timeout: 12e4, cwd: this.options.projectRoot }
             );
             try {
@@ -20018,7 +20018,7 @@ var init_pretrain_bridge = __esm({
           try {
             const { execSync: execSync6 } = await import("child_process");
             const result = execSync6(
-              `npx @claude-flow/cli@latest hooks build-agents --format ${format} 2>/dev/null`,
+              `npx @claude-flow/cli@latest hooks build-agents --format ${format}`,
               { encoding: "utf-8", timeout: 6e4, cwd: this.options.projectRoot }
             );
             try {
@@ -20041,7 +20041,7 @@ var init_pretrain_bridge = __esm({
           try {
             const { execSync: execSync6 } = await import("child_process");
             const result = execSync6(
-              `npx @claude-flow/cli@latest hooks transfer --source-path ${this.escapeArg(sourcePath)} --min-confidence ${minConfidence} 2>/dev/null`,
+              `npx @claude-flow/cli@latest hooks transfer --source-path ${this.escapeArg(sourcePath)} --min-confidence ${minConfidence}`,
               { encoding: "utf-8", timeout: 6e4, cwd: this.options.projectRoot }
             );
             const transferredMatch = result.match(/transferred[:\s]+(\d+)/i);
@@ -29930,6 +29930,9 @@ var InMemoryBackend = class {
   cleanupInterval;
   async initialize() {
     this.cleanupInterval = setInterval(() => this.cleanup(), MEMORY_CONSTANTS.CLEANUP_INTERVAL_MS);
+    if (this.cleanupInterval.unref) {
+      this.cleanupInterval.unref();
+    }
   }
   async dispose() {
     if (this.cleanupInterval) {
@@ -30099,6 +30102,9 @@ var HybridMemoryBackend = class {
       () => this.cleanup(),
       this.config.cleanupInterval
     );
+    if (this.cleanupInterval.unref) {
+      this.cleanupInterval.unref();
+    }
     this.initialized = true;
     console.log(`[HybridBackend] Initialized with unified memory: ${this.unifiedMemory.getDbPath()}`);
   }
@@ -84341,7 +84347,7 @@ function checkTestRunners(projectPath) {
 function countVitestTests(projectPath, config) {
   try {
     const output = execSync5(
-      "npx vitest list --reporter=json 2>/dev/null",
+      "npx vitest list --reporter=json",
       {
         cwd: projectPath,
         encoding: "utf-8",
@@ -84401,7 +84407,7 @@ function countTestsRecursive(tests) {
 function countJestTests(projectPath, config) {
   try {
     const output = execSync5(
-      "npx jest --listTests 2>/dev/null",
+      "npx jest --listTests",
       {
         cwd: projectPath,
         encoding: "utf-8",
@@ -84427,7 +84433,7 @@ function countJestTests(projectPath, config) {
 function countCargoTests(projectPath, config) {
   try {
     const output = execSync5(
-      'cargo test --list 2>/dev/null || echo ""',
+      "cargo test --list",
       {
         cwd: projectPath,
         encoding: "utf-8",
@@ -84461,7 +84467,7 @@ function countCargoTests(projectPath, config) {
 function countPytestTests(projectPath, config) {
   try {
     const output = execSync5(
-      'pytest --collect-only -q 2>/dev/null || echo ""',
+      "pytest --collect-only -q",
       {
         cwd: projectPath,
         encoding: "utf-8",
@@ -84502,7 +84508,7 @@ function countPytestTests(projectPath, config) {
 function countGoTests(projectPath, config) {
   try {
     const output = execSync5(
-      'go test -list ".*" ./... 2>/dev/null || echo ""',
+      'go test -list ".*" ./...',
       {
         cwd: projectPath,
         encoding: "utf-8",
@@ -146239,6 +146245,1317 @@ var COHERENCE_TOOL_NAMES = {
   COHERENCE_COLLAPSE: "qe/coherence/collapse"
 };
 
+// src/mcp/tools/qx-analysis/types.ts
+var QXHeuristic = /* @__PURE__ */ ((QXHeuristic2) => {
+  QXHeuristic2["PROBLEM_UNDERSTANDING"] = "H1.1-problem-understanding";
+  QXHeuristic2["RULE_OF_THREE"] = "H1.2-rule-of-three";
+  QXHeuristic2["PROBLEM_COMPLEXITY"] = "H1.3-problem-complexity";
+  QXHeuristic2["USER_NEEDS_IDENTIFICATION"] = "H2.1-user-needs-identification";
+  QXHeuristic2["USER_NEEDS_SUITABILITY"] = "H2.2-user-needs-suitability";
+  QXHeuristic2["USER_NEEDS_VALIDATION"] = "H2.3-user-needs-validation";
+  QXHeuristic2["BUSINESS_NEEDS_IDENTIFICATION"] = "H3.1-business-needs-identification";
+  QXHeuristic2["USER_VS_BUSINESS_BALANCE"] = "H3.2-user-vs-business-balance";
+  QXHeuristic2["KPI_IMPACT_ANALYSIS"] = "H3.3-kpi-impact-analysis";
+  QXHeuristic2["ORACLE_PROBLEM_DETECTION"] = "H4.1-oracle-problem-detection";
+  QXHeuristic2["WHAT_MUST_NOT_CHANGE"] = "H4.2-what-must-not-change";
+  QXHeuristic2["SUPPORTING_DATA_ANALYSIS"] = "H4.3-supporting-data-analysis";
+  QXHeuristic2["GUI_FLOW_IMPACT"] = "H5.1-gui-flow-impact";
+  QXHeuristic2["USER_FEELINGS_IMPACT"] = "H5.2-user-feelings-impact";
+  QXHeuristic2["CROSS_FUNCTIONAL_IMPACT"] = "H5.3-cross-functional-impact";
+  QXHeuristic2["DATA_DEPENDENT_IMPACT"] = "H5.4-data-dependent-impact";
+  QXHeuristic2["COMPETITIVE_ANALYSIS"] = "H6.1-competitive-analysis";
+  QXHeuristic2["DOMAIN_INSPIRATION"] = "H6.2-domain-inspiration";
+  QXHeuristic2["INNOVATIVE_SOLUTIONS"] = "H6.3-innovative-solutions";
+  QXHeuristic2["EXACTNESS_AND_CLARITY"] = "H7.1-exactness-and-clarity";
+  QXHeuristic2["INTUITIVE_DESIGN"] = "H7.2-intuitive-design";
+  QXHeuristic2["COUNTER_INTUITIVE_DESIGN"] = "H7.3-counter-intuitive-design";
+  QXHeuristic2["CONSISTENCY_ANALYSIS"] = "H7.4-consistency-analysis";
+  return QXHeuristic2;
+})(QXHeuristic || {});
+
+// src/mcp/tools/qx-analysis/heuristics-engine.ts
+var QXHeuristicsEngine = class {
+  enabledHeuristics;
+  minConfidence;
+  constructor(options = {}) {
+    this.enabledHeuristics = options.enabledHeuristics || Object.values(QXHeuristic);
+    this.minConfidence = options.minConfidence || 0.7;
+  }
+  /**
+   * Apply all enabled heuristics
+   */
+  async applyAll(context, problemAnalysis, userNeeds, businessNeeds) {
+    const results = [];
+    for (const heuristic of this.enabledHeuristics) {
+      const result = await this.apply(heuristic, context, problemAnalysis, userNeeds, businessNeeds);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Apply a specific heuristic
+   */
+  async apply(heuristic, context, problemAnalysis, userNeeds, businessNeeds) {
+    const category = this.getHeuristicCategory(heuristic);
+    const findings = [];
+    const issues = [];
+    const recommendations = [];
+    let score = 75;
+    switch (heuristic) {
+      // ========== Design Quality Heuristics (H7.x) ==========
+      case "H7.4-consistency-analysis" /* CONSISTENCY_ANALYSIS */:
+        if (context.domMetrics?.semanticStructure?.hasHeader && context.domMetrics?.semanticStructure?.hasFooter) {
+          score = 85;
+          findings.push("Consistent page structure with header and footer");
+        } else {
+          score = 60;
+          recommendations.push("Add consistent header/footer structure");
+        }
+        break;
+      case "H7.2-intuitive-design" /* 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");
+        } else {
+          score = 55;
+          issues.push({ description: "Navigation or interaction patterns unclear", severity: "medium" });
+        }
+        break;
+      case "H7.1-exactness-and-clarity" /* 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");
+        }
+        if (context.metadata?.description && context.metadata.description.length > 20) {
+          score += 10;
+          findings.push("Page has descriptive metadata");
+        }
+        break;
+      case "H7.3-counter-intuitive-design" /* COUNTER_INTUITIVE_DESIGN */:
+        score = 85;
+        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;
+      // ========== Impact Analysis Heuristics (H5.x) ==========
+      case "H5.2-user-feelings-impact" /* 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;
+        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");
+        }
+        if (ariaLabels > 5) {
+          score += 8;
+          findings.push("Strong ARIA labeling enhances screen reader experience");
+        }
+        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 > 4e3) {
+          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 > 3e3) {
+          score -= 12;
+          issues.push({ description: "Slow load time causes user frustration", severity: "high" });
+        }
+        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");
+        }
+        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;
+      case "H5.1-gui-flow-impact" /* 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" });
+        }
+        break;
+      case "H5.3-cross-functional-impact" /* CROSS_FUNCTIONAL_IMPACT */:
+        score = 70;
+        if (context.accessibility && (context.accessibility.altTextsCoverage || 0) < 100) {
+          findings.push("Content team needed for alt text creation");
+        }
+        if (context.performance && (context.performance.loadTime || 0) > 2e3) {
+          findings.push("Engineering team needed for performance optimization");
+        }
+        if (problemAnalysis.complexity === "complex") {
+          findings.push("QA team needed for comprehensive testing");
+        }
+        score = 70 + findings.length * 5;
+        break;
+      case "H5.4-data-dependent-impact" /* DATA_DEPENDENT_IMPACT */:
+        if (context.domMetrics?.forms && context.domMetrics.forms > 0) {
+          score = 75;
+          findings.push(`${context.domMetrics.forms} forms depend on backend data processing`);
+        } else {
+          score = 50;
+          findings.push("Limited data-dependent features");
+        }
+        break;
+      // ========== Problem Analysis Heuristics (H1.x) ==========
+      case "H1.1-problem-understanding" /* PROBLEM_UNDERSTANDING */:
+        score = problemAnalysis.clarityScore;
+        if (problemAnalysis.clarityScore > 80) {
+          findings.push("Problem is well-defined");
+        } else {
+          issues.push({ description: "Problem clarity needs improvement", severity: "medium" });
+        }
+        findings.push(...problemAnalysis.breakdown);
+        break;
+      case "H1.2-rule-of-three" /* RULE_OF_THREE */:
+        score = problemAnalysis.potentialFailures.length >= 3 ? 85 : 60;
+        findings.push(`${problemAnalysis.potentialFailures.length} potential failure modes identified`);
+        if (problemAnalysis.potentialFailures.length < 3) {
+          recommendations.push("Identify at least 3 potential failure modes (Rule of Three)");
+        }
+        break;
+      case "H1.3-problem-complexity" /* PROBLEM_COMPLEXITY */:
+        score = problemAnalysis.complexity === "simple" ? 90 : problemAnalysis.complexity === "moderate" ? 75 : 60;
+        findings.push(`Problem complexity: ${problemAnalysis.complexity}`);
+        break;
+      // ========== User Needs Heuristics (H2.x) ==========
+      case "H2.1-user-needs-identification" /* USER_NEEDS_IDENTIFICATION */:
+        score = userNeeds.alignmentScore;
+        findings.push(`${userNeeds.needs.length} user needs identified`);
+        const mustHave = userNeeds.needs.filter((n61) => n61.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;
+      case "H2.2-user-needs-suitability" /* USER_NEEDS_SUITABILITY */:
+        score = userNeeds.suitability === "excellent" ? 95 : userNeeds.suitability === "good" ? 80 : userNeeds.suitability === "adequate" ? 65 : 45;
+        findings.push(`User needs suitability: ${userNeeds.suitability}`);
+        break;
+      case "H2.3-user-needs-validation" /* USER_NEEDS_VALIDATION */:
+        const addressedNeeds = userNeeds.needs.filter((n61) => n61.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 "H3.1-business-needs-identification" /* BUSINESS_NEEDS_IDENTIFICATION */:
+        score = businessNeeds.alignmentScore;
+        findings.push(`Primary goal: ${businessNeeds.primaryGoal}`);
+        findings.push(`${businessNeeds.kpisAffected.length} KPIs affected`);
+        findings.push(`${businessNeeds.crossTeamImpact.length} cross-team impacts`);
+        break;
+      case "H3.2-user-vs-business-balance" /* 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");
+        }
+        break;
+      case "H3.3-kpi-impact-analysis" /* KPI_IMPACT_ANALYSIS */:
+        score = businessNeeds.impactsKPIs ? 85 : 50;
+        findings.push(`KPIs impacted: ${businessNeeds.kpisAffected.join(", ")}`);
+        if (businessNeeds.compromisesUX) {
+          issues.push({ description: "Business ease compromises user experience", severity: "high" });
+          score -= 20;
+        }
+        break;
+      // ========== Balance / Oracle Heuristics (H4.x) ==========
+      case "H4.1-oracle-problem-detection" /* ORACLE_PROBLEM_DETECTION */:
+        score = 75;
+        findings.push("Oracle problem detection capability active");
+        break;
+      case "H4.2-what-must-not-change" /* WHAT_MUST_NOT_CHANGE */:
+        score = 80;
+        if (context.domMetrics?.semanticStructure?.hasMain) {
+          findings.push("Main content structure is immutable");
+        }
+        if (context.accessibility && (context.accessibility.focusableElementsCount || 0) > 0) {
+          findings.push("Keyboard navigation support must be maintained");
+        }
+        break;
+      case "H4.3-supporting-data-analysis" /* 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");
+        }
+        break;
+      // ========== Creativity Heuristics (H6.x) ==========
+      case "H6.1-competitive-analysis" /* COMPETITIVE_ANALYSIS */:
+        score = 70;
+        findings.push("Competitive analysis capability available");
+        if (context.domMetrics?.semanticStructure?.hasNav && context.domMetrics?.interactiveElements && context.domMetrics.interactiveElements > 15) {
+          score = 78;
+          findings.push("Navigation and interaction patterns follow industry standards");
+        } else {
+          recommendations.push("Compare interaction patterns with leading competitors");
+        }
+        break;
+      case "H6.2-domain-inspiration" /* 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");
+        }
+        break;
+      case "H6.3-innovative-solutions" /* INNOVATIVE_SOLUTIONS */:
+        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;
+      default:
+        if (category === "user-needs") {
+          score = userNeeds.alignmentScore;
+        } else if (category === "business-needs") {
+          score = businessNeeds.alignmentScore;
+        } else if (category === "problem") {
+          score = problemAnalysis.clarityScore;
+        }
+        break;
+    }
+    return {
+      id: heuristic,
+      name: this.getHeuristicName(heuristic),
+      category,
+      applied: true,
+      score: Math.min(100, Math.max(0, score)),
+      findings,
+      issues,
+      recommendations
+    };
+  }
+  /**
+   * Get the category for a heuristic
+   */
+  getHeuristicCategory(heuristic) {
+    if (heuristic.includes("problem")) return "problem";
+    if (heuristic.includes("user-needs") || heuristic.includes("user-vs")) return "user-needs";
+    if (heuristic.includes("business")) return "business-needs";
+    if (heuristic.includes("oracle") || heuristic.includes("balance") || heuristic.includes("what-must") || heuristic.includes("supporting-data"))
+      return "balance";
+    if (heuristic.includes("impact") || heuristic.includes("gui-flow") || heuristic.includes("feelings") || heuristic.includes("cross-functional") || heuristic.includes("data-dependent"))
+      return "impact";
+    if (heuristic.includes("competitive") || heuristic.includes("inspiration") || heuristic.includes("innovative"))
+      return "creativity";
+    return "design";
+  }
+  /**
+   * Get human-readable name for a heuristic
+   */
+  getHeuristicName(heuristic) {
+    const names = {
+      ["H1.1-problem-understanding" /* PROBLEM_UNDERSTANDING */]: "Problem Understanding",
+      ["H1.2-rule-of-three" /* RULE_OF_THREE */]: "Rule of Three",
+      ["H1.3-problem-complexity" /* PROBLEM_COMPLEXITY */]: "Problem Complexity",
+      ["H2.1-user-needs-identification" /* USER_NEEDS_IDENTIFICATION */]: "User Needs Identification",
+      ["H2.2-user-needs-suitability" /* USER_NEEDS_SUITABILITY */]: "User Needs Suitability",
+      ["H2.3-user-needs-validation" /* USER_NEEDS_VALIDATION */]: "User Needs Validation",
+      ["H3.1-business-needs-identification" /* BUSINESS_NEEDS_IDENTIFICATION */]: "Business Needs Identification",
+      ["H3.2-user-vs-business-balance" /* USER_VS_BUSINESS_BALANCE */]: "User vs Business Balance",
+      ["H3.3-kpi-impact-analysis" /* KPI_IMPACT_ANALYSIS */]: "KPI Impact Analysis",
+      ["H4.1-oracle-problem-detection" /* ORACLE_PROBLEM_DETECTION */]: "Oracle Problem Detection",
+      ["H4.2-what-must-not-change" /* WHAT_MUST_NOT_CHANGE */]: "What Must Not Change",
+      ["H4.3-supporting-data-analysis" /* SUPPORTING_DATA_ANALYSIS */]: "Supporting Data Analysis",
+      ["H5.1-gui-flow-impact" /* GUI_FLOW_IMPACT */]: "GUI Flow Impact",
+      ["H5.2-user-feelings-impact" /* USER_FEELINGS_IMPACT */]: "User Feelings Impact",
+      ["H5.3-cross-functional-impact" /* CROSS_FUNCTIONAL_IMPACT */]: "Cross-Functional Impact",
+      ["H5.4-data-dependent-impact" /* DATA_DEPENDENT_IMPACT */]: "Data-Dependent Impact",
+      ["H6.1-competitive-analysis" /* COMPETITIVE_ANALYSIS */]: "Competitive Analysis",
+      ["H6.2-domain-inspiration" /* DOMAIN_INSPIRATION */]: "Domain Inspiration",
+      ["H6.3-innovative-solutions" /* INNOVATIVE_SOLUTIONS */]: "Innovative Solutions",
+      ["H7.1-exactness-and-clarity" /* EXACTNESS_AND_CLARITY */]: "Exactness & Clarity",
+      ["H7.2-intuitive-design" /* INTUITIVE_DESIGN */]: "Intuitive Design",
+      ["H7.3-counter-intuitive-design" /* COUNTER_INTUITIVE_DESIGN */]: "Counter-Intuitive Design",
+      ["H7.4-consistency-analysis" /* CONSISTENCY_ANALYSIS */]: "Consistency Analysis"
+    };
+    return names[heuristic] || heuristic;
+  }
+};
+
+// src/mcp/tools/qx-analysis/oracle-detector.ts
+var OracleDetector = class {
+  minSeverity;
+  constructor(minSeverity = "medium") {
+    this.minSeverity = minSeverity;
+  }
+  /**
+   * Detect oracle problems from context and analysis
+   */
+  detect(context, userNeeds, businessNeeds) {
+    const problems = [];
+    if (Math.abs(userNeeds.alignmentScore - businessNeeds.alignmentScore) > 20) {
+      problems.push({
+        type: "user-vs-business",
+        description: "Significant gap between user needs and business objectives",
+        severity: "high",
+        stakeholders: ["Users", "Business"],
+        resolutionApproach: [
+          "Gather supporting data from both perspectives",
+          "Facilitate discussion between stakeholders",
+          "Find compromise solutions that address both needs"
+        ]
+      });
+    }
+    if (userNeeds.challenges.length > 0 || businessNeeds.compromisesUX) {
+      problems.push({
+        type: "unclear-criteria",
+        description: "Quality criteria unclear due to conflicting information",
+        severity: "medium",
+        missingInfo: userNeeds.challenges,
+        resolutionApproach: [
+          "Collect missing information from stakeholders",
+          "Define clear acceptance criteria"
+        ]
+      });
+    }
+    const titleLower = (context.title || "").toLowerCase();
+    const descLower = (context.metadata?.description || "").toLowerCase();
+    if (titleLower.includes("hotel") || titleLower.includes("booking") || titleLower.includes("travel") || titleLower.includes("shop") || titleLower.includes("store") || descLower.includes("book")) {
+      if (businessNeeds.kpisAffected.some(
+        (k68) => k68.toLowerCase().includes("conversion") || k68.toLowerCase().includes("engagement")
+      )) {
+        problems.push({
+          type: "user-vs-business",
+          description: "Potential conflict between conversion optimization (business) and user experience quality (user trust)",
+          severity: "medium",
+          stakeholders: ["Marketing", "Product", "Users"],
+          resolutionApproach: [
+            "A/B test aggressive vs. subtle conversion tactics",
+            "Measure both conversion rate and user satisfaction metrics",
+            "Balance urgency messaging with transparent communication"
+          ]
+        });
+      }
+      problems.push({
+        type: "unclear-criteria",
+        description: "Unclear criteria for price display timing - when to show fees, taxes, and final price",
+        severity: "medium",
+        stakeholders: ["Users", "Legal", "Business"],
+        resolutionApproach: [
+          "Define regulatory compliance requirements for price display",
+          "Balance business desire for competitive base pricing vs user need for full price transparency",
+          "Establish clear standards for fee disclosure timing"
+        ]
+      });
+    }
+    if (titleLower.includes("blog") || titleLower.includes("article") || titleLower.includes("news") || titleLower.includes("magazine") || titleLower.includes("testing")) {
+      problems.push({
+        type: "user-vs-business",
+        description: "Content depth (user need) vs. publication frequency (business engagement goals) trade-off",
+        severity: "low",
+        stakeholders: ["Readers", "Content Team", "Editorial"],
+        resolutionApproach: [
+          "Define content quality standards and acceptance criteria",
+          "Balance editorial calendar with quality thresholds",
+          "Consider mix of in-depth and quick-read content formats"
+        ]
+      });
+    }
+    if (titleLower.includes("health") || titleLower.includes("medical") || titleLower.includes("patient") || titleLower.includes("care") || titleLower.includes("nhs")) {
+      problems.push({
+        type: "stakeholder-conflict",
+        description: "Healthcare compliance requirements may conflict with streamlined user experience",
+        severity: "medium",
+        stakeholders: ["Patients", "Healthcare Providers", "Compliance", "Legal"],
+        resolutionApproach: [
+          "Map regulatory requirements to UX touchpoints",
+          "Identify where compliance can be achieved without friction",
+          "Engage compliance team early in UX design reviews",
+          "Document consent and data handling requirements clearly"
+        ]
+      });
+      if (context.accessibility && (context.accessibility.altTextsCoverage || 0) < 80) {
+        problems.push({
+          type: "technical-constraint",
+          description: "Healthcare accessibility requirements not fully met - critical for patient inclusivity",
+          severity: "high",
+          stakeholders: ["Patients", "Accessibility Team", "Legal"],
+          resolutionApproach: [
+            "Prioritize WCAG 2.1 AA compliance for healthcare content",
+            "Ensure screen reader compatibility for medical information",
+            "Test with assistive technology users"
+          ]
+        });
+      }
+    }
+    if (titleLower.includes("bank") || titleLower.includes("finance") || titleLower.includes("payment") || titleLower.includes("money")) {
+      problems.push({
+        type: "stakeholder-conflict",
+        description: "Security requirements vs user convenience - authentication friction vs fraud prevention",
+        severity: "high",
+        stakeholders: ["Users", "Security Team", "Product", "Compliance"],
+        resolutionApproach: [
+          "Implement risk-based authentication to reduce friction for trusted sessions",
+          "Use biometrics where available for convenient yet secure access",
+          "A/B test authentication flows for security effectiveness and user completion rates"
+        ]
+      });
+    }
+    if ((context.domMetrics?.totalElements || 0) > 500 || (context.domMetrics?.interactiveElements || 0) > 50) {
+      problems.push({
+        type: "technical-constraint",
+        description: "Platform technical limitations may restrict advanced UX features or accessibility enhancements",
+        severity: "low",
+        stakeholders: ["Development", "Product", "Users"],
+        resolutionApproach: [
+          "Evaluate platform capabilities and constraints",
+          "Prioritize features based on user impact vs. implementation complexity",
+          "Consider gradual enhancement approach"
+        ]
+      });
+    }
+    if (context.performance && (context.performance.loadTime || 0) > 3e3) {
+      problems.push({
+        type: "technical-constraint",
+        description: "Performance optimization needed but may require trade-offs with visual richness",
+        severity: "medium",
+        stakeholders: ["Users", "Development", "Design"],
+        resolutionApproach: [
+          "Profile and identify performance bottlenecks",
+          "Consider progressive loading for visual elements",
+          "Balance image quality with load time"
+        ]
+      });
+    }
+    return problems.filter((p74) => this.meetsMinimumSeverity(p74.severity));
+  }
+  /**
+   * Check if severity meets minimum threshold
+   */
+  meetsMinimumSeverity(severity) {
+    const severityLevels = ["low", "medium", "high", "critical"];
+    const minIndex = severityLevels.indexOf(this.minSeverity);
+    const currentIndex = severityLevels.indexOf(severity);
+    return currentIndex >= minIndex;
+  }
+};
+
+// src/mcp/tools/qx-analysis/impact-analyzer.ts
+var ImpactAnalyzer = class {
+  /**
+   * Analyze impacts from context and problem analysis
+   */
+  analyze(context, problemAnalysis) {
+    const guiFlowEndUser = [];
+    const guiFlowInternal = [];
+    const userFeelings = [];
+    const performance4 = [];
+    const security = [];
+    const immutableRequirements = [];
+    const interactiveElements = context.domMetrics?.interactiveElements || 0;
+    const forms = context.domMetrics?.forms || 0;
+    if (interactiveElements > 0) {
+      guiFlowEndUser.push(`${interactiveElements} interactive elements affect user journey`);
+    }
+    if (forms > 0) {
+      guiFlowEndUser.push(`${forms} forms impact user input flows`);
+    }
+    if (context.domMetrics?.semanticStructure?.hasNav) {
+      guiFlowEndUser.push("Navigation structure enables exploration flow");
+    }
+    if (context.domMetrics?.semanticStructure?.hasMain) {
+      guiFlowEndUser.push("Clear main content area guides user focus");
+    }
+    if (forms > 0) {
+      guiFlowInternal.push("Form submissions create data processing workflows");
+    }
+    if (context.domMetrics?.semanticStructure?.hasAside) {
+      guiFlowInternal.push("Sidebar content may require separate management");
+    }
+    const altCoverage = context.accessibility?.altTextsCoverage || 0;
+    if (altCoverage > 80) {
+      userFeelings.push("Positive - Good accessibility creates inclusive experience");
+    } else if (altCoverage >= 50 && altCoverage <= 80) {
+      userFeelings.push("Neutral - Moderate accessibility; some users may struggle");
+    } else if (altCoverage < 50) {
+      userFeelings.push("Frustrated - Poor accessibility excludes some users");
+    }
+    const loadTime = context.performance?.loadTime || 0;
+    if (loadTime > 4e3) {
+      userFeelings.push("Impatient - Very slow load time causes significant frustration");
+    } else if (loadTime > 3e3) {
+      userFeelings.push("Impatient - Slow load time causes frustration");
+    } else if (loadTime > 2e3) {
+      userFeelings.push("Mildly Annoyed - Noticeable load time");
+    } else if (loadTime < 1500) {
+      userFeelings.push("Delighted - Fast load time enhances experience");
+    } else if (loadTime < 2e3) {
+      userFeelings.push("Satisfied - Good load time meets expectations");
+    }
+    if (context.errorIndicators?.hasErrorMessages) {
+      userFeelings.push("Confused - Visible errors reduce confidence");
+    }
+    const semanticStructure = context.domMetrics?.semanticStructure;
+    if (semanticStructure) {
+      const structureCount = [
+        semanticStructure.hasHeader,
+        semanticStructure.hasNav,
+        semanticStructure.hasMain,
+        semanticStructure.hasFooter
+      ].filter(Boolean).length;
+      if (structureCount >= 3) {
+        userFeelings.push("Oriented - Clear page structure helps navigation");
+      } else if (structureCount < 2) {
+        userFeelings.push("Disoriented - Unclear page structure may confuse users");
+      }
+    }
+    if (loadTime > 2e3) {
+      performance4.push(`Load time ${loadTime}ms impacts user retention`);
+    }
+    if (!context.metadata?.viewport) {
+      performance4.push("Missing viewport tag affects mobile performance");
+    }
+    if (context.performance?.firstContentfulPaint && context.performance.firstContentfulPaint > 2500) {
+      performance4.push(`First Contentful Paint ${context.performance.firstContentfulPaint}ms delays perceived readiness`);
+    }
+    if (forms > 0) {
+      security.push("Form data handling requires secure transmission");
+    }
+    if (context.accessibility && (context.accessibility.ariaLabelsCount || 0) > 0) {
+      security.push("ARIA labels may expose internal element names - review for sensitive info");
+    }
+    if (context.domMetrics?.semanticStructure?.hasMain) {
+      immutableRequirements.push("Must maintain main content accessibility");
+    }
+    if (context.accessibility && (context.accessibility.focusableElementsCount || 0) > 0) {
+      immutableRequirements.push("Must support keyboard navigation");
+    }
+    if (problemAnalysis.complexity === "complex") {
+      immutableRequirements.push("Must maintain system stability with complex interactions");
+    }
+    const titleLower = (context.title || "").toLowerCase();
+    if (titleLower.includes("health") || titleLower.includes("medical") || titleLower.includes("care")) {
+      immutableRequirements.push("Must comply with healthcare accessibility standards");
+      immutableRequirements.push("Must protect patient data privacy");
+    }
+    if (titleLower.includes("bank") || titleLower.includes("finance") || titleLower.includes("payment")) {
+      immutableRequirements.push("Must maintain PCI DSS compliance for payment data");
+      immutableRequirements.push("Must support secure authentication flows");
+    }
+    let visibleScore = 50;
+    if (guiFlowEndUser.length > 0) visibleScore += 15;
+    if (userFeelings.some((f74) => f74.includes("Positive") || f74.includes("Satisfied") || f74.includes("Delighted")))
+      visibleScore += 20;
+    if (userFeelings.some((f74) => f74.includes("Oriented"))) visibleScore += 10;
+    if (userFeelings.some((f74) => f74.includes("Frustrated") || f74.includes("Confused") || f74.includes("Impatient")))
+      visibleScore -= 15;
+    if (userFeelings.some((f74) => f74.includes("Disoriented"))) visibleScore -= 10;
+    visibleScore = Math.max(0, Math.min(100, visibleScore));
+    let invisibleScore = 50;
+    if (performance4.length === 0) invisibleScore += 20;
+    if (security.length === 0) invisibleScore += 10;
+    if (performance4.length > 2) invisibleScore -= 15;
+    invisibleScore = Math.max(0, Math.min(100, invisibleScore));
+    const overallImpactScore = Math.round((visibleScore + invisibleScore) / 2);
+    return {
+      visible: {
+        guiFlow: {
+          forEndUser: guiFlowEndUser,
+          forInternalUser: guiFlowInternal
+        },
+        userFeelings,
+        score: visibleScore
+      },
+      invisible: {
+        performance: performance4,
+        security,
+        score: invisibleScore
+      },
+      immutableRequirements,
+      overallImpactScore
+    };
+  }
+};
+
+// src/mcp/tools/qx-analysis/analyze.ts
+var QX_ANALYZE_SCHEMA = {
+  type: "object",
+  properties: {
+    target: {
+      type: "string",
+      description: "Target URL or identifier to analyze"
+    },
+    context: {
+      type: "object",
+      description: "Pre-collected QX context (optional)"
+    },
+    mode: {
+      type: "string",
+      description: "Analysis mode: full, quick, or targeted",
+      enum: ["full", "quick", "targeted"],
+      default: "full"
+    },
+    heuristics: {
+      type: "array",
+      description: "Specific heuristics to apply (default: all)"
+    },
+    minOracleSeverity: {
+      type: "string",
+      description: "Minimum oracle problem severity to report",
+      enum: ["low", "medium", "high", "critical"],
+      default: "medium"
+    },
+    includeCreativity: {
+      type: "boolean",
+      description: "Include creativity analysis from diverse domains",
+      default: true
+    },
+    includeDesign: {
+      type: "boolean",
+      description: "Include design quality analysis",
+      default: true
+    }
+  },
+  required: ["target"]
+};
+var QXAnalyzeTool = class extends MCPToolBase {
+  config = {
+    name: "qe/qx/analyze",
+    description: "Comprehensive Quality Experience (QX) analysis combining QA and UX perspectives. Applies 23+ programmatic heuristics, detects oracle problems, and analyzes impacts. QX = Marriage between QA (Quality Advocacy) and UX (User Experience).",
+    domain: "quality-assessment",
+    schema: QX_ANALYZE_SCHEMA,
+    streaming: true,
+    timeout: 18e4
+  };
+  async execute(params, context) {
+    const {
+      target,
+      context: qxContext = this.createMinimalContext(target),
+      mode = "full",
+      heuristics,
+      minOracleSeverity = "medium",
+      includeCreativity = true,
+      includeDesign = true
+    } = params;
+    try {
+      this.emitStream(context, {
+        status: "starting",
+        message: `Starting QX analysis for: ${target}`,
+        phase: "initialization"
+      });
+      this.emitStream(context, { status: "analyzing", phase: "problem-analysis" });
+      const problemAnalysis = this.analyzeProblem(qxContext);
+      if (this.isAborted(context)) {
+        return { success: false, error: "Operation aborted" };
+      }
+      this.emitStream(context, { status: "analyzing", phase: "user-needs" });
+      const userNeeds = this.analyzeUserNeeds(qxContext, problemAnalysis);
+      this.emitStream(context, { status: "analyzing", phase: "business-needs" });
+      const businessNeeds = this.analyzeBusinessNeeds(qxContext, problemAnalysis);
+      this.emitStream(context, { status: "analyzing", phase: "creativity" });
+      const creativityAnalysis = includeCreativity ? this.analyzeCreativity(qxContext, problemAnalysis) : this.createMinimalCreativityAnalysis();
+      this.emitStream(context, { status: "analyzing", phase: "design" });
+      const designAnalysis = includeDesign ? this.analyzeDesign(qxContext) : this.createMinimalDesignAnalysis();
+      this.emitStream(context, { status: "analyzing", phase: "oracle-detection" });
+      const oracleDetector = new OracleDetector(minOracleSeverity);
+      const oracleProblems = oracleDetector.detect(qxContext, userNeeds, businessNeeds);
+      this.emitStream(context, { status: "analyzing", phase: "impact-analysis" });
+      const impactAnalyzer = new ImpactAnalyzer();
+      const impactAnalysis = impactAnalyzer.analyze(qxContext, problemAnalysis);
+      this.emitStream(context, { status: "analyzing", phase: "heuristics", count: 23 });
+      const heuristicsEngine = new QXHeuristicsEngine({
+        enabledHeuristics: heuristics || Object.values(QXHeuristic)
+      });
+      const heuristicResults = await heuristicsEngine.applyAll(
+        qxContext,
+        problemAnalysis,
+        userNeeds,
+        businessNeeds
+      );
+      this.emitStream(context, { status: "analyzing", phase: "recommendations" });
+      const recommendations = this.generateRecommendations(
+        problemAnalysis,
+        userNeeds,
+        businessNeeds,
+        oracleProblems,
+        impactAnalysis,
+        heuristicResults
+      );
+      const overallScore = this.calculateOverallScore(
+        problemAnalysis,
+        userNeeds,
+        businessNeeds,
+        creativityAnalysis,
+        designAnalysis,
+        impactAnalysis,
+        heuristicResults
+      );
+      const grade = this.scoreToGrade(overallScore);
+      const result = {
+        overallScore,
+        grade,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        target,
+        problemAnalysis,
+        userNeeds,
+        businessNeeds,
+        creativityAnalysis,
+        designAnalysis,
+        oracleProblems,
+        impactAnalysis,
+        heuristics: heuristicResults,
+        recommendations,
+        context: qxContext
+      };
+      this.emitStream(context, {
+        status: "complete",
+        score: overallScore,
+        grade,
+        heuristicsApplied: heuristicResults.length,
+        oracleProblemsFound: oracleProblems.length
+      });
+      return {
+        success: true,
+        data: result,
+        metadata: this.createMetadata(context.startTime, context.requestId)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `QX analysis failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  // ============================================================================
+  // Analysis Methods (Ported from V2)
+  // ============================================================================
+  analyzeProblem(context) {
+    const title = context.title || "Untitled page";
+    const description = context.metadata?.description || "";
+    const hasError = context.errorIndicators?.hasErrorMessages || false;
+    let problemStatement = `Evaluate quality experience of "${title}"`;
+    if (description) {
+      problemStatement += ` - ${description.substring(0, 100)}`;
+    }
+    const totalElements = context.domMetrics?.totalElements || 0;
+    const interactiveElements = context.domMetrics?.interactiveElements || 0;
+    const forms = context.domMetrics?.forms || 0;
+    let complexity;
+    if (totalElements > 500 || interactiveElements > 50 || forms > 3) {
+      complexity = "complex";
+    } else if (totalElements > 200 || interactiveElements > 20 || forms > 1) {
+      complexity = "moderate";
+    } else {
+      complexity = "simple";
+    }
+    const breakdown = [];
+    if (context.domMetrics?.semanticStructure?.hasNav) breakdown.push("Navigation structure");
+    if (forms > 0) breakdown.push(`Form interactions (${forms} forms)`);
+    if (interactiveElements > 0) breakdown.push(`User interactions (${interactiveElements} elements)`);
+    if (context.accessibility) breakdown.push("Accessibility compliance");
+    if (context.performance) breakdown.push("Performance metrics");
+    const potentialFailures = [];
+    const titleLower = title.toLowerCase();
+    if (titleLower.includes("health") || titleLower.includes("care") || titleLower.includes("nhs")) {
+      potentialFailures.push({
+        description: "Healthcare information may not be accessible to users with visual impairments",
+        severity: "high",
+        likelihood: "likely"
+      });
+      potentialFailures.push({
+        description: "Patient journey complexity may cause confusion during registration or booking",
+        severity: "medium",
+        likelihood: "possible"
+      });
+      potentialFailures.push({
+        description: "Emergency contact information may not be prominently visible",
+        severity: "high",
+        likelihood: "possible"
+      });
+    }
+    if (!context.domMetrics?.semanticStructure?.hasMain) {
+      potentialFailures.push({
+        description: "Missing main content landmark - users may struggle to find primary content",
+        severity: "medium",
+        likelihood: "likely"
+      });
+    }
+    if (context.accessibility && (context.accessibility.altTextsCoverage || 0) < 80) {
+      potentialFailures.push({
+        description: "Poor image alt text coverage - screen reader users affected",
+        severity: "high",
+        likelihood: "very-likely"
+      });
+    }
+    if (hasError) {
+      potentialFailures.push({
+        description: "Visible error messages detected - potential usability issues",
+        severity: "medium",
+        likelihood: "likely"
+      });
+    }
+    if (context.performance && (context.performance.loadTime || 0) > 3e3) {
+      potentialFailures.push({
+        description: "Slow load time - user frustration and abandonment risk",
+        severity: "high",
+        likelihood: "very-likely"
+      });
+    }
+    while (potentialFailures.length < 3) {
+      if (complexity === "complex") {
+        potentialFailures.push({
+          description: "Complex interaction flows may confuse first-time users",
+          severity: "medium",
+          likelihood: "possible"
+        });
+      } else if (complexity === "moderate") {
+        potentialFailures.push({
+          description: "Multiple interactive elements increase cognitive load",
+          severity: "low",
+          likelihood: "possible"
+        });
+      } else {
+        potentialFailures.push({
+          description: "Limited interactivity may not meet user expectations",
+          severity: "low",
+          likelihood: "possible"
+        });
+      }
+    }
+    let clarityScore = 50;
+    if (title && title !== "Untitled page") clarityScore += 15;
+    if (description) clarityScore += 15;
+    if (breakdown.length >= 3) clarityScore += 10;
+    if (context.domMetrics?.semanticStructure?.hasMain) clarityScore += 10;
+    clarityScore = Math.min(100, clarityScore);
+    return {
+      problemStatement,
+      complexity,
+      breakdown,
+      potentialFailures: potentialFailures.slice(0, 5),
+      clarityScore
+    };
+  }
+  analyzeUserNeeds(context, problemAnalysis) {
+    const needs = [];
+    const challenges = [];
+    const semantic = context.domMetrics?.semanticStructure;
+    const accessibility = context.accessibility;
+    const interactiveElements = context.domMetrics?.interactiveElements || 0;
+    const forms = context.domMetrics?.forms || 0;
+    if (semantic?.hasNav) {
+      needs.push({ description: "Clear navigation to find content", priority: "must-have", addressed: true });
+    } else {
+      challenges.push("Missing navigation structure - users cannot easily explore site");
+      needs.push({ description: "Clear navigation to find content", priority: "must-have", addressed: false });
+    }
+    if (interactiveElements > 0) {
+      needs.push({ description: "Interactive elements for engagement", priority: "must-have", addressed: true });
+    }
+    if (accessibility && (accessibility.focusableElementsCount || 0) > 0) {
+      needs.push({ description: "Keyboard navigation support", priority: "must-have", addressed: true });
+    } else {
+      challenges.push("Limited keyboard navigation - inaccessible to some users");
+      needs.push({ description: "Keyboard navigation support", priority: "must-have", addressed: false });
+    }
+    if (semantic?.hasHeader) {
+      needs.push({ description: "Consistent page header for orientation", priority: "should-have", addressed: true });
+    }
+    if (semantic?.hasFooter) {
+      needs.push({ description: "Footer with supporting information", priority: "should-have", addressed: true });
+    }
+    if (accessibility && (accessibility.altTextsCoverage || 0) > 50) {
+      needs.push({ description: "Image descriptions for screen readers", priority: "should-have", addressed: true });
+    } else if (accessibility && (accessibility.altTextsCoverage || 0) < 50) {
+      challenges.push("Poor alt text coverage - images not accessible");
+      needs.push({ description: "Image descriptions for screen readers", priority: "should-have", addressed: false });
+    }
+    if (context.performance && (context.performance.loadTime || 0) < 3e3) {
+      needs.push({ description: "Fast page load time", priority: "should-have", addressed: true });
+    } else if (context.performance && (context.performance.loadTime || 0) >= 3e3) {
+      challenges.push("Slow load time - user frustration risk");
+      needs.push({ description: "Fast page load time", priority: "should-have", addressed: false });
+    }
+    if (semantic?.hasAside) {
+      needs.push({ description: "Supplementary content sections", priority: "nice-to-have", addressed: true });
+    }
+    if (accessibility && (accessibility.landmarkRoles || 0) > 3) {
+      needs.push({ description: "Rich ARIA landmarks for navigation", priority: "nice-to-have", addressed: true });
+    }
+    if (forms > 0) {
+      needs.push({ description: "Form interactions for user input", priority: "nice-to-have", addressed: true });
+    }
+    const addressedMustHaves = needs.filter((n61) => n61.priority === "must-have" && n61.addressed).length;
+    let suitability;
+    if (challenges.length === 0 && addressedMustHaves >= 3) {
+      suitability = "excellent";
+    } else if (challenges.length <= 1 && addressedMustHaves >= 2) {
+      suitability = "good";
+    } else if (challenges.length <= 2 && addressedMustHaves >= 2) {
+      suitability = "adequate";
+    } else {
+      suitability = "poor";
+    }
+    let alignmentScore = 40;
+    alignmentScore += addressedMustHaves * 10;
+    alignmentScore += needs.filter((n61) => n61.priority === "should-have" && n61.addressed).length * 5;
+    alignmentScore += needs.filter((n61) => n61.priority === "nice-to-have" && n61.addressed).length * 2;
+    alignmentScore -= challenges.length * 8;
+    alignmentScore = Math.max(0, Math.min(100, alignmentScore));
+    return { needs, suitability, challenges, alignmentScore };
+  }
+  analyzeBusinessNeeds(context, problemAnalysis) {
+    const forms = context.domMetrics?.forms || 0;
+    const interactiveElements = context.domMetrics?.interactiveElements || 0;
+    const performance4 = context.performance;
+    const hasErrors = context.errorIndicators?.hasErrorMessages || false;
+    let primaryGoal;
+    let kpisAffected = [];
+    if (forms > 2) {
+      primaryGoal = "business-ease";
+      kpisAffected = ["Form completion rate", "Lead generation", "User sign-ups"];
+    } else if (interactiveElements > 30) {
+      primaryGoal = "user-experience";
+      kpisAffected = ["Time on site", "Click-through rate", "User engagement"];
+    } else {
+      primaryGoal = "balanced";
+      kpisAffected = ["Content consumption", "Bounce rate", "Page views"];
+    }
+    const titleLower = (context.title || "").toLowerCase();
+    if (titleLower.includes("health") || titleLower.includes("care")) {
+      kpisAffected.push("Patient satisfaction", "Appointment completion rate", "Information accessibility");
+    }
+    const crossTeamImpact = [];
+    if (forms > 0) {
+      crossTeamImpact.push({ team: "Marketing", impactType: "positive", description: "Form conversion optimization needed" });
+      crossTeamImpact.push({ team: "Development", impactType: "neutral", description: "Form validation and submission handling" });
+    }
+    if (context.accessibility && (context.accessibility.altTextsCoverage || 0) < 100) {
+      crossTeamImpact.push({ team: "Content", impactType: "negative", description: "Image alt text creation required" });
+    }
+    if (performance4 && (performance4.loadTime || 0) > 2e3) {
+      crossTeamImpact.push({ team: "Engineering", impactType: "negative", description: "Performance optimization needed" });
+    }
+    if (problemAnalysis.complexity === "complex") {
+      crossTeamImpact.push({ team: "QA", impactType: "neutral", description: "Comprehensive testing strategy required" });
+    }
+    let compromisesUX = false;
+    if (hasErrors) compromisesUX = true;
+    if (context.accessibility && (context.accessibility.altTextsCoverage || 0) < 50) compromisesUX = true;
+    if (performance4 && (performance4.loadTime || 0) > 4e3) compromisesUX = true;
+    let alignmentScore = 50;
+    if (kpisAffected.length > 0) alignmentScore += 15;
+    if (crossTeamImpact.length > 0) alignmentScore += 10;
+    if (!compromisesUX) alignmentScore += 20;
+    alignmentScore = Math.min(100, alignmentScore);
+    return {
+      primaryGoal,
+      kpisAffected,
+      crossTeamImpact,
+      compromisesUX,
+      impactsKPIs: kpisAffected.length > 0,
+      alignmentScore
+    };
+  }
+  analyzeCreativity(context, problemAnalysis) {
+    const innovativeApproaches = [];
+    if (problemAnalysis.complexity === "complex" || problemAnalysis.complexity === "moderate") {
+      innovativeApproaches.push({
+        description: "Question fundamental assumptions about user mental models and expected workflows",
+        inspirationSource: "philosophy",
+        applicability: "high",
+        novelty: "moderately-novel"
+      });
+      if (context.errorIndicators?.hasErrorMessages) {
+        innovativeApproaches.push({
+          description: "Apply diagnostic testing - systematically isolate error sources through controlled scenarios",
+          inspirationSource: "medicine",
+          applicability: "high",
+          novelty: "moderately-novel"
+        });
+      }
+    }
+    if (context.domMetrics?.forms && context.domMetrics.forms > 0) {
+      innovativeApproaches.push({
+        description: "Test checkout/form flows like fashion retail - focus on friction points, abandonment triggers",
+        inspirationSource: "e-commerce",
+        applicability: "high",
+        novelty: "incremental"
+      });
+    }
+    innovativeApproaches.push({
+      description: "Analyze through diverse demographic lenses (age, gender, culture, ability) for inclusive testing",
+      inspirationSource: "social science",
+      applicability: "high",
+      novelty: "moderately-novel"
+    });
+    if (context.domMetrics?.interactiveElements && context.domMetrics.interactiveElements > 20) {
+      innovativeApproaches.push({
+        description: 'Test for "game-breaking" exploits - unexpected interaction sequences, boundary conditions',
+        inspirationSource: "gaming",
+        applicability: "medium",
+        novelty: "highly-novel"
+      });
+    }
+    const domainsExplored = [...new Set(innovativeApproaches.map((a37) => a37.inspirationSource))];
+    const perspectives = [
+      "Unexperienced user perspective (fresh eyes)",
+      "Power user perspective (efficiency focus)",
+      "Accessibility perspective (assistive tech users)",
+      "International perspective (cultural differences)"
+    ];
+    let creativityScore = 50;
+    creativityScore += innovativeApproaches.length * 8;
+    creativityScore += domainsExplored.length * 5;
+    creativityScore = Math.min(100, creativityScore);
+    return {
+      innovativeApproaches,
+      domainsExplored,
+      perspectives,
+      creativityScore,
+      notes: [
+        "Creativity draws from diverse domains to uncover unconventional testing approaches",
+        "Higher complexity problems benefit from cross-disciplinary inspiration",
+        `Applied ${innovativeApproaches.length} creative approaches from ${domainsExplored.length} domains`
+      ]
+    };
+  }
+  analyzeDesign(context) {
+    const clearElements = [];
+    const unclearElements = [];
+    if (context.domMetrics?.semanticStructure?.hasNav) {
+      clearElements.push("Navigation structure clearly defined with semantic <nav> element");
+    }
+    if (context.domMetrics?.semanticStructure?.hasMain) {
+      clearElements.push("Main content area clearly identified");
+    }
+    if (context.domMetrics?.semanticStructure?.hasHeader && context.domMetrics?.semanticStructure?.hasFooter) {
+      clearElements.push("Header and footer provide clear page structure");
+    }
+    const ariaLabels = context.accessibility?.ariaLabelsCount || 0;
+    const interactiveElements = context.domMetrics?.interactiveElements || 0;
+    if (interactiveElements > 0 && ariaLabels < interactiveElements * 0.5) {
+      unclearElements.push("Many interactive elements lack ARIA labels for clarity");
+    }
+    let exactnessScore = 50 + clearElements.length * 15 - unclearElements.length * 10;
+    exactnessScore = Math.max(0, Math.min(100, exactnessScore));
+    const clarity = exactnessScore >= 80 ? "excellent" : exactnessScore >= 60 ? "good" : exactnessScore >= 40 ? "adequate" : "poor";
+    const intuitivePatterns = [];
+    const culturalIssues = [];
+    let followsConventions = true;
+    if (context.domMetrics?.semanticStructure?.hasNav) {
+      intuitivePatterns.push("Standard navigation placement");
+    }
+    if (context.domMetrics?.semanticStructure?.hasHeader) {
+      intuitivePatterns.push("Header follows common layout conventions");
+    }
+    if (!context.domMetrics?.semanticStructure?.hasNav && interactiveElements > 10) {
+      followsConventions = false;
+      culturalIssues.push("Non-standard navigation pattern may confuse users from different regions");
+    }
+    let intuitiveScore = 50 + intuitivePatterns.length * 15;
+    if (!followsConventions) intuitiveScore -= 20;
+    intuitiveScore = Math.max(0, Math.min(100, intuitiveScore));
+    const overallDesignScore = Math.round((exactnessScore + intuitiveScore) / 2);
+    return {
+      exactness: {
+        clarity,
+        clearElements,
+        unclearElements,
+        score: exactnessScore
+      },
+      intuitive: {
+        followsConventions,
+        intuitivePatterns,
+        culturalIssues,
+        score: intuitiveScore
+      },
+      counterIntuitive: {
+        deviations: [],
+        innovativeJustification: false,
+        freshEyesPerspective: true,
+        issuesCount: 0
+      },
+      overallDesignScore
+    };
+  }
+  generateRecommendations(problemAnalysis, userNeeds, businessNeeds, oracleProblems, impactAnalysis, heuristics) {
+    const recommendations = [];
+    let priority = 1;
+    for (const heuristic of heuristics) {
+      for (const issue of heuristic.issues) {
+        if (issue.severity === "critical" || issue.severity === "high") {
+          recommendations.push({
+            principle: heuristic.name,
+            recommendation: issue.description,
+            severity: issue.severity,
+            impact: issue.severity === "critical" ? 90 : 75,
+            effort: "medium",
+            priority: priority++,
+            category: "qx"
+          });
+        }
+      }
+      for (const rec of heuristic.recommendations) {
+        recommendations.push({
+          principle: heuristic.name,
+          recommendation: rec,
+          severity: "medium",
+          impact: 60,
+          effort: "medium",
+          priority: priority++,
+          category: "qx"
+        });
+      }
+    }
+    for (const oracle of oracleProblems) {
+      recommendations.push({
+        principle: `Oracle: ${oracle.type}`,
+        recommendation: oracle.description,
+        severity: oracle.severity,
+        impact: oracle.severity === "critical" ? 95 : oracle.severity === "high" ? 80 : 60,
+        effort: "high",
+        priority: priority++,
+        category: "process",
+        evidence: oracle.resolutionApproach
+      });
+    }
+    for (const challenge of userNeeds.challenges) {
+      recommendations.push({
+        principle: "User Needs",
+        recommendation: challenge,
+        severity: "medium",
+        impact: 65,
+        effort: "medium",
+        priority: priority++,
+        category: "ux"
+      });
+    }
+    return recommendations.sort((a37, b68) => {
+      const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      const severityDiff = severityOrder[a37.severity] - severityOrder[b68.severity];
+      if (severityDiff !== 0) return severityDiff;
+      return b68.impact - a37.impact;
+    }).slice(0, 15);
+  }
+  calculateOverallScore(problemAnalysis, userNeeds, businessNeeds, creativityAnalysis, designAnalysis, impactAnalysis, heuristics) {
+    const heuristicsAvg = heuristics.reduce((sum, h66) => sum + h66.score, 0) / heuristics.length || 0;
+    const score = problemAnalysis.clarityScore * 0.1 + userNeeds.alignmentScore * 0.2 + businessNeeds.alignmentScore * 0.15 + creativityAnalysis.creativityScore * 0.1 + designAnalysis.overallDesignScore * 0.15 + (100 - impactAnalysis.overallImpactScore) * 0.1 + heuristicsAvg * 0.2;
+    return Math.round(Math.max(0, Math.min(100, score)));
+  }
+  scoreToGrade(score) {
+    if (score >= 90) return "A";
+    if (score >= 80) return "B";
+    if (score >= 70) return "C";
+    if (score >= 60) return "D";
+    return "F";
+  }
+  createMinimalContext(target) {
+    return {
+      url: target,
+      title: target
+    };
+  }
+  createMinimalCreativityAnalysis() {
+    return {
+      innovativeApproaches: [],
+      domainsExplored: [],
+      perspectives: [],
+      creativityScore: 50,
+      notes: ["Creativity analysis skipped"]
+    };
+  }
+  createMinimalDesignAnalysis() {
+    return {
+      exactness: { clarity: "adequate", clearElements: [], unclearElements: [], score: 50 },
+      intuitive: { followsConventions: true, intuitivePatterns: [], culturalIssues: [], score: 50 },
+      counterIntuitive: { deviations: [], innovativeJustification: false, freshEyesPerspective: false, issuesCount: 0 },
+      overallDesignScore: 50
+    };
+  }
+  // Helper methods from base class
+  emitStream(context, data) {
+    if (context.streaming && context.onStream) {
+      context.onStream(data);
+    }
+  }
+  isAborted(context) {
+    return context.abortSignal?.aborted || false;
+  }
+  createMetadata(startTime, requestId) {
+    return {
+      executionTime: Date.now() - startTime,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      requestId
+    };
+  }
+};
+var qxAnalyzeTool = new QXAnalyzeTool();
+
 // src/mcp/tools/registry.ts
 var QE_TOOL_NAMES = {
   // Test Generation
@@ -146284,7 +147601,9 @@ var QE_TOOL_NAMES = {
   EMBEDDING_STORE: "qe/embeddings/store",
   EMBEDDING_STATS: "qe/embeddings/stats",
   // Coherence Tools (ADR-052)
-  ...COHERENCE_TOOL_NAMES
+  ...COHERENCE_TOOL_NAMES,
+  // QX Analysis (Quality Experience)
+  QX_ANALYZE: "qe/qx/analyze"
 };
 var QE_TOOLS = [
   // Test Generation Domain
@@ -146330,7 +147649,9 @@ var QE_TOOLS = [
   new EmbeddingStoreTool(),
   new EmbeddingStatsTool(),
   // Coherence Tools (ADR-052)
-  ...COHERENCE_TOOLS
+  ...COHERENCE_TOOLS,
+  // QX Analysis (Quality Experience)
+  new QXAnalyzeTool()
 ];
 function resetAllToolCaches() {
   for (const tool of QE_TOOLS) {