agentic-qe 3.3.0 → 3.3.1

package/v3/dist/mcp/bundle.js

@@ -7279,12 +7279,11 @@ var init_types3 = __esm({
   }
 });
 
-// src/integrations/agentic-flow/model-router/complexity-analyzer.ts
-var COMPLEXITY_KEYWORDS, SCOPE_PATTERNS, ComplexityAnalyzer;
-var init_complexity_analyzer = __esm({
-  "src/integrations/agentic-flow/model-router/complexity-analyzer.ts"() {
+// src/integrations/agentic-flow/model-router/signal-collector.ts
+var COMPLEXITY_KEYWORDS, SCOPE_PATTERNS, SignalCollector;
+var init_signal_collector = __esm({
+  "src/integrations/agentic-flow/model-router/signal-collector.ts"() {
     "use strict";
-    init_types3();
     init_types2();
     COMPLEXITY_KEYWORDS = {
       // Tier 0 - Mechanical transforms
@@ -7348,7 +7347,7 @@ var init_complexity_analyzer = __esm({
       multiStep: /\b(orchestrate|coordinate|workflow|pipeline|multi[- ]step)\b/i,
       crossDomain: /\b(cross[- ]domain|across (domains|modules)|integrate|coordination)\b/i
     };
-    ComplexityAnalyzer = class {
+    SignalCollector = class {
       config;
       agentBoosterAdapter;
       constructor(config, agentBoosterAdapter) {
@@ -7356,46 +7355,44 @@ var init_complexity_analyzer = __esm({
         this.agentBoosterAdapter = agentBoosterAdapter;
       }
       /**
-       * Analyze task complexity
+       * Collect all complexity signals from input
        */
-      async analyze(input) {
-        const startTime = Date.now();
-        try {
-          const signals = await this.collectSignals(input);
-          const codeComplexity = this.calculateCodeComplexity(signals);
-          const reasoningComplexity = this.calculateReasoningComplexity(signals);
-          const scopeComplexity = this.calculateScopeComplexity(signals);
-          const overall = this.calculateOverallComplexity(
-            codeComplexity,
-            reasoningComplexity,
-            scopeComplexity,
-            signals
-          );
-          const recommendedTier = this.getRecommendedTier(overall);
-          const alternateTiers = this.findAlternateTiers(overall, recommendedTier);
-          const confidence = this.calculateConfidence(signals, input);
-          const explanation = this.generateExplanation(
-            overall,
-            recommendedTier,
-            signals
-          );
-          return {
-            overall,
-            codeComplexity,
-            reasoningComplexity,
-            scopeComplexity,
-            confidence,
-            signals,
-            recommendedTier,
-            alternateTiers,
-            explanation
-          };
-        } catch (error) {
-          throw new ComplexityAnalysisError(
-            `Failed to analyze task complexity: ${error instanceof Error ? error.message : "Unknown error"}`,
-            error instanceof Error ? error : void 0
-          );
-        }
+      async collectSignals(input) {
+        const taskLower = input.task.toLowerCase();
+        const agentBoosterCheck = await this.checkAgentBoosterEligibility(input);
+        const keywordMatches = {
+          simple: this.findKeywordMatches(taskLower, COMPLEXITY_KEYWORDS.simple),
+          moderate: this.findKeywordMatches(taskLower, COMPLEXITY_KEYWORDS.moderate),
+          complex: this.findKeywordMatches(taskLower, COMPLEXITY_KEYWORDS.complex),
+          critical: this.findKeywordMatches(taskLower, COMPLEXITY_KEYWORDS.critical)
+        };
+        const linesOfCode = input.codeContext ? input.codeContext.split("\n").length : void 0;
+        const fileCount = input.filePaths ? input.filePaths.length : void 0;
+        const hasArchitectureScope = SCOPE_PATTERNS.architecture.test(taskLower);
+        const hasSecurityScope = SCOPE_PATTERNS.security.test(taskLower);
+        const requiresMultiStepReasoning = SCOPE_PATTERNS.multiStep.test(taskLower);
+        const requiresCrossDomainCoordination = SCOPE_PATTERNS.crossDomain.test(taskLower);
+        const requiresCreativity = this.detectCreativityRequirement(taskLower);
+        const languageComplexity = this.estimateLanguageComplexity(
+          input.codeContext,
+          input.filePaths
+        );
+        const cyclomaticComplexity = input.codeContext ? this.estimateCyclomaticComplexity(input.codeContext) : void 0;
+        return {
+          linesOfCode,
+          fileCount,
+          hasArchitectureScope,
+          hasSecurityScope,
+          requiresMultiStepReasoning,
+          requiresCrossDomainCoordination,
+          isMechanicalTransform: agentBoosterCheck.eligible,
+          languageComplexity,
+          cyclomaticComplexity,
+          dependencyCount: this.countDependencies(input.codeContext),
+          requiresCreativity,
+          detectedTransformType: agentBoosterCheck.transformType,
+          keywordMatches
+        };
       }
       /**
        * Check if task is eligible for Agent Booster (Tier 0)
@@ -7416,7 +7413,12 @@ var init_complexity_analyzer = __esm({
           let confidence = 0;
           for (const keyword of keywords) {
             if (taskLower.includes(keyword.toLowerCase())) {
-              confidence += 0.2;
+              confidence = confidence === 0 ? 0.5 : confidence + 0.25;
+            }
+          }
+          for (const mechanicalKeyword of COMPLEXITY_KEYWORDS.mechanical) {
+            if (taskLower.includes(mechanicalKeyword.toLowerCase())) {
+              confidence = Math.max(confidence, 0.6);
             }
           }
           if (confidence > maxConfidence) {
@@ -7451,143 +7453,8 @@ var init_complexity_analyzer = __esm({
           reason: eligible ? `Detected ${detectedTransformType} transform pattern` : "No mechanical transform pattern detected"
         };
       }
-      /**
-       * Get recommended tier based on complexity score
-       */
-      getRecommendedTier(complexity) {
-        for (const tier of [0, 1, 2, 3, 4]) {
-          const [min, max] = TIER_METADATA[tier].complexityRange;
-          if (complexity >= min && complexity <= max) {
-            return tier;
-          }
-        }
-        return 2;
-      }
-      // ============================================================================
-      // Private: Signal Collection
-      // ============================================================================
-      /**
-       * Collect all complexity signals from input
-       */
-      async collectSignals(input) {
-        const taskLower = input.task.toLowerCase();
-        const codeLower = input.codeContext?.toLowerCase() || "";
-        const agentBoosterCheck = await this.checkAgentBoosterEligibility(input);
-        const keywordMatches = {
-          simple: this.findKeywordMatches(taskLower, COMPLEXITY_KEYWORDS.simple),
-          moderate: this.findKeywordMatches(taskLower, COMPLEXITY_KEYWORDS.moderate),
-          complex: this.findKeywordMatches(taskLower, COMPLEXITY_KEYWORDS.complex),
-          critical: this.findKeywordMatches(taskLower, COMPLEXITY_KEYWORDS.critical)
-        };
-        const linesOfCode = input.codeContext ? input.codeContext.split("\n").length : void 0;
-        const fileCount = input.filePaths ? input.filePaths.length : void 0;
-        const hasArchitectureScope = SCOPE_PATTERNS.architecture.test(taskLower);
-        const hasSecurityScope = SCOPE_PATTERNS.security.test(taskLower);
-        const requiresMultiStepReasoning = SCOPE_PATTERNS.multiStep.test(taskLower);
-        const requiresCrossDomainCoordination = SCOPE_PATTERNS.crossDomain.test(taskLower);
-        const requiresCreativity = taskLower.includes("design") || taskLower.includes("creative") || taskLower.includes("innovative") || taskLower.includes("novel");
-        const languageComplexity = this.estimateLanguageComplexity(
-          input.codeContext,
-          input.filePaths
-        );
-        const cyclomaticComplexity = input.codeContext ? this.estimateCyclomaticComplexity(input.codeContext) : void 0;
-        return {
-          linesOfCode,
-          fileCount,
-          hasArchitectureScope,
-          hasSecurityScope,
-          requiresMultiStepReasoning,
-          requiresCrossDomainCoordination,
-          isMechanicalTransform: agentBoosterCheck.eligible,
-          languageComplexity,
-          cyclomaticComplexity,
-          dependencyCount: this.countDependencies(input.codeContext),
-          requiresCreativity,
-          detectedTransformType: agentBoosterCheck.transformType,
-          keywordMatches
-        };
-      }
-      // ============================================================================
-      // Private: Complexity Calculation
-      // ============================================================================
-      /**
-       * Calculate code complexity component (0-100)
-       */
-      calculateCodeComplexity(signals) {
-        let score = 0;
-        if (signals.linesOfCode !== void 0) {
-          if (signals.linesOfCode < 10) score += 0;
-          else if (signals.linesOfCode < 50) score += 10;
-          else if (signals.linesOfCode < 200) score += 20;
-          else score += 30;
-        }
-        if (signals.fileCount !== void 0) {
-          if (signals.fileCount === 1) score += 0;
-          else if (signals.fileCount < 5) score += 10;
-          else score += 20;
-        }
-        if (signals.cyclomaticComplexity !== void 0) {
-          if (signals.cyclomaticComplexity < 5) score += 0;
-          else if (signals.cyclomaticComplexity < 10) score += 10;
-          else if (signals.cyclomaticComplexity < 20) score += 20;
-          else score += 30;
-        }
-        if (signals.languageComplexity === "low") score += 0;
-        else if (signals.languageComplexity === "medium") score += 10;
-        else if (signals.languageComplexity === "high") score += 20;
-        return Math.min(score, 100);
-      }
-      /**
-       * Calculate reasoning complexity component (0-100)
-       */
-      calculateReasoningComplexity(signals) {
-        let score = 0;
-        const keywordScore = signals.keywordMatches.simple.length * 5 + signals.keywordMatches.moderate.length * 15 + signals.keywordMatches.complex.length * 25 + signals.keywordMatches.critical.length * 35;
-        score += Math.min(keywordScore, 60);
-        if (signals.requiresMultiStepReasoning) score += 20;
-        if (signals.requiresCreativity) score += 20;
-        return Math.min(score, 100);
-      }
-      /**
-       * Calculate scope complexity component (0-100)
-       */
-      calculateScopeComplexity(signals) {
-        let score = 0;
-        if (signals.hasArchitectureScope) score += 40;
-        if (signals.hasSecurityScope) score += 30;
-        if (signals.requiresCrossDomainCoordination) score += 20;
-        if (signals.dependencyCount !== void 0) {
-          if (signals.dependencyCount < 3) score += 0;
-          else if (signals.dependencyCount < 10) score += 5;
-          else score += 10;
-        }
-        return Math.min(score, 100);
-      }
-      /**
-       * Calculate overall complexity score (0-100)
-       */
-      calculateOverallComplexity(codeComplexity, reasoningComplexity, scopeComplexity, signals) {
-        if (signals.isMechanicalTransform) {
-          return 5;
-        }
-        const weighted = codeComplexity * 0.3 + reasoningComplexity * 0.4 + scopeComplexity * 0.3;
-        return Math.min(Math.round(weighted), 100);
-      }
-      /**
-       * Calculate confidence in complexity assessment (0-1)
-       */
-      calculateConfidence(signals, input) {
-        let confidence = 0.5;
-        if (input.codeContext) confidence += 0.2;
-        if (input.filePaths && input.filePaths.length > 0) confidence += 0.1;
-        const totalKeywords = signals.keywordMatches.simple.length + signals.keywordMatches.moderate.length + signals.keywordMatches.complex.length + signals.keywordMatches.critical.length;
-        if (totalKeywords >= 3) confidence += 0.1;
-        else if (totalKeywords >= 1) confidence += 0.05;
-        if (signals.isMechanicalTransform) confidence += 0.15;
-        return Math.min(confidence, 1);
-      }
       // ============================================================================
-      // Private: Helper Methods
+      // Private Helper Methods
       // ============================================================================
       /**
        * Find matching keywords in text
@@ -7601,6 +7468,12 @@ var init_complexity_analyzer = __esm({
         }
         return matches;
       }
+      /**
+       * Detect creativity requirements from task text
+       */
+      detectCreativityRequirement(taskLower) {
+        return taskLower.includes("design") || taskLower.includes("creative") || taskLower.includes("innovative") || taskLower.includes("novel");
+      }
       /**
        * Estimate language complexity from code context
        */
@@ -7668,23 +7541,205 @@ var init_complexity_analyzer = __esm({
        */
       getTransformKeywords(transformType) {
         const keywordMap = {
-          "var-to-const": ["var to const", "convert var", "var declaration"],
-          "add-types": ["add types", "typescript types", "type annotations"],
-          "remove-console": ["remove console", "delete console", "console.log"],
+          "var-to-const": [
+            "var to const",
+            "convert var",
+            "var declaration",
+            "var to let",
+            "convert var to const",
+            // Added explicit full phrase
+            "change var to const"
+          ],
+          "add-types": [
+            "add types",
+            "add type",
+            "typescript types",
+            "type annotations",
+            "type annotation",
+            "add type annotations"
+          ],
+          "remove-console": [
+            "remove console",
+            "delete console",
+            "console.log",
+            "remove console.log",
+            "strip console"
+          ],
           "promise-to-async": [
             "promise to async",
             "async await",
-            ".then to async"
+            ".then to async",
+            "convert to async",
+            "convert function to async"
           ],
           "cjs-to-esm": [
             "commonjs to esm",
             "require to import",
-            "convert to esm"
+            "convert to esm",
+            "cjs to esm",
+            "module conversion"
           ],
-          "func-to-arrow": ["arrow function", "function to arrow", "convert to arrow"]
+          "func-to-arrow": [
+            "arrow function",
+            "function to arrow",
+            "convert to arrow",
+            "convert function to arrow"
+          ]
         };
         return keywordMap[transformType] || [];
       }
+    };
+  }
+});
+
+// src/integrations/agentic-flow/model-router/score-calculator.ts
+var ScoreCalculator;
+var init_score_calculator = __esm({
+  "src/integrations/agentic-flow/model-router/score-calculator.ts"() {
+    "use strict";
+    ScoreCalculator = class {
+      /**
+       * Calculate code complexity component (0-100)
+       */
+      calculateCodeComplexity(signals) {
+        let score = 0;
+        score += this.calculateLinesOfCodeContribution(signals.linesOfCode);
+        score += this.calculateFileCountContribution(signals.fileCount);
+        score += this.calculateCyclomaticContribution(signals.cyclomaticComplexity);
+        score += this.calculateLanguageContribution(signals.languageComplexity);
+        return Math.min(score, 100);
+      }
+      /**
+       * Calculate reasoning complexity component (0-100)
+       */
+      calculateReasoningComplexity(signals) {
+        let score = 0;
+        score += this.calculateKeywordScore(signals.keywordMatches);
+        if (signals.requiresMultiStepReasoning) score += 20;
+        if (signals.requiresCreativity) score += 20;
+        return Math.min(score, 100);
+      }
+      /**
+       * Calculate scope complexity component (0-100)
+       */
+      calculateScopeComplexity(signals) {
+        let score = 0;
+        if (signals.hasArchitectureScope) score += 40;
+        if (signals.hasSecurityScope) score += 30;
+        if (signals.requiresCrossDomainCoordination) score += 20;
+        score += this.calculateDependencyContribution(signals.dependencyCount);
+        return Math.min(score, 100);
+      }
+      /**
+       * Calculate overall complexity score (0-100)
+       */
+      calculateOverallComplexity(codeComplexity, reasoningComplexity, scopeComplexity, signals) {
+        if (signals.isMechanicalTransform) {
+          return 5;
+        }
+        const weighted = codeComplexity * 0.3 + reasoningComplexity * 0.4 + scopeComplexity * 0.3;
+        return Math.min(Math.round(weighted), 100);
+      }
+      /**
+       * Calculate confidence in complexity assessment (0-1)
+       */
+      calculateConfidence(signals, input) {
+        let confidence = 0.5;
+        if (input.codeContext) confidence += 0.2;
+        if (input.filePaths && input.filePaths.length > 0) confidence += 0.1;
+        confidence += this.calculateKeywordConfidenceBoost(signals.keywordMatches);
+        if (signals.isMechanicalTransform) confidence += 0.15;
+        return Math.min(confidence, 1);
+      }
+      // ============================================================================
+      // Private Helper Methods
+      // ============================================================================
+      /**
+       * Calculate lines of code contribution (0-30 points)
+       */
+      calculateLinesOfCodeContribution(linesOfCode) {
+        if (linesOfCode === void 0) return 0;
+        if (linesOfCode < 10) return 0;
+        if (linesOfCode < 50) return 10;
+        if (linesOfCode < 200) return 20;
+        return 30;
+      }
+      /**
+       * Calculate file count contribution (0-20 points)
+       */
+      calculateFileCountContribution(fileCount) {
+        if (fileCount === void 0) return 0;
+        if (fileCount === 1) return 0;
+        if (fileCount < 5) return 10;
+        return 20;
+      }
+      /**
+       * Calculate cyclomatic complexity contribution (0-30 points)
+       */
+      calculateCyclomaticContribution(cyclomaticComplexity) {
+        if (cyclomaticComplexity === void 0) return 0;
+        if (cyclomaticComplexity < 5) return 0;
+        if (cyclomaticComplexity < 10) return 10;
+        if (cyclomaticComplexity < 20) return 20;
+        return 30;
+      }
+      /**
+       * Calculate language complexity contribution (0-20 points)
+       */
+      calculateLanguageContribution(languageComplexity) {
+        if (languageComplexity === "low") return 0;
+        if (languageComplexity === "medium") return 10;
+        if (languageComplexity === "high") return 20;
+        return 0;
+      }
+      /**
+       * Calculate keyword score (0-60 points)
+       */
+      calculateKeywordScore(keywordMatches) {
+        const keywordScore = keywordMatches.simple.length * 5 + keywordMatches.moderate.length * 15 + keywordMatches.complex.length * 25 + keywordMatches.critical.length * 35;
+        return Math.min(keywordScore, 60);
+      }
+      /**
+       * Calculate dependency count contribution (0-10 points)
+       */
+      calculateDependencyContribution(dependencyCount) {
+        if (dependencyCount === void 0) return 0;
+        if (dependencyCount < 3) return 0;
+        if (dependencyCount < 10) return 5;
+        return 10;
+      }
+      /**
+       * Calculate confidence boost from keyword matches (0-0.1)
+       */
+      calculateKeywordConfidenceBoost(keywordMatches) {
+        const totalKeywords = keywordMatches.simple.length + keywordMatches.moderate.length + keywordMatches.complex.length + keywordMatches.critical.length;
+        if (totalKeywords >= 3) return 0.1;
+        if (totalKeywords >= 1) return 0.05;
+        return 0;
+      }
+    };
+  }
+});
+
+// src/integrations/agentic-flow/model-router/tier-recommender.ts
+var TierRecommender;
+var init_tier_recommender = __esm({
+  "src/integrations/agentic-flow/model-router/tier-recommender.ts"() {
+    "use strict";
+    init_types3();
+    TierRecommender = class {
+      /**
+       * Get recommended tier based on complexity score
+       */
+      getRecommendedTier(complexity) {
+        for (const tier of [0, 1, 2, 3, 4]) {
+          const [min, max] = TIER_METADATA[tier].complexityRange;
+          if (complexity >= min && complexity <= max) {
+            return tier;
+          }
+        }
+        return 2;
+      }
       /**
        * Find alternative tiers that could handle this task
        */
@@ -7708,29 +7763,143 @@ var init_complexity_analyzer = __esm({
         const parts = [];
         parts.push(`Complexity score: ${overall}/100 (Tier ${tier})`);
         if (signals.isMechanicalTransform) {
-          parts.push(
-            `Detected mechanical transform: ${signals.detectedTransformType}`
-          );
+          parts.push(this.formatMechanicalTransformInfo(signals.detectedTransformType));
         }
+        parts.push(...this.formatScopeExplanations(signals));
+        parts.push(...this.formatCodeMetricsExplanations(signals));
+        return parts.join(". ");
+      }
+      // ============================================================================
+      // Private Helper Methods
+      // ============================================================================
+      /**
+       * Format mechanical transform information
+       */
+      formatMechanicalTransformInfo(transformType) {
+        return `Detected mechanical transform: ${transformType}`;
+      }
+      /**
+       * Format scope-related explanations
+       */
+      formatScopeExplanations(signals) {
+        const explanations = [];
         if (signals.hasArchitectureScope) {
-          parts.push("Architecture scope detected");
+          explanations.push("Architecture scope detected");
         }
         if (signals.hasSecurityScope) {
-          parts.push("Security scope detected");
+          explanations.push("Security scope detected");
         }
         if (signals.requiresMultiStepReasoning) {
-          parts.push("Multi-step reasoning required");
+          explanations.push("Multi-step reasoning required");
         }
         if (signals.requiresCrossDomainCoordination) {
-          parts.push("Cross-domain coordination required");
+          explanations.push("Cross-domain coordination required");
         }
+        return explanations;
+      }
+      /**
+       * Format code metrics explanations
+       */
+      formatCodeMetricsExplanations(signals) {
+        const explanations = [];
         if (signals.linesOfCode !== void 0 && signals.linesOfCode > 100) {
-          parts.push(`Large code change: ${signals.linesOfCode} lines`);
+          explanations.push(`Large code change: ${signals.linesOfCode} lines`);
         }
         if (signals.fileCount !== void 0 && signals.fileCount > 3) {
-          parts.push(`Multi-file change: ${signals.fileCount} files`);
+          explanations.push(`Multi-file change: ${signals.fileCount} files`);
         }
-        return parts.join(". ");
+        return explanations;
+      }
+    };
+  }
+});
+
+// src/integrations/agentic-flow/model-router/complexity-analyzer.ts
+function createComplexityAnalyzer(config, agentBoosterAdapter) {
+  const signalCollector = new SignalCollector(config, agentBoosterAdapter);
+  const scoreCalculator = new ScoreCalculator();
+  const tierRecommender = new TierRecommender();
+  return new ComplexityAnalyzer(
+    config,
+    signalCollector,
+    scoreCalculator,
+    tierRecommender
+  );
+}
+var ComplexityAnalyzer;
+var init_complexity_analyzer = __esm({
+  "src/integrations/agentic-flow/model-router/complexity-analyzer.ts"() {
+    "use strict";
+    init_types3();
+    init_signal_collector();
+    init_score_calculator();
+    init_tier_recommender();
+    init_signal_collector();
+    init_score_calculator();
+    init_tier_recommender();
+    ComplexityAnalyzer = class {
+      config;
+      signalCollector;
+      scoreCalculator;
+      tierRecommender;
+      constructor(config, signalCollector, scoreCalculator, tierRecommender) {
+        this.config = config;
+        this.signalCollector = signalCollector;
+        this.scoreCalculator = scoreCalculator;
+        this.tierRecommender = tierRecommender;
+      }
+      /**
+       * Analyze task complexity
+       */
+      async analyze(input) {
+        try {
+          const signals = await this.signalCollector.collectSignals(input);
+          const codeComplexity = this.scoreCalculator.calculateCodeComplexity(signals);
+          const reasoningComplexity = this.scoreCalculator.calculateReasoningComplexity(signals);
+          const scopeComplexity = this.scoreCalculator.calculateScopeComplexity(signals);
+          const overall = this.scoreCalculator.calculateOverallComplexity(
+            codeComplexity,
+            reasoningComplexity,
+            scopeComplexity,
+            signals
+          );
+          const recommendedTier = this.tierRecommender.getRecommendedTier(overall);
+          const alternateTiers = this.tierRecommender.findAlternateTiers(overall, recommendedTier);
+          const confidence = this.scoreCalculator.calculateConfidence(signals, input);
+          const explanation = this.tierRecommender.generateExplanation(
+            overall,
+            recommendedTier,
+            signals
+          );
+          return {
+            overall,
+            codeComplexity,
+            reasoningComplexity,
+            scopeComplexity,
+            confidence,
+            signals,
+            recommendedTier,
+            alternateTiers,
+            explanation
+          };
+        } catch (error) {
+          throw new ComplexityAnalysisError(
+            `Failed to analyze task complexity: ${error instanceof Error ? error.message : "Unknown error"}`,
+            error instanceof Error ? error : void 0
+          );
+        }
+      }
+      /**
+       * Check if task is eligible for Agent Booster (Tier 0)
+       */
+      async checkAgentBoosterEligibility(input) {
+        return this.signalCollector.checkAgentBoosterEligibility(input);
+      }
+      /**
+       * Get recommended tier based on complexity score
+       */
+      getRecommendedTier(complexity) {
+        return this.tierRecommender.getRecommendedTier(complexity);
       }
     };
   }
@@ -8303,7 +8472,7 @@ var init_router = __esm({
         this.config = { ...DEFAULT_ROUTER_CONFIG, ...config };
         this.agentBoosterAdapter = agentBoosterAdapter;
         this.persistentMetricsTracker = persistentMetricsTracker;
-        this.complexityAnalyzer = new ComplexityAnalyzer(
+        this.complexityAnalyzer = createComplexityAnalyzer(
           this.config,
           agentBoosterAdapter
         );
@@ -10869,7 +11038,740 @@ function err(error) {
   return { success: false, error };
 }
 
+// src/mcp/security/validators/path-traversal-validator.ts
+var PATH_TRAVERSAL_PATTERNS = [
+  /\.\./,
+  // Basic traversal
+  /%2e%2e/i,
+  // URL encoded ..
+  /%252e%252e/i,
+  // Double URL encoded
+  /\.\.%2f/i,
+  // Mixed encoding
+  /%2f\.\./i,
+  // Forward slash + ..
+  /\.\.%5c/i,
+  // Backslash + ..
+  /\.\.\\/,
+  // Windows backslash traversal
+  /%c0%ae/i,
+  // UTF-8 overlong encoding
+  /%c0%2f/i,
+  // UTF-8 overlong /
+  /%c1%9c/i,
+  // UTF-8 overlong \
+  /\0/,
+  // Null byte injection
+  /%00/i
+  // URL encoded null
+];
+var DANGEROUS_PATH_COMPONENTS = [
+  /^\/etc\//i,
+  /^\/proc\//i,
+  /^\/sys\//i,
+  /^\/dev\//i,
+  /^\/root\//i,
+  /^\/home\/.+\/\./i,
+  /^[A-Z]:\\Windows/i,
+  /^[A-Z]:\\System/i,
+  /^[A-Z]:\\Users\\.+\\AppData/i
+];
+var PathTraversalValidator = class {
+  name = "path-traversal";
+  /**
+   * Get the primary risk level this validator addresses
+   */
+  getRiskLevel() {
+    return "critical";
+  }
+  /**
+   * Validate a file path against traversal attacks
+   */
+  validate(path16, options = {}) {
+    const {
+      basePath = "",
+      allowAbsolute = false,
+      allowedExtensions = [],
+      deniedExtensions = [".exe", ".bat", ".cmd", ".sh", ".ps1", ".dll", ".so"],
+      maxDepth = 10,
+      maxLength = 4096
+    } = options;
+    if (path16.length > maxLength) {
+      return {
+        valid: false,
+        error: `Path exceeds maximum length of ${maxLength}`,
+        riskLevel: "medium"
+      };
+    }
+    for (const pattern of PATH_TRAVERSAL_PATTERNS) {
+      if (pattern.test(path16)) {
+        return {
+          valid: false,
+          error: "Path traversal attempt detected",
+          riskLevel: "critical"
+        };
+      }
+    }
+    if (!allowAbsolute && (path16.startsWith("/") || /^[A-Z]:/i.test(path16))) {
+      return {
+        valid: false,
+        error: "Absolute paths are not allowed",
+        riskLevel: "high"
+      };
+    }
+    for (const pattern of DANGEROUS_PATH_COMPONENTS) {
+      if (pattern.test(path16)) {
+        return {
+          valid: false,
+          error: "Access to system paths is not allowed",
+          riskLevel: "critical"
+        };
+      }
+    }
+    const normalizedPath = this.normalizePath(path16);
+    if (normalizedPath.includes("..")) {
+      return {
+        valid: false,
+        error: "Path traversal detected after normalization",
+        riskLevel: "critical"
+      };
+    }
+    const depth = normalizedPath.split("/").filter(Boolean).length;
+    if (depth > maxDepth) {
+      return {
+        valid: false,
+        error: `Path depth exceeds maximum of ${maxDepth}`,
+        riskLevel: "low"
+      };
+    }
+    const ext = this.getExtension(normalizedPath);
+    if (ext) {
+      const extWithDot = `.${ext.toLowerCase()}`;
+      const extWithoutDot = ext.toLowerCase();
+      if (deniedExtensions.length > 0) {
+        const isDenied = deniedExtensions.some(
+          (denied) => denied.toLowerCase() === extWithDot || denied.toLowerCase() === extWithoutDot
+        );
+        if (isDenied) {
+          return {
+            valid: false,
+            error: `File extension '${ext}' is not allowed`,
+            riskLevel: "high"
+          };
+        }
+      }
+      if (allowedExtensions.length > 0) {
+        const isAllowed = allowedExtensions.some(
+          (allowed) => allowed.toLowerCase() === extWithDot || allowed.toLowerCase() === extWithoutDot
+        );
+        if (!isAllowed) {
+          return {
+            valid: false,
+            error: `File extension '${ext}' is not in allowed list`,
+            riskLevel: "medium"
+          };
+        }
+      }
+    }
+    const finalPath = basePath ? this.joinPathsAbsolute(basePath, normalizedPath) : normalizedPath;
+    const normalizedBase = basePath.startsWith("/") ? `/${this.normalizePath(basePath)}` : this.normalizePath(basePath);
+    if (basePath && !finalPath.startsWith(normalizedBase)) {
+      return {
+        valid: false,
+        error: "Path escapes base directory",
+        riskLevel: "critical"
+      };
+    }
+    return {
+      valid: true,
+      normalizedPath: finalPath,
+      riskLevel: "none"
+    };
+  }
+  /**
+   * Normalize a path by resolving . and .. components
+   */
+  normalizePath(path16) {
+    let normalized = path16.replace(/\\/g, "/");
+    normalized = normalized.replace(/\/+/g, "/");
+    const parts = normalized.split("/");
+    const result = [];
+    for (const part of parts) {
+      if (part === "." || part === "") {
+        continue;
+      }
+      if (part === "..") {
+        if (result.length > 0 && result[result.length - 1] !== "..") {
+          result.pop();
+        }
+      } else {
+        result.push(part);
+      }
+    }
+    return result.join("/");
+  }
+  /**
+   * Safely join path components (strips leading/trailing slashes from all parts)
+   */
+  joinPaths(...paths) {
+    if (paths.length === 0) return "";
+    return paths.map((p) => p.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+  }
+  /**
+   * Join paths preserving absolute path from first component
+   */
+  joinPathsAbsolute(...paths) {
+    if (paths.length === 0) return "";
+    const isAbsolute4 = paths[0].startsWith("/");
+    const result = paths.map((p) => {
+      while (p.startsWith("/")) p = p.slice(1);
+      while (p.endsWith("/")) p = p.slice(0, -1);
+      return p;
+    }).filter(Boolean).join("/");
+    return isAbsolute4 ? `/${result}` : result;
+  }
+  /**
+   * Get file extension from path
+   */
+  getExtension(path16) {
+    const match = path16.match(/\.([^./\\]+)$/);
+    return match ? match[1] : null;
+  }
+};
+var defaultValidator = new PathTraversalValidator();
+var validatePath = (path16, options) => defaultValidator.validate(path16, options);
+
+// src/mcp/security/validators/regex-safety-validator.ts
+var REDOS_PATTERNS = [
+  /\(\.\*\)\+/,
+  // (.*)+
+  /\(\.\+\)\+/,
+  // (.+)+
+  /\([^)]*\?\)\+/,
+  // (...?)+
+  /\([^)]*\*\)\+/,
+  // (...*)+
+  /\([^)]*\+\)\+/,
+  // (...+)+
+  /\(\[.*?\]\+\)\+/,
+  // ([...]+)+
+  /\(\[.*?\]\*\)\+/,
+  // ([...]*)+
+  /\(\[.*?\]\?\)\+/,
+  // ([...]?)+
+  /\(\[.*?\]\*\)\*/,
+  // ([...]*)*
+  /\.\*\.\*/,
+  // .*.*
+  /\.\+\.\+/,
+  // .+.+
+  /\(\.\|\.\)/
+  // (.|.)
+];
+var MAX_REGEX_COMPLEXITY = 3;
+function countQuantifierNesting(pattern) {
+  let maxDepth = 0;
+  let currentDepth = 0;
+  let inGroup = false;
+  let escaped = false;
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === "(") {
+      inGroup = true;
+      continue;
+    }
+    if (char === ")") {
+      inGroup = false;
+      const next = pattern[i + 1];
+      if (next === "*" || next === "+" || next === "?" || next === "{") {
+        currentDepth++;
+        maxDepth = Math.max(maxDepth, currentDepth);
+      }
+      continue;
+    }
+    if ((char === "*" || char === "+" || char === "?") && !inGroup) {
+      currentDepth = 1;
+      maxDepth = Math.max(maxDepth, currentDepth);
+    }
+  }
+  return maxDepth;
+}
+function hasExponentialBacktracking(pattern) {
+  const dangerous = [
+    /\(\[^\\]*\]\+\)\+/,
+    // ([...]+)+
+    /\(\[^\\]*\]\*\)\*/,
+    // ([...]*)*
+    /\([^)]+\|[^)]+\)\+/,
+    // (a|b)+
+    /\(\.\*\)[*+]/,
+    // (.*)+, (.*)*
+    /\(\.\+\)[*+]/
+    // (.+)+, (.+)*
+  ];
+  return dangerous.some((d) => d.test(pattern));
+}
+var RegexSafetyValidator = class {
+  name = "regex-safety";
+  maxComplexity;
+  constructor(maxComplexity = MAX_REGEX_COMPLEXITY) {
+    this.maxComplexity = maxComplexity;
+  }
+  /**
+   * Get the primary risk level this validator addresses
+   */
+  getRiskLevel() {
+    return "high";
+  }
+  /**
+   * Validate a regex pattern (IValidationStrategy interface)
+   */
+  validate(pattern, options = {}) {
+    const { maxLength = 1e4, maxComplexity = this.maxComplexity } = options;
+    if (pattern.length > maxLength) {
+      return {
+        valid: false,
+        error: `Pattern exceeds maximum length of ${maxLength}`,
+        riskLevel: "medium"
+      };
+    }
+    const result = this.isRegexSafe(pattern, maxComplexity);
+    return {
+      valid: result.safe,
+      error: result.error,
+      riskLevel: result.safe ? "none" : "high"
+    };
+  }
+  /**
+   * Check if a regex pattern is safe from ReDoS
+   */
+  isRegexSafe(pattern, maxComplexity = this.maxComplexity) {
+    const riskyPatterns = [];
+    for (const redosPattern of REDOS_PATTERNS) {
+      if (redosPattern.test(pattern)) {
+        riskyPatterns.push(redosPattern.source);
+      }
+    }
+    const quantifierDepth = countQuantifierNesting(pattern);
+    if (quantifierDepth > maxComplexity) {
+      riskyPatterns.push(`Quantifier nesting depth: ${quantifierDepth} (max: ${maxComplexity})`);
+    }
+    if (hasExponentialBacktracking(pattern)) {
+      riskyPatterns.push("Exponential backtracking potential detected");
+    }
+    return {
+      safe: riskyPatterns.length === 0,
+      pattern,
+      escapedPattern: this.escapeRegex(pattern),
+      riskyPatterns,
+      error: riskyPatterns.length > 0 ? "Pattern may cause ReDoS" : void 0
+    };
+  }
+  /**
+   * Escape special regex characters in a string
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Create a safe regex with validation
+   */
+  createSafeRegex(pattern, flags, maxLength = 1e4) {
+    const safety = this.isRegexSafe(pattern);
+    if (!safety.safe) {
+      return null;
+    }
+    if (pattern.length > maxLength) {
+      return null;
+    }
+    try {
+      return new RegExp(pattern, flags);
+    } catch {
+      return null;
+    }
+  }
+};
+var defaultValidator2 = new RegexSafetyValidator();
+
+// src/mcp/security/validators/crypto-validator.ts
+import { createHash, timingSafeEqual, randomBytes } from "crypto";
+var CryptoValidator = class {
+  name = "crypto-security";
+  /**
+   * Get the primary risk level this validator addresses
+   */
+  getRiskLevel() {
+    return "critical";
+  }
+  /**
+   * Perform a timing-safe string comparison
+   * Prevents timing attacks by ensuring constant-time comparison
+   */
+  timingSafeCompare(a, b) {
+    const maxLen = Math.max(a.length, b.length);
+    const paddedA = a.padEnd(maxLen, "\0");
+    const paddedB = b.padEnd(maxLen, "\0");
+    try {
+      return timingSafeEqual(Buffer.from(paddedA), Buffer.from(paddedB));
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Timing-safe comparison for hashed values
+   * Hashes the input value and compares against expected hash
+   */
+  timingSafeHashCompare(value, expectedHash) {
+    const hash = createHash("sha256").update(value).digest("hex");
+    return this.timingSafeCompare(hash, expectedHash);
+  }
+  /**
+   * Generate a secure random token
+   * Uses cryptographically secure random bytes
+   */
+  generateSecureToken(length = 32) {
+    return randomBytes(length).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+  /**
+   * Hash a value securely using SHA-256
+   */
+  secureHash(value, salt) {
+    const data = salt ? `${salt}:${value}` : value;
+    return createHash("sha256").update(data).digest("hex");
+  }
+};
+var defaultValidator3 = new CryptoValidator();
+
+// src/mcp/security/validators/input-sanitizer.ts
+var HTML_ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#x27;",
+  "/": "&#x2F;",
+  "`": "&#x60;",
+  "=": "&#x3D;"
+};
+var SQL_INJECTION_PATTERNS = [
+  /('|")\s*;\s*--/i,
+  /'\s*OR\s+'1'\s*=\s*'1/i,
+  /"\s*OR\s+"1"\s*=\s*"1/i,
+  /UNION\s+SELECT/i,
+  /INSERT\s+INTO/i,
+  /DROP\s+TABLE/i,
+  /DELETE\s+FROM/i,
+  /UPDATE\s+.*\s+SET/i,
+  /EXEC(\s+|\()sp_/i,
+  /xp_cmdshell/i
+];
+var SHELL_METACHARACTERS = /[|;&$`<>{}[\]!#*?~]/g;
+var DANGEROUS_CONTROL_CHARS = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g;
+var InputSanitizer = class {
+  name = "input-sanitization";
+  /**
+   * Get the primary risk level this sanitizer addresses
+   */
+  getRiskLevel() {
+    return "high";
+  }
+  /**
+   * Sanitize input string with configurable options
+   */
+  sanitize(input, options = {}) {
+    const {
+      maxLength = 1e4,
+      allowedChars,
+      stripHtml = true,
+      stripSql = true,
+      escapeShell = true,
+      trim = true,
+      stripControlChars = true
+    } = options;
+    let result = input;
+    if (stripControlChars) {
+      result = result.replace(DANGEROUS_CONTROL_CHARS, "");
+    }
+    if (trim) {
+      result = result.trim();
+    }
+    if (result.length > maxLength) {
+      result = result.substring(0, maxLength);
+    }
+    if (stripHtml) {
+      result = this.stripHtmlTags(result);
+    }
+    if (stripSql) {
+      for (const pattern of SQL_INJECTION_PATTERNS) {
+        result = result.replace(pattern, "");
+      }
+    }
+    if (escapeShell) {
+      result = result.replace(SHELL_METACHARACTERS, "");
+    }
+    if (allowedChars) {
+      result = result.split("").filter((char) => allowedChars.test(char)).join("");
+    }
+    return result;
+  }
+  /**
+   * Escape HTML special characters
+   */
+  escapeHtml(str) {
+    return str.replace(/[&<>"'`=/]/g, (char) => HTML_ESCAPE_MAP[char] || char);
+  }
+  /**
+   * Strip HTML tags from a string
+   * Handles both complete tags and incomplete/malformed tags to prevent XSS
+   */
+  stripHtmlTags(str) {
+    const MAX_LENGTH = 1e5;
+    if (str.length > MAX_LENGTH) {
+      str = str.slice(0, MAX_LENGTH);
+    }
+    let result = str;
+    let prevLength;
+    do {
+      prevLength = result.length;
+      let cleaned = "";
+      let inTag = false;
+      for (let i = 0; i < result.length; i++) {
+        const char = result[i];
+        if (char === "<") {
+          inTag = true;
+        } else if (char === ">" && inTag) {
+          inTag = false;
+        } else if (!inTag) {
+          cleaned += char;
+        }
+      }
+      result = cleaned;
+    } while (result.length < prevLength && result.length > 0);
+    result = result.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    return result;
+  }
+};
+var defaultSanitizer = new InputSanitizer();
+var sanitizeInput = (input, options) => defaultSanitizer.sanitize(input, options);
+
+// src/mcp/security/validators/command-validator.ts
+var DEFAULT_ALLOWED_COMMANDS = [
+  "ls",
+  "cat",
+  "echo",
+  "grep",
+  "find",
+  "head",
+  "tail",
+  "wc",
+  "npm",
+  "node",
+  "yarn",
+  "pnpm",
+  "git",
+  "jest",
+  "vitest",
+  "playwright"
+];
+var BLOCKED_COMMAND_PATTERNS = [
+  /;/,
+  // Command chaining with semicolon
+  /&&/,
+  // Command chaining with AND
+  /\|\|/,
+  // Command chaining with OR
+  /\|/,
+  // Piping
+  /`.*`/,
+  // Backtick command substitution
+  /\$\(.*\)/,
+  // $() command substitution
+  />\s*\/dev\/sd/i,
+  // Writing to block devices
+  />\s*\/etc\//i
+  // Writing to /etc
+];
+var SHELL_METACHARACTERS2 = /[|;&$`<>{}[\]!#*?~]/g;
+var CommandValidator = class {
+  name = "command-injection";
+  defaultAllowedCommands;
+  constructor(defaultAllowedCommands = DEFAULT_ALLOWED_COMMANDS) {
+    this.defaultAllowedCommands = defaultAllowedCommands;
+  }
+  /**
+   * Get the primary risk level this validator addresses
+   */
+  getRiskLevel() {
+    return "critical";
+  }
+  /**
+   * Validate a command (IValidationStrategy interface)
+   */
+  validate(command, options = {}) {
+    const allowedCommands = options.allowedCommands ?? this.defaultAllowedCommands;
+    return this.validateCommand(command, allowedCommands);
+  }
+  /**
+   * Validate and sanitize a command
+   */
+  validateCommand(command, allowedCommands = this.defaultAllowedCommands) {
+    const blockedPatterns = [];
+    for (const pattern of BLOCKED_COMMAND_PATTERNS) {
+      if (pattern.test(command)) {
+        blockedPatterns.push(pattern.source);
+      }
+    }
+    if (blockedPatterns.length > 0) {
+      return {
+        valid: false,
+        error: "Command contains blocked patterns",
+        blockedPatterns,
+        riskLevel: "critical"
+      };
+    }
+    const parts = command.trim().split(/\s+/);
+    const baseCommand = parts[0].split("/").pop() || "";
+    if (!allowedCommands.includes(baseCommand)) {
+      return {
+        valid: false,
+        error: `Command '${baseCommand}' is not in the allowed list`,
+        blockedPatterns: [],
+        riskLevel: "high"
+      };
+    }
+    const sanitizedParts = parts.map((part, i) => {
+      if (i === 0) return part;
+      return part.replace(SHELL_METACHARACTERS2, "");
+    });
+    return {
+      valid: true,
+      sanitizedCommand: sanitizedParts.join(" "),
+      blockedPatterns: [],
+      riskLevel: "none"
+    };
+  }
+  /**
+   * Escape a string for safe shell usage
+   */
+  escapeShellArg(arg) {
+    return `'${arg.replace(/'/g, "'\\''")}'`;
+  }
+};
+var defaultValidator4 = new CommandValidator();
+var validateCommand = (command, allowedCommands) => {
+  if (allowedCommands) {
+    return defaultValidator4.validateCommand(command, allowedCommands);
+  }
+  return defaultValidator4.validate(command);
+};
+
 // src/mcp/tool-registry.ts
+var VALID_TOOL_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_:-]{0,127}$/;
+var MAX_PARAM_STRING_LENGTH = 1e6;
+function validateToolName(name) {
+  if (typeof name !== "string") {
+    return { valid: false, error: "Tool name must be a string" };
+  }
+  if (name.length === 0) {
+    return { valid: false, error: "Tool name cannot be empty" };
+  }
+  if (name.length > 128) {
+    return { valid: false, error: "Tool name exceeds maximum length (128)" };
+  }
+  if (!VALID_TOOL_NAME_PATTERN.test(name)) {
+    return {
+      valid: false,
+      error: "Tool name contains invalid characters. Use only alphanumeric, underscore, hyphen, or colon"
+    };
+  }
+  return { valid: true };
+}
+function validateParamValue(value, param) {
+  if (value === void 0 || value === null) {
+    if (param.required) {
+      return { valid: false, error: `Required parameter '${param.name}' is missing` };
+    }
+    return { valid: true };
+  }
+  switch (param.type) {
+    case "string":
+      if (typeof value !== "string") {
+        return { valid: false, error: `Parameter '${param.name}' must be a string` };
+      }
+      if (value.length > MAX_PARAM_STRING_LENGTH) {
+        return { valid: false, error: `Parameter '${param.name}' exceeds maximum length` };
+      }
+      break;
+    case "number":
+      if (typeof value !== "number" || isNaN(value)) {
+        return { valid: false, error: `Parameter '${param.name}' must be a number` };
+      }
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return { valid: false, error: `Parameter '${param.name}' must be a boolean` };
+      }
+      break;
+    case "object":
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return { valid: false, error: `Parameter '${param.name}' must be an object` };
+      }
+      break;
+    case "array":
+      if (!Array.isArray(value)) {
+        return { valid: false, error: `Parameter '${param.name}' must be an array` };
+      }
+      break;
+  }
+  if (param.enum && param.enum.length > 0) {
+    if (!param.enum.includes(value)) {
+      return {
+        valid: false,
+        error: `Parameter '${param.name}' must be one of: ${param.enum.join(", ")}`
+      };
+    }
+  }
+  return { valid: true };
+}
+function validateParams(params, definition) {
+  const errors = [];
+  const knownParams = new Set(definition.parameters.map((p) => p.name));
+  for (const key of Object.keys(params)) {
+    if (!knownParams.has(key)) {
+      errors.push(`Unknown parameter: '${key}'`);
+    }
+  }
+  for (const param of definition.parameters) {
+    const result = validateParamValue(params[param.name], param);
+    if (!result.valid && result.error) {
+      errors.push(result.error);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function sanitizeParams(params) {
+  const sanitized = { ...params };
+  for (const [key, value] of Object.entries(sanitized)) {
+    if (typeof value === "string") {
+      sanitized[key] = sanitizeInput(value);
+    } else if (Array.isArray(value)) {
+      sanitized[key] = value.map(
+        (item) => typeof item === "string" ? sanitizeInput(item) : item
+      );
+    } else if (typeof value === "object" && value !== null) {
+      sanitized[key] = sanitizeParams(value);
+    }
+  }
+  return sanitized;
+}
 var DOMAIN_KEYWORDS = {
   "test-generation": [
     "test",
@@ -11137,11 +12039,20 @@ var ToolRegistry = class {
     return Array.from(names).map((name) => this.tools.get(name)?.definition).filter((d) => d !== void 0);
   }
   /**
-   * Invoke a tool
+   * Invoke a tool with input validation and sanitization (SEC-001 fix)
    */
   async invoke(name, params) {
     const startTime = Date.now();
     const requestId = uuidv4();
+    const nameValidation = validateToolName(name);
+    if (!nameValidation.valid) {
+      this.stats.errors++;
+      return {
+        success: false,
+        error: `Invalid tool name: ${nameValidation.error}`,
+        metadata: this.createMetadata(startTime, requestId)
+      };
+    }
     const tool = this.tools.get(name);
     if (!tool) {
       this.stats.errors++;
@@ -11151,6 +12062,16 @@ var ToolRegistry = class {
         metadata: this.createMetadata(startTime, requestId)
       };
     }
+    const paramValidation = validateParams(params, tool.definition);
+    if (!paramValidation.valid) {
+      this.stats.errors++;
+      return {
+        success: false,
+        error: `Parameter validation failed: ${paramValidation.errors.join("; ")}`,
+        metadata: this.createMetadata(startTime, requestId, tool.definition.domain)
+      };
+    }
+    const sanitizedParams = sanitizeParams(params);
     if (!tool.loaded) {
       tool.loaded = true;
       this.stats.loadedTools++;
@@ -11159,7 +12080,7 @@ var ToolRegistry = class {
     tool.lastUsed = /* @__PURE__ */ new Date();
     this.stats.invocations++;
     try {
-      const result = await tool.handler(params);
+      const result = await tool.handler(sanitizedParams);
       return {
         ...result,
         metadata: {
@@ -11971,8 +12892,10 @@ var BaseDomainPlugin = class {
     this.memory = memory;
   }
   _initialized = false;
+  // Issue #205 fix: Default to 'idle' status for fresh installs (0 agents)
+  // Domains transition to 'healthy' when they have active agents
   _health = {
-    status: "healthy",
+    status: "idle",
     agents: { total: 0, active: 0, idle: 0, failed: 0 },
     errors: []
   };
@@ -12094,403 +13017,207 @@ import { v4 as uuidv44 } from "uuid";
 import * as fs2 from "fs";
 import * as path2 from "path";
 import * as ts from "typescript";
+
+// src/domains/test-generation/generators/base-test-generator.ts
 import { faker } from "@faker-js/faker";
-var DEFAULT_CONFIG = {
-  defaultFramework: "jest",
-  maxTestsPerFile: 50,
-  coverageTargetDefault: 80,
-  enableAIGeneration: true
-};
-var TestGeneratorService = class {
-  constructor(memory, config = {}) {
-    this.memory = memory;
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-  config;
-  /**
-   * Generate tests for given source files
-   */
-  async generateTests(request) {
-    try {
-      const {
-        sourceFiles,
-        testType,
-        framework,
-        coverageTarget = this.config.coverageTargetDefault,
-        patterns = []
-      } = request;
-      if (sourceFiles.length === 0) {
-        return err(new Error("No source files provided"));
-      }
-      const tests = [];
-      const patternsUsed = [];
-      for (const sourceFile of sourceFiles) {
-        const fileTests = await this.generateTestsForFile(
-          sourceFile,
-          testType,
-          framework,
-          patterns
-        );
-        if (fileTests.success) {
-          tests.push(...fileTests.value.tests);
-          patternsUsed.push(...fileTests.value.patternsUsed);
-        }
-      }
-      const coverageEstimate = this.estimateCoverage(tests, coverageTarget);
-      await this.storeGenerationMetadata(tests, patternsUsed);
-      return ok({
-        tests,
-        coverageEstimate,
-        patternsUsed: [...new Set(patternsUsed)]
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
+var BaseTestGenerator = class {
+  // ============================================================================
+  // Shared Utilities - Available to all subclasses
+  // ============================================================================
   /**
-   * Generate tests specifically targeting coverage gaps
+   * Generate a test value for a parameter based on its type and name
+   * Uses @faker-js/faker for realistic test data
+   *
+   * @param param - Parameter information
+   * @returns Generated test value as a string
    */
-  async generateForCoverageGap(file, uncoveredLines, framework) {
-    try {
-      if (uncoveredLines.length === 0) {
-        return ok([]);
-      }
-      const tests = [];
-      const lineGroups = this.groupConsecutiveLines(uncoveredLines);
-      for (const group of lineGroups) {
-        const test = await this.generateTestForLines(file, group, framework);
-        if (test) {
-          tests.push(test);
-        }
-      }
-      return ok(tests);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
+  generateTestValue(param) {
+    if (param.defaultValue) {
+      return param.defaultValue;
     }
+    const type = param.type?.toLowerCase() || "unknown";
+    const name = param.name.toLowerCase();
+    if (name.includes("id")) return `'${faker.string.uuid()}'`;
+    if (name.includes("email")) return `'${faker.internet.email()}'`;
+    if (name.includes("name")) return `'${faker.person.fullName()}'`;
+    if (name.includes("url")) return `'${faker.internet.url()}'`;
+    if (name.includes("date")) return `new Date('${faker.date.recent().toISOString()}')`;
+    if (name.includes("phone")) return `'${faker.phone.number()}'`;
+    if (name.includes("address")) return `'${faker.location.streetAddress()}'`;
+    if (type.includes("string")) return `'${faker.lorem.word()}'`;
+    if (type.includes("number")) return String(faker.number.int({ min: 1, max: 100 }));
+    if (type.includes("boolean")) return "true";
+    if (type.includes("[]") || type.includes("array")) return "[]";
+    if (type.includes("object") || type.includes("{")) return "{}";
+    if (type.includes("function")) return "() => {}";
+    if (type.includes("promise")) return "Promise.resolve()";
+    if (type.includes("date")) return "new Date()";
+    return `mock${param.name.charAt(0).toUpperCase() + param.name.slice(1)}`;
   }
   /**
-   * Generate tests following TDD workflow
+   * Generate test cases for a function based on its signature
+   * Creates happy-path, edge-case, error-handling, and boundary tests
+   *
+   * @param fn - Function information from AST
+   * @returns Array of test cases
    */
-  async generateTDDTests(request) {
-    try {
-      const { feature, behavior, framework, phase } = request;
-      switch (phase) {
-        case "red":
-          return ok(await this.generateRedPhaseTest(feature, behavior, framework));
-        case "green":
-          return ok(await this.generateGreenPhaseCode(feature, behavior, framework));
-        case "refactor":
-          return ok(await this.generateRefactoringSuggestions(feature, behavior));
-        default:
-          return err(new Error(`Unknown TDD phase: ${phase}`));
+  generateTestCasesForFunction(fn) {
+    const testCases = [];
+    const validParams = fn.parameters.map((p) => this.generateTestValue(p)).join(", ");
+    const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
+    testCases.push({
+      description: "should handle valid input correctly",
+      type: "happy-path",
+      action: `const result = ${fnCall};`,
+      assertion: "expect(result).toBeDefined();"
+    });
+    for (const param of fn.parameters) {
+      if (!param.optional) {
+        const paramsWithUndefined = fn.parameters.map((p) => p.name === param.name ? "undefined" : this.generateTestValue(p)).join(", ");
+        testCases.push({
+          description: `should handle undefined ${param.name}`,
+          type: "error-handling",
+          action: fn.isAsync ? `const action = async () => await ${fn.name}(${paramsWithUndefined});` : `const action = () => ${fn.name}(${paramsWithUndefined});`,
+          assertion: "expect(action).toThrow();"
+        });
       }
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
+      testCases.push(...this.generateBoundaryTestCases(fn, param));
     }
-  }
-  /**
-   * Generate property-based tests
-   */
-  async generatePropertyTests(request) {
-    try {
-      const { function: funcName, properties, constraints = {} } = request;
-      const tests = properties.map((property) => ({
-        property,
-        testCode: this.generatePropertyTestCode(funcName, property, constraints),
-        generators: this.inferGenerators(property, constraints)
-      }));
-      return ok({
-        tests,
-        arbitraries: this.collectArbitraries(tests)
+    if (fn.isAsync) {
+      testCases.push({
+        description: "should handle async rejection gracefully",
+        type: "error-handling",
+        action: `// Mock or setup to cause rejection`,
+        assertion: `// await expect(${fn.name}(invalidParams)).rejects.toThrow();`
       });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
     }
+    return testCases;
   }
   /**
-   * Generate test data based on schema
+   * Generate boundary test cases for a parameter based on its type
    */
-  async generateTestData(request) {
-    try {
-      const { schema, count, locale = "en", preserveRelationships = false } = request;
-      const seed = Date.now();
-      const records = [];
-      for (let i = 0; i < count; i++) {
-        const record = this.generateRecordFromSchema(schema, seed + i, locale);
-        records.push(record);
-      }
-      if (preserveRelationships) {
-        this.linkRelatedRecords(records, schema);
-      }
-      return ok({
-        records,
-        schema,
-        seed
+  generateBoundaryTestCases(fn, param) {
+    const testCases = [];
+    const type = param.type?.toLowerCase() || "";
+    if (type.includes("string")) {
+      const paramsWithEmpty = fn.parameters.map((p) => p.name === param.name ? "''" : this.generateTestValue(p)).join(", ");
+      const emptyCall = fn.isAsync ? `await ${fn.name}(${paramsWithEmpty})` : `${fn.name}(${paramsWithEmpty})`;
+      testCases.push({
+        description: `should handle empty string for ${param.name}`,
+        type: "boundary",
+        action: `const result = ${emptyCall};`,
+        assertion: "expect(result).toBeDefined();"
       });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
     }
-  }
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-  async generateTestsForFile(sourceFile, testType, framework, patterns) {
-    const testFile = this.getTestFilePath(sourceFile, framework);
-    const patternsUsed = [];
-    const applicablePatterns = await this.findApplicablePatterns(sourceFile, patterns);
-    patternsUsed.push(...applicablePatterns.map((p) => p.name));
-    let codeAnalysis = null;
-    try {
-      const content = fs2.readFileSync(sourceFile, "utf-8");
-      codeAnalysis = this.analyzeSourceCode(content, sourceFile);
-    } catch {
+    if (type.includes("number")) {
+      const paramsWithZero = fn.parameters.map((p) => p.name === param.name ? "0" : this.generateTestValue(p)).join(", ");
+      const zeroCall = fn.isAsync ? `await ${fn.name}(${paramsWithZero})` : `${fn.name}(${paramsWithZero})`;
+      testCases.push({
+        description: `should handle zero for ${param.name}`,
+        type: "boundary",
+        action: `const result = ${zeroCall};`,
+        assertion: "expect(result).toBeDefined();"
+      });
+      const paramsWithNegative = fn.parameters.map((p) => p.name === param.name ? "-1" : this.generateTestValue(p)).join(", ");
+      const negativeCall = fn.isAsync ? `await ${fn.name}(${paramsWithNegative})` : `${fn.name}(${paramsWithNegative})`;
+      testCases.push({
+        description: `should handle negative value for ${param.name}`,
+        type: "edge-case",
+        action: `const result = ${negativeCall};`,
+        assertion: "expect(result).toBeDefined();"
+      });
     }
-    let testCode;
-    if (codeAnalysis && (codeAnalysis.functions.length > 0 || codeAnalysis.classes.length > 0)) {
-      testCode = this.generateRealTestCode(
-        sourceFile,
-        testType,
-        framework,
-        codeAnalysis,
-        applicablePatterns
-      );
-    } else {
-      testCode = this.generateStubTestCode(sourceFile, testType, framework, applicablePatterns);
+    if (type.includes("[]") || type.includes("array")) {
+      const paramsWithEmpty = fn.parameters.map((p) => p.name === param.name ? "[]" : this.generateTestValue(p)).join(", ");
+      const emptyCall = fn.isAsync ? `await ${fn.name}(${paramsWithEmpty})` : `${fn.name}(${paramsWithEmpty})`;
+      testCases.push({
+        description: `should handle empty array for ${param.name}`,
+        type: "boundary",
+        action: `const result = ${emptyCall};`,
+        assertion: "expect(result).toBeDefined();"
+      });
     }
-    const test = {
-      id: uuidv44(),
-      name: `${this.extractModuleName(sourceFile)} tests`,
-      sourceFile,
-      testFile,
-      testCode,
-      type: testType,
-      assertions: this.countAssertions(testCode)
-    };
-    return ok({ tests: [test], patternsUsed });
+    return testCases;
   }
   /**
-   * Analyze source code using TypeScript AST
+   * Extract exports from code analysis for import statements
    */
-  analyzeSourceCode(content, fileName) {
-    const sourceFile = ts.createSourceFile(
-      path2.basename(fileName),
-      content,
-      ts.ScriptTarget.Latest,
-      true,
-      ts.ScriptKind.TS
-    );
-    const functions = [];
-    const classes = [];
-    const visit = (node) => {
-      if (ts.isFunctionDeclaration(node) && node.name) {
-        functions.push(this.extractFunctionInfo(node, sourceFile));
-      } else if (ts.isVariableStatement(node)) {
-        for (const declaration of node.declarationList.declarations) {
-          if (ts.isVariableDeclaration(declaration) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) {
-            const name = declaration.name.getText(sourceFile);
-            functions.push(
-              this.extractArrowFunctionInfo(name, declaration.initializer, sourceFile, node)
-            );
-          }
-        }
-      } else if (ts.isClassDeclaration(node) && node.name) {
-        classes.push(this.extractClassInfo(node, sourceFile));
-      }
-      ts.forEachChild(node, visit);
-    };
-    ts.forEachChild(sourceFile, visit);
-    return { functions, classes };
+  extractExports(functions, classes) {
+    const exports = [];
+    for (const fn of functions) {
+      if (fn.isExported) exports.push(fn.name);
+    }
+    for (const cls of classes) {
+      if (cls.isExported) exports.push(cls.name);
+    }
+    return exports;
   }
   /**
-   * Extract function information from AST
+   * Generate import statement based on exports
    */
-  extractFunctionInfo(node, sourceFile) {
-    const name = node.name?.getText(sourceFile) || "anonymous";
-    const parameters = this.extractParameters(node.parameters, sourceFile);
-    const returnType = node.type?.getText(sourceFile);
-    const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-    const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
-    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-    return {
-      name,
-      parameters,
-      returnType,
-      isAsync,
-      isExported,
-      complexity: this.calculateComplexity(node),
-      startLine: startLine + 1,
-      endLine: endLine + 1,
-      body: node.body?.getText(sourceFile)
-    };
+  generateImportStatement(exports, importPath, moduleName) {
+    if (exports.length > 0) {
+      return `import { ${exports.join(", ")} } from '${importPath}';`;
+    }
+    return `import * as ${moduleName} from '${importPath}';`;
   }
   /**
-   * Extract arrow function information from AST
+   * Generate pattern comment header
    */
-  extractArrowFunctionInfo(name, node, sourceFile, parentNode) {
-    const parameters = this.extractParameters(node.parameters, sourceFile);
-    const returnType = node.type?.getText(sourceFile);
-    const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-    const isExported = ts.isVariableStatement(parentNode) && (parentNode.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
-    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-    return {
-      name,
-      parameters,
-      returnType,
-      isAsync,
-      isExported,
-      complexity: this.calculateComplexity(node),
-      startLine: startLine + 1,
-      endLine: endLine + 1,
-      body: node.body?.getText(sourceFile)
-    };
+  generatePatternComment(patterns) {
+    if (patterns.length === 0) return "";
+    return `// Applied patterns: ${patterns.map((p) => p.name).join(", ")}
+`;
   }
   /**
-   * Extract class information from AST
+   * Convert string to camelCase
    */
-  extractClassInfo(node, sourceFile) {
-    const name = node.name?.getText(sourceFile) || "AnonymousClass";
-    const methods = [];
-    const properties = [];
-    let hasConstructor = false;
-    let constructorParams;
-    const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
-    for (const member of node.members) {
-      if (ts.isMethodDeclaration(member)) {
-        const methodName = member.name.getText(sourceFile);
-        const parameters = this.extractParameters(member.parameters, sourceFile);
-        const returnType = member.type?.getText(sourceFile);
-        const isAsync = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-        const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(
-          member.getStart(sourceFile)
-        );
-        const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(member.getEnd());
-        methods.push({
-          name: methodName,
-          parameters,
-          returnType,
-          isAsync,
-          isExported: false,
-          complexity: this.calculateComplexity(member),
-          startLine: startLine + 1,
-          endLine: endLine + 1,
-          body: member.body?.getText(sourceFile)
-        });
-      } else if (ts.isConstructorDeclaration(member)) {
-        hasConstructor = true;
-        constructorParams = this.extractParameters(member.parameters, sourceFile);
-      } else if (ts.isPropertyDeclaration(member)) {
-        const propName = member.name.getText(sourceFile);
-        const propType = member.type?.getText(sourceFile);
-        const isPrivate = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword) ?? false;
-        const isReadonly = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
-        properties.push({
-          name: propName,
-          type: propType,
-          isPrivate,
-          isReadonly
-        });
-      }
-    }
-    return {
-      name,
-      methods,
-      properties,
-      isExported,
-      hasConstructor,
-      constructorParams
-    };
+  camelCase(str) {
+    return str.replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase()).replace(/^./, (chr) => chr.toLowerCase());
   }
   /**
-   * Extract parameters from a function
+   * Convert string to PascalCase
    */
-  extractParameters(params, sourceFile) {
-    return params.map((param) => ({
-      name: param.name.getText(sourceFile),
-      type: param.type?.getText(sourceFile),
-      optional: param.questionToken !== void 0,
-      defaultValue: param.initializer?.getText(sourceFile)
-    }));
+  pascalCase(str) {
+    return str.replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase()).replace(/^./, (chr) => chr.toUpperCase());
   }
   /**
-   * Calculate cyclomatic complexity of a node
+   * Format line range for display
    */
-  calculateComplexity(node) {
-    let complexity = 1;
-    const visit = (n) => {
-      switch (n.kind) {
-        case ts.SyntaxKind.IfStatement:
-        case ts.SyntaxKind.ForStatement:
-        case ts.SyntaxKind.ForInStatement:
-        case ts.SyntaxKind.ForOfStatement:
-        case ts.SyntaxKind.WhileStatement:
-        case ts.SyntaxKind.DoStatement:
-        case ts.SyntaxKind.CaseClause:
-        case ts.SyntaxKind.CatchClause:
-        case ts.SyntaxKind.ConditionalExpression:
-          complexity++;
-          break;
-        case ts.SyntaxKind.BinaryExpression: {
-          const binary = n;
-          if (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || binary.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-            complexity++;
-          }
-          break;
-        }
-      }
-      ts.forEachChild(n, visit);
-    };
-    ts.forEachChild(node, visit);
-    return complexity;
+  formatLineRange(lines) {
+    if (lines.length === 1) {
+      return `line ${lines[0]}`;
+    }
+    return `lines ${lines[0]}-${lines[lines.length - 1]}`;
+  }
+};
+
+// src/domains/test-generation/generators/jest-vitest-generator.ts
+var JestVitestGenerator = class extends BaseTestGenerator {
+  framework;
+  constructor(framework = "vitest") {
+    super();
+    this.framework = framework;
   }
   /**
-   * Generate real test code based on AST analysis
+   * Get the mock utility name (vi for vitest, jest for jest)
    */
-  generateRealTestCode(sourceFile, testType, framework, analysis, patterns) {
-    const moduleName = this.extractModuleName(sourceFile);
-    const importPath = this.getImportPath(sourceFile);
-    switch (framework) {
-      case "jest":
-      case "vitest":
-        return this.generateRealJestVitestTest(
-          moduleName,
-          importPath,
-          testType,
-          analysis,
-          patterns,
-          framework
-        );
-      case "mocha":
-        return this.generateRealMochaTest(moduleName, importPath, testType, analysis, patterns);
-      case "pytest":
-        return this.generateRealPytestTest(moduleName, importPath, testType, analysis, patterns);
-      default:
-        return this.generateRealJestVitestTest(
-          moduleName,
-          importPath,
-          testType,
-          analysis,
-          patterns,
-          "vitest"
-        );
-    }
+  get mockUtil() {
+    return this.framework === "vitest" ? "vi" : "jest";
   }
   /**
-   * Generate real Jest/Vitest test code
+   * Generate complete test file from analysis
    */
-  generateRealJestVitestTest(moduleName, importPath, testType, analysis, patterns, framework) {
-    const patternComment = patterns.length > 0 ? `// Applied patterns: ${patterns.map((p) => p.name).join(", ")}
-` : "";
-    const exports = [];
-    for (const fn of analysis.functions) {
-      if (fn.isExported) exports.push(fn.name);
-    }
-    for (const cls of analysis.classes) {
-      if (cls.isExported) exports.push(cls.name);
+  generateTests(context) {
+    const { moduleName, importPath, testType, patterns, analysis } = context;
+    if (!analysis || analysis.functions.length === 0 && analysis.classes.length === 0) {
+      return this.generateStubTests(context);
     }
-    const importStatement = exports.length > 0 ? `import { ${exports.join(", ")} } from '${importPath}';` : `import * as ${moduleName} from '${importPath}';`;
-    let testCode = `${patternComment}import { describe, it, expect, beforeEach${framework === "vitest" ? ", vi" : ""} } from '${framework}';
+    const patternComment = this.generatePatternComment(patterns);
+    const exports = this.extractExports(analysis.functions, analysis.classes);
+    const importStatement = this.generateImportStatement(exports, importPath, moduleName);
+    const mockImport = this.framework === "vitest" ? ", vi" : "";
+    let testCode = `${patternComment}import { describe, it, expect, beforeEach${mockImport} } from '${this.framework}';
 ${importStatement}
 
 `;
@@ -12503,7 +13230,7 @@ ${importStatement}
     return testCode;
   }
   /**
-   * Generate tests for a function
+   * Generate tests for a standalone function
    */
   generateFunctionTests(fn, _testType) {
     const testCases = this.generateTestCasesForFunction(fn);
@@ -12531,78 +13258,6 @@ ${importStatement}
 `;
     return code;
   }
-  /**
-   * Generate test cases for a function
-   */
-  generateTestCasesForFunction(fn) {
-    const testCases = [];
-    const validParams = fn.parameters.map((p) => this.generateTestValue(p)).join(", ");
-    const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
-    testCases.push({
-      description: "should handle valid input correctly",
-      type: "happy-path",
-      action: `const result = ${fnCall};`,
-      assertion: "expect(result).toBeDefined();"
-    });
-    for (const param of fn.parameters) {
-      if (!param.optional) {
-        const paramsWithUndefined = fn.parameters.map((p) => p.name === param.name ? "undefined" : this.generateTestValue(p)).join(", ");
-        testCases.push({
-          description: `should handle undefined ${param.name}`,
-          type: "error-handling",
-          action: fn.isAsync ? `const action = async () => await ${fn.name}(${paramsWithUndefined});` : `const action = () => ${fn.name}(${paramsWithUndefined});`,
-          assertion: "expect(action).toThrow();"
-        });
-      }
-      if (param.type?.includes("string")) {
-        const paramsWithEmpty = fn.parameters.map((p) => p.name === param.name ? "''" : this.generateTestValue(p)).join(", ");
-        const emptyCall = fn.isAsync ? `await ${fn.name}(${paramsWithEmpty})` : `${fn.name}(${paramsWithEmpty})`;
-        testCases.push({
-          description: `should handle empty string for ${param.name}`,
-          type: "boundary",
-          action: `const result = ${emptyCall};`,
-          assertion: "expect(result).toBeDefined();"
-        });
-      }
-      if (param.type?.includes("number")) {
-        const paramsWithZero = fn.parameters.map((p) => p.name === param.name ? "0" : this.generateTestValue(p)).join(", ");
-        const zeroCall = fn.isAsync ? `await ${fn.name}(${paramsWithZero})` : `${fn.name}(${paramsWithZero})`;
-        testCases.push({
-          description: `should handle zero for ${param.name}`,
-          type: "boundary",
-          action: `const result = ${zeroCall};`,
-          assertion: "expect(result).toBeDefined();"
-        });
-        const paramsWithNegative = fn.parameters.map((p) => p.name === param.name ? "-1" : this.generateTestValue(p)).join(", ");
-        const negativeCall = fn.isAsync ? `await ${fn.name}(${paramsWithNegative})` : `${fn.name}(${paramsWithNegative})`;
-        testCases.push({
-          description: `should handle negative value for ${param.name}`,
-          type: "edge-case",
-          action: `const result = ${negativeCall};`,
-          assertion: "expect(result).toBeDefined();"
-        });
-      }
-      if (param.type?.includes("[]") || param.type?.includes("Array")) {
-        const paramsWithEmpty = fn.parameters.map((p) => p.name === param.name ? "[]" : this.generateTestValue(p)).join(", ");
-        const emptyCall = fn.isAsync ? `await ${fn.name}(${paramsWithEmpty})` : `${fn.name}(${paramsWithEmpty})`;
-        testCases.push({
-          description: `should handle empty array for ${param.name}`,
-          type: "boundary",
-          action: `const result = ${emptyCall};`,
-          assertion: "expect(result).toBeDefined();"
-        });
-      }
-    }
-    if (fn.isAsync) {
-      testCases.push({
-        description: "should handle async rejection gracefully",
-        type: "error-handling",
-        action: `// Mock or setup to cause rejection`,
-        assertion: `// await expect(${fn.name}(invalidParams)).rejects.toThrow();`
-      });
-    }
-    return testCases;
-  }
   /**
    * Generate tests for a class
    */
@@ -12682,259 +13337,11 @@ ${importStatement}
     return code;
   }
   /**
-   * Generate a test value for a parameter
-   */
-  generateTestValue(param) {
-    if (param.defaultValue) {
-      return param.defaultValue;
-    }
-    const type = param.type?.toLowerCase() || "unknown";
-    const name = param.name.toLowerCase();
-    if (name.includes("id")) return `'${faker.string.uuid()}'`;
-    if (name.includes("email")) return `'${faker.internet.email()}'`;
-    if (name.includes("name")) return `'${faker.person.fullName()}'`;
-    if (name.includes("url")) return `'${faker.internet.url()}'`;
-    if (name.includes("date")) return `new Date('${faker.date.recent().toISOString()}')`;
-    if (type.includes("string")) return `'${faker.lorem.word()}'`;
-    if (type.includes("number")) return String(faker.number.int({ min: 1, max: 100 }));
-    if (type.includes("boolean")) return "true";
-    if (type.includes("[]") || type.includes("array")) return "[]";
-    if (type.includes("object") || type.includes("{")) return "{}";
-    if (type.includes("function")) return "() => {}";
-    if (type.includes("promise")) return "Promise.resolve()";
-    if (type.includes("date")) return "new Date()";
-    return `mock${param.name.charAt(0).toUpperCase() + param.name.slice(1)}`;
-  }
-  /**
-   * Generate real Mocha test code
-   */
-  generateRealMochaTest(moduleName, importPath, testType, analysis, patterns) {
-    const patternComment = patterns.length > 0 ? `// Applied patterns: ${patterns.map((p) => p.name).join(", ")}
-` : "";
-    const exports = [];
-    for (const fn of analysis.functions) {
-      if (fn.isExported) exports.push(fn.name);
-    }
-    for (const cls of analysis.classes) {
-      if (cls.isExported) exports.push(cls.name);
-    }
-    const importStatement = exports.length > 0 ? `import { ${exports.join(", ")} } from '${importPath}';` : `import * as ${moduleName} from '${importPath}';`;
-    let code = `${patternComment}import { expect } from 'chai';
-${importStatement}
-
-describe('${moduleName} - ${testType} tests', function() {
-`;
-    for (const fn of analysis.functions) {
-      code += this.generateMochaFunctionTests(fn);
-    }
-    for (const cls of analysis.classes) {
-      code += this.generateMochaClassTests(cls);
-    }
-    code += `});
-`;
-    return code;
-  }
-  /**
-   * Generate Mocha tests for a function
-   */
-  generateMochaFunctionTests(fn) {
-    const validParams = fn.parameters.map((p) => this.generateTestValue(p)).join(", ");
-    const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
-    let code = `  describe('${fn.name}', function() {
-`;
-    code += `    it('should handle valid input', ${fn.isAsync ? "async " : ""}function() {
-`;
-    code += `      const result = ${fnCall};
-`;
-    code += `      expect(result).to.not.be.undefined;
-`;
-    code += `    });
-`;
-    code += `  });
-
-`;
-    return code;
-  }
-  /**
-   * Generate Mocha tests for a class
-   */
-  generateMochaClassTests(cls) {
-    const constructorArgs = cls.constructorParams?.map((p) => this.generateTestValue(p)).join(", ") || "";
-    let code = `  describe('${cls.name}', function() {
-`;
-    code += `    let instance;
-
-`;
-    code += `    beforeEach(function() {
-`;
-    code += `      instance = new ${cls.name}(${constructorArgs});
-`;
-    code += `    });
-
-`;
-    code += `    it('should instantiate correctly', function() {
-`;
-    code += `      expect(instance).to.be.instanceOf(${cls.name});
-`;
-    code += `    });
-`;
-    for (const method of cls.methods) {
-      if (!method.name.startsWith("_")) {
-        const methodParams = method.parameters.map((p) => this.generateTestValue(p)).join(", ");
-        code += `
-    it('${method.name} should work', ${method.isAsync ? "async " : ""}function() {
-`;
-        code += `      const result = ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
-`;
-        code += `      expect(result).to.not.be.undefined;
-`;
-        code += `    });
-`;
-      }
-    }
-    code += `  });
-
-`;
-    return code;
-  }
-  /**
-   * Generate real Pytest test code
-   */
-  generateRealPytestTest(moduleName, importPath, testType, analysis, patterns) {
-    const patternComment = patterns.length > 0 ? `# Applied patterns: ${patterns.map((p) => p.name).join(", ")}
-` : "";
-    const exports = [];
-    for (const fn of analysis.functions) {
-      if (fn.isExported) exports.push(fn.name);
-    }
-    for (const cls of analysis.classes) {
-      if (cls.isExported) exports.push(cls.name);
-    }
-    const pythonImport = importPath.replace(/\//g, ".").replace(/\.(ts|js)$/, "");
-    const importStatement = exports.length > 0 ? `from ${pythonImport} import ${exports.join(", ")}` : `import ${pythonImport} as ${moduleName}`;
-    let code = `${patternComment}import pytest
-${importStatement}
-
-
-class Test${moduleName.charAt(0).toUpperCase() + moduleName.slice(1)}:
-    """${testType} tests for ${moduleName}"""
-
-`;
-    for (const fn of analysis.functions) {
-      code += this.generatePytestFunctionTests(fn);
-    }
-    for (const cls of analysis.classes) {
-      code += this.generatePytestClassTests(cls);
-    }
-    return code;
-  }
-  /**
-   * Generate Pytest tests for a function
-   */
-  generatePytestFunctionTests(fn) {
-    const validParams = fn.parameters.map((p) => this.generatePythonTestValue(p)).join(", ");
-    let code = `    def test_${fn.name}_valid_input(self):
-`;
-    code += `        """Test ${fn.name} with valid input"""
-`;
-    code += `        result = ${fn.name}(${validParams})
-`;
-    code += `        assert result is not None
-
-`;
-    return code;
-  }
-  /**
-   * Generate Pytest tests for a class
-   */
-  generatePytestClassTests(cls) {
-    const constructorArgs = cls.constructorParams?.map((p) => this.generatePythonTestValue(p)).join(", ") || "";
-    let code = `
-class Test${cls.name}:
-`;
-    code += `    """Tests for ${cls.name}"""
-
-`;
-    code += `    @pytest.fixture
-`;
-    code += `    def instance(self):
-`;
-    code += `        return ${cls.name}(${constructorArgs})
-
-`;
-    code += `    def test_instantiation(self, instance):
-`;
-    code += `        assert isinstance(instance, ${cls.name})
-
-`;
-    for (const method of cls.methods) {
-      if (!method.name.startsWith("_")) {
-        const methodParams = method.parameters.map((p) => this.generatePythonTestValue(p)).join(", ");
-        code += `    def test_${method.name}(self, instance):
-`;
-        code += `        result = instance.${method.name}(${methodParams})
-`;
-        code += `        assert result is not None
-
-`;
-      }
-    }
-    return code;
-  }
-  /**
-   * Generate a Python test value for a parameter
+   * Generate stub tests when no AST analysis is available
    */
-  generatePythonTestValue(param) {
-    const type = param.type?.toLowerCase() || "unknown";
-    const name = param.name.toLowerCase();
-    if (name.includes("id")) return `"${faker.string.uuid()}"`;
-    if (name.includes("name")) return `"${faker.person.fullName()}"`;
-    if (name.includes("email")) return `"${faker.internet.email()}"`;
-    if (type.includes("str")) return `"${faker.lorem.word()}"`;
-    if (type.includes("int") || type.includes("number")) {
-      return String(faker.number.int({ min: 1, max: 100 }));
-    }
-    if (type.includes("bool")) return "True";
-    if (type.includes("list") || type.includes("[]")) return "[]";
-    if (type.includes("dict") || type.includes("{}")) return "{}";
-    return "None";
-  }
-  async findApplicablePatterns(sourceFile, requestedPatterns) {
-    const patterns = [];
-    for (const patternName of requestedPatterns) {
-      const stored = await this.memory.get(`pattern:${patternName}`);
-      if (stored) {
-        patterns.push(stored);
-      }
-    }
-    const extension = sourceFile.split(".").pop() || "";
-    const searchResults = await this.memory.search(`pattern:*:${extension}`, 5);
-    for (const key of searchResults) {
-      const pattern = await this.memory.get(key);
-      if (pattern && !patterns.some((p) => p.id === pattern.id)) {
-        patterns.push(pattern);
-      }
-    }
-    return patterns;
-  }
-  generateStubTestCode(sourceFile, testType, framework, patterns) {
-    const moduleName = this.extractModuleName(sourceFile);
-    const importPath = this.getImportPath(sourceFile);
-    switch (framework) {
-      case "jest":
-      case "vitest":
-        return this.generateJestVitestTest(moduleName, importPath, testType, patterns);
-      case "mocha":
-        return this.generateMochaTest(moduleName, importPath, testType, patterns);
-      case "pytest":
-        return this.generatePytestTest(moduleName, importPath, testType, patterns);
-      default:
-        return this.generateJestVitestTest(moduleName, importPath, testType, patterns);
-    }
-  }
-  generateJestVitestTest(moduleName, importPath, testType, patterns) {
-    const patternComment = patterns.length > 0 ? `// Applied patterns: ${patterns.map((p) => p.name).join(", ")}
-` : "";
+  generateStubTests(context) {
+    const { moduleName, importPath, testType, patterns } = context;
+    const patternComment = this.generatePatternComment(patterns);
     const basicOpsTest = this.generateBasicOpsTest(moduleName, patterns);
     const edgeCaseTest = this.generateEdgeCaseTest(moduleName, patterns);
     const errorHandlingTest = this.generateErrorHandlingTest(moduleName, patterns);
@@ -12954,7 +13361,43 @@ ${errorHandlingTest}
 `;
   }
   /**
-   * Generate basic operations test based on patterns
+   * Generate coverage-focused tests for specific lines
+   */
+  generateCoverageTests(moduleName, importPath, lines) {
+    const funcName = this.camelCase(moduleName);
+    const lineRange = this.formatLineRange(lines);
+    return `// Coverage test for ${lineRange} in ${moduleName}
+import { ${funcName} } from '${importPath}';
+
+describe('${moduleName} coverage', () => {
+  describe('${lineRange}', () => {
+    it('should execute code path covering ${lineRange}', () => {
+      // Arrange: Set up test inputs to reach uncovered lines
+      const testInput = undefined; // Replace with appropriate input
+
+      // Act: Execute the code path
+      const result = ${funcName}(testInput);
+
+      // Assert: Verify the code was reached and behaves correctly
+      expect(result).toBeDefined();
+    });
+
+    it('should handle edge case for ${lineRange}', () => {
+      // Arrange: Set up edge case input
+      const edgeCaseInput = null;
+
+      // Act & Assert: Verify edge case handling
+      expect(() => ${funcName}(edgeCaseInput)).not.toThrow();
+    });
+  });
+});
+`;
+  }
+  // ============================================================================
+  // Pattern-Aware Stub Test Generators
+  // ============================================================================
+  /**
+   * Generate basic operations test based on detected patterns
    */
   generateBasicOpsTest(moduleName, patterns) {
     const isService = patterns.some(
@@ -13013,7 +13456,7 @@ ${errorHandlingTest}
     });`;
   }
   /**
-   * Generate edge case test based on patterns
+   * Generate edge case test based on detected patterns
    */
   generateEdgeCaseTest(moduleName, patterns) {
     const hasValidation = patterns.some(
@@ -13060,7 +13503,7 @@ ${errorHandlingTest}
     });`;
   }
   /**
-   * Generate error handling test based on patterns
+   * Generate error handling test based on detected patterns
    */
   generateErrorHandlingTest(moduleName, patterns) {
     const hasErrorPattern = patterns.some(
@@ -13111,9 +13554,118 @@ ${errorHandlingTest}
       expect(() => Object.keys(${moduleName})).not.toThrow();
     });`;
   }
-  generateMochaTest(moduleName, importPath, testType, patterns) {
-    const patternComment = patterns.length > 0 ? `// Applied patterns: ${patterns.map((p) => p.name).join(", ")}
-` : "";
+};
+
+// src/domains/test-generation/generators/mocha-generator.ts
+var MochaGenerator = class extends BaseTestGenerator {
+  framework = "mocha";
+  /**
+   * Generate complete test file from analysis
+   */
+  generateTests(context) {
+    const { moduleName, importPath, testType, patterns, analysis } = context;
+    if (!analysis || analysis.functions.length === 0 && analysis.classes.length === 0) {
+      return this.generateStubTests(context);
+    }
+    const patternComment = this.generatePatternComment(patterns);
+    const exports = this.extractExports(analysis.functions, analysis.classes);
+    const importStatement = this.generateImportStatement(exports, importPath, moduleName);
+    let code = `${patternComment}import { expect } from 'chai';
+${importStatement}
+
+describe('${moduleName} - ${testType} tests', function() {
+`;
+    for (const fn of analysis.functions) {
+      code += this.generateFunctionTests(fn, testType);
+    }
+    for (const cls of analysis.classes) {
+      code += this.generateClassTests(cls, testType);
+    }
+    code += `});
+`;
+    return code;
+  }
+  /**
+   * Generate tests for a standalone function
+   */
+  generateFunctionTests(fn, _testType) {
+    const validParams = fn.parameters.map((p) => this.generateTestValue(p)).join(", ");
+    const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
+    let code = `  describe('${fn.name}', function() {
+`;
+    code += `    it('should handle valid input', ${fn.isAsync ? "async " : ""}function() {
+`;
+    code += `      const result = ${fnCall};
+`;
+    code += `      expect(result).to.not.be.undefined;
+`;
+    code += `    });
+`;
+    for (const param of fn.parameters) {
+      if (!param.optional) {
+        const paramsWithUndefined = fn.parameters.map((p) => p.name === param.name ? "undefined" : this.generateTestValue(p)).join(", ");
+        code += `
+    it('should handle undefined ${param.name}', function() {
+`;
+        code += `      expect(function() { ${fn.name}(${paramsWithUndefined}); }).to.throw();
+`;
+        code += `    });
+`;
+      }
+    }
+    code += `  });
+
+`;
+    return code;
+  }
+  /**
+   * Generate tests for a class
+   */
+  generateClassTests(cls, _testType) {
+    const constructorArgs = cls.constructorParams?.map((p) => this.generateTestValue(p)).join(", ") || "";
+    let code = `  describe('${cls.name}', function() {
+`;
+    code += `    let instance;
+
+`;
+    code += `    beforeEach(function() {
+`;
+    code += `      instance = new ${cls.name}(${constructorArgs});
+`;
+    code += `    });
+
+`;
+    code += `    it('should instantiate correctly', function() {
+`;
+    code += `      expect(instance).to.be.instanceOf(${cls.name});
+`;
+    code += `    });
+`;
+    for (const method of cls.methods) {
+      if (!method.name.startsWith("_")) {
+        const methodParams = method.parameters.map((p) => this.generateTestValue(p)).join(", ");
+        code += `
+    it('${method.name} should work', ${method.isAsync ? "async " : ""}function() {
+`;
+        code += `      const result = ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
+`;
+        code += `      expect(result).to.not.be.undefined;
+`;
+        code += `    });
+`;
+      }
+    }
+    code += `  });
+
+`;
+    return code;
+  }
+  /**
+   * Generate stub tests when no AST analysis is available
+   */
+  generateStubTests(context) {
+    const { moduleName, importPath, testType, patterns } = context;
+    const patternComment = this.generatePatternComment(patterns);
     const isAsync = patterns.some(
       (p) => p.name.toLowerCase().includes("async") || p.name.toLowerCase().includes("promise")
     );
@@ -13146,12 +13698,12 @@ describe('${moduleName}', function() {
         ? new ${moduleName}()
         : ${moduleName};
       expect(instance).to.exist;
-      expect(() => JSON.stringify(instance)).to.not.throw();
+      expect(function() { JSON.stringify(instance); }).to.not.throw();
     });
 
     it('should handle error conditions', function() {
       // Verify error resilience
-      expect(() => {
+      expect(function() {
         const instance = typeof ${moduleName} === 'function'
           ? new ${moduleName}()
           : ${moduleName};
@@ -13162,9 +13714,147 @@ describe('${moduleName}', function() {
 });
 `;
   }
-  generatePytestTest(moduleName, importPath, testType, patterns) {
-    const patternComment = patterns.length > 0 ? `# Applied patterns: ${patterns.map((p) => p.name).join(", ")}
-` : "";
+  /**
+   * Generate coverage-focused tests for specific lines
+   */
+  generateCoverageTests(moduleName, importPath, lines) {
+    const funcName = this.camelCase(moduleName);
+    const lineRange = this.formatLineRange(lines);
+    return `// Coverage test for ${lineRange} in ${moduleName}
+import { expect } from 'chai';
+import { ${funcName} } from '${importPath}';
+
+describe('${moduleName} coverage', function() {
+  describe('${lineRange}', function() {
+    it('should execute code path covering ${lineRange}', function() {
+      // Arrange: Set up test inputs to reach uncovered lines
+      const testInput = undefined; // Replace with appropriate input
+
+      // Act: Execute the code path
+      const result = ${funcName}(testInput);
+
+      // Assert: Verify the code was reached and behaves correctly
+      expect(result).to.not.be.undefined;
+    });
+
+    it('should handle edge case for ${lineRange}', function() {
+      // Arrange: Set up edge case input
+      const edgeCaseInput = null;
+
+      // Act & Assert: Verify edge case handling
+      expect(function() { ${funcName}(edgeCaseInput); }).to.not.throw();
+    });
+  });
+});
+`;
+  }
+};
+
+// src/domains/test-generation/generators/pytest-generator.ts
+import { faker as faker2 } from "@faker-js/faker";
+var PytestGenerator = class extends BaseTestGenerator {
+  framework = "pytest";
+  /**
+   * Generate complete test file from analysis
+   */
+  generateTests(context) {
+    const { moduleName, importPath, testType, patterns, analysis } = context;
+    if (!analysis || analysis.functions.length === 0 && analysis.classes.length === 0) {
+      return this.generateStubTests(context);
+    }
+    const patternComment = this.generatePythonPatternComment(patterns);
+    const exports = this.extractExports(analysis.functions, analysis.classes);
+    const pythonImport = importPath.replace(/\//g, ".").replace(/\.(ts|js)$/, "");
+    const importStatement = exports.length > 0 ? `from ${pythonImport} import ${exports.join(", ")}` : `import ${pythonImport} as ${moduleName}`;
+    let code = `${patternComment}import pytest
+${importStatement}
+
+
+class Test${this.pascalCase(moduleName)}:
+    """${testType} tests for ${moduleName}"""
+
+`;
+    for (const fn of analysis.functions) {
+      code += this.generateFunctionTests(fn, testType);
+    }
+    for (const cls of analysis.classes) {
+      code += this.generateClassTests(cls, testType);
+    }
+    return code;
+  }
+  /**
+   * Generate tests for a standalone function
+   */
+  generateFunctionTests(fn, _testType) {
+    const validParams = fn.parameters.map((p) => this.generatePythonTestValue(p)).join(", ");
+    let code = `    def test_${fn.name}_valid_input(self):
+`;
+    code += `        """Test ${fn.name} with valid input"""
+`;
+    code += `        result = ${fn.name}(${validParams})
+`;
+    code += `        assert result is not None
+
+`;
+    for (const param of fn.parameters) {
+      if (!param.optional && param.type?.includes("str")) {
+        code += `    def test_${fn.name}_empty_${param.name}(self):
+`;
+        code += `        """Test ${fn.name} with empty ${param.name}"""
+`;
+        const paramsWithEmpty = fn.parameters.map((p) => p.name === param.name ? '""' : this.generatePythonTestValue(p)).join(", ");
+        code += `        result = ${fn.name}(${paramsWithEmpty})
+`;
+        code += `        assert result is not None
+
+`;
+      }
+    }
+    return code;
+  }
+  /**
+   * Generate tests for a class
+   */
+  generateClassTests(cls, _testType) {
+    const constructorArgs = cls.constructorParams?.map((p) => this.generatePythonTestValue(p)).join(", ") || "";
+    let code = `
+class Test${cls.name}:
+`;
+    code += `    """Tests for ${cls.name}"""
+
+`;
+    code += `    @pytest.fixture
+`;
+    code += `    def instance(self):
+`;
+    code += `        return ${cls.name}(${constructorArgs})
+
+`;
+    code += `    def test_instantiation(self, instance):
+`;
+    code += `        assert isinstance(instance, ${cls.name})
+
+`;
+    for (const method of cls.methods) {
+      if (!method.name.startsWith("_")) {
+        const methodParams = method.parameters.map((p) => this.generatePythonTestValue(p)).join(", ");
+        code += `    def test_${method.name}(self, instance):
+`;
+        code += `        result = instance.${method.name}(${methodParams})
+`;
+        code += `        assert result is not None
+
+`;
+      }
+    }
+    return code;
+  }
+  /**
+   * Generate stub tests when no AST analysis is available
+   */
+  generateStubTests(context) {
+    const { moduleName, importPath, testType, patterns } = context;
+    const patternComment = this.generatePythonPatternComment(patterns);
     const isAsync = patterns.some(
       (p) => p.name.toLowerCase().includes("async") || p.name.toLowerCase().includes("promise")
     );
@@ -13174,7 +13864,7 @@ describe('${moduleName}', function() {
 from ${importPath} import ${moduleName}
 
 
-class Test${moduleName}:
+class Test${this.pascalCase(moduleName)}:
     """${testType} tests for ${moduleName}"""
 
     def test_is_defined(self):
@@ -13213,7 +13903,169 @@ class Test${moduleName}:
             pass
 `;
   }
-  async generateRedPhaseTest(feature, behavior, _framework) {
+  /**
+   * Generate coverage-focused tests for specific lines
+   */
+  generateCoverageTests(moduleName, importPath, lines) {
+    const funcName = this.camelCase(moduleName);
+    const lineRange = this.formatLineRange(lines);
+    const pythonImport = importPath.replace(/\//g, ".");
+    return `# Coverage test for ${lineRange} in ${moduleName}
+import pytest
+from ${pythonImport} import ${funcName}
+
+class Test${this.pascalCase(moduleName)}Coverage:
+    """Tests to cover ${lineRange}"""
+
+    def test_cover_${lines[0]}_${lines[lines.length - 1]}(self):
+        """Exercise code path covering ${lineRange}"""
+        # Arrange: Set up test inputs to reach uncovered lines
+        test_input = None  # Replace with appropriate input
+
+        # Act: Execute the code path
+        try:
+            result = ${funcName}(test_input)
+
+            # Assert: Verify expected behavior
+            assert result is not None
+        except Exception as e:
+            # If exception is expected for this path, verify it
+            pytest.fail(f"Unexpected exception: {e}")
+`;
+  }
+  // ============================================================================
+  // Python-Specific Helpers
+  // ============================================================================
+  /**
+   * Generate Python pattern comment
+   */
+  generatePythonPatternComment(patterns) {
+    if (patterns.length === 0) return "";
+    return `# Applied patterns: ${patterns.map((p) => p.name).join(", ")}
+`;
+  }
+  /**
+   * Generate a Python test value for a parameter
+   */
+  generatePythonTestValue(param) {
+    const type = param.type?.toLowerCase() || "unknown";
+    const name = param.name.toLowerCase();
+    if (name.includes("id")) return `"${faker2.string.uuid()}"`;
+    if (name.includes("name")) return `"${faker2.person.fullName()}"`;
+    if (name.includes("email")) return `"${faker2.internet.email()}"`;
+    if (name.includes("url")) return `"${faker2.internet.url()}"`;
+    if (type.includes("str")) return `"${faker2.lorem.word()}"`;
+    if (type.includes("int") || type.includes("number")) {
+      return String(faker2.number.int({ min: 1, max: 100 }));
+    }
+    if (type.includes("bool")) return "True";
+    if (type.includes("list") || type.includes("[]")) return "[]";
+    if (type.includes("dict") || type.includes("{}")) return "{}";
+    if (type.includes("float")) return String(faker2.number.float({ min: 0, max: 100 }));
+    return "None";
+  }
+};
+
+// src/domains/test-generation/factories/test-generator-factory.ts
+var SUPPORTED_FRAMEWORKS = [
+  "jest",
+  "vitest",
+  "mocha",
+  "pytest"
+];
+var DEFAULT_FRAMEWORK = "vitest";
+var TestGeneratorFactory = class {
+  /**
+   * Cache of created generators for reuse
+   */
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Create a test generator for the specified framework
+   *
+   * @param framework - Target test framework
+   * @returns Test generator instance
+   * @throws Error if framework is not supported
+   */
+  create(framework) {
+    const cached = this.cache.get(framework);
+    if (cached) {
+      return cached;
+    }
+    const generator = this.createGenerator(framework);
+    this.cache.set(framework, generator);
+    return generator;
+  }
+  /**
+   * Check if a framework is supported
+   *
+   * @param framework - Framework to check
+   * @returns True if supported, with type narrowing
+   */
+  supports(framework) {
+    return SUPPORTED_FRAMEWORKS.includes(framework);
+  }
+  /**
+   * Get the default framework
+   *
+   * @returns Default test framework (vitest)
+   */
+  getDefault() {
+    return DEFAULT_FRAMEWORK;
+  }
+  /**
+   * Get all supported frameworks
+   *
+   * @returns Array of supported framework names
+   */
+  getSupportedFrameworks() {
+    return [...SUPPORTED_FRAMEWORKS];
+  }
+  /**
+   * Create a generator instance for the framework
+   */
+  createGenerator(framework) {
+    switch (framework) {
+      case "jest":
+        return new JestVitestGenerator("jest");
+      case "vitest":
+        return new JestVitestGenerator("vitest");
+      case "mocha":
+        return new MochaGenerator();
+      case "pytest":
+        return new PytestGenerator();
+      default:
+        throw new Error(`Unsupported test framework: ${framework}`);
+    }
+  }
+  /**
+   * Clear the generator cache
+   * Useful for testing or when memory needs to be freed
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+};
+var testGeneratorFactory = new TestGeneratorFactory();
+
+// src/domains/test-generation/services/tdd-generator.ts
+var TDDGeneratorService = class {
+  /**
+   * Generate TDD artifacts based on the requested phase
+   */
+  async generateTDDTests(request) {
+    const { feature, behavior, framework, phase } = request;
+    switch (phase) {
+      case "red":
+        return this.generateRedPhaseTest(feature, behavior, framework);
+      case "green":
+        return this.generateGreenPhaseCode(feature, behavior, framework);
+      case "refactor":
+        return this.generateRefactoringSuggestions(feature, behavior);
+      default:
+        throw new Error(`Unknown TDD phase: ${phase}`);
+    }
+  }
+  generateRedPhaseTest(feature, behavior, _framework) {
     const funcName = this.camelCase(feature);
     const assertions = this.generateAssertionsFromBehavior(behavior, funcName);
     const testCode = `describe('${feature}', () => {
@@ -13228,10 +14080,6 @@ ${assertions}
       nextStep: "Write the minimal implementation to make this test pass"
     };
   }
-  /**
-   * Generate specific assertions from behavior description
-   * Uses NLP-style extraction to infer test values and assertions
-   */
   generateAssertionsFromBehavior(behavior, funcName) {
     const behaviorLower = behavior.toLowerCase();
     const assertions = [];
@@ -13272,7 +14120,7 @@ ${assertions}
       } else if (context.extractedNumber !== void 0) {
         assertions.push(`    expect(result).toContain(${expectedValue});`);
       } else {
-        assertions.push(`    expect(result).toContain(testInput); // Contains the input`);
+        assertions.push(`    expect(result).toContain(testInput);`);
       }
     } else if (behaviorLower.includes("length") || behaviorLower.includes("count")) {
       assertions.push(`    const result = ${funcCall};`);
@@ -13329,9 +14177,6 @@ ${assertions}
     }
     return assertions.join("\n");
   }
-  /**
-   * Extract contextual information from behavior description
-   */
   extractBehaviorContext(behavior) {
     const context = {};
     const stringMatch = behavior.match(/["']([^"']+)["']/);
@@ -13363,9 +14208,6 @@ ${assertions}
     }
     return context;
   }
-  /**
-   * Build function call with appropriate arguments based on context
-   */
   buildFunctionCall(funcName, context, behaviorLower) {
     if (context.inputType) {
       return `${funcName}(testInput)`;
@@ -13398,7 +14240,7 @@ ${assertions}
     }
     return `${funcName}(input)`;
   }
-  async generateGreenPhaseCode(feature, behavior, _framework) {
+  generateGreenPhaseCode(feature, behavior, _framework) {
     const behaviorLower = behavior.toLowerCase();
     const funcName = this.camelCase(feature);
     const { returnType, implementation, params } = this.inferImplementationFromBehavior(behaviorLower);
@@ -13415,10 +14257,6 @@ ${implementation}
       nextStep: "Refactor the code while keeping tests green"
     };
   }
-  /**
-   * Infer implementation details from behavior description using heuristics
-   * Analyzes the behavior text to determine return type, parameters, and minimal implementation
-   */
   inferImplementationFromBehavior(behavior) {
     let returnType = "unknown";
     let implementation = "  return undefined;";
@@ -13481,7 +14319,7 @@ ${implementation}`;
     }
     return { returnType, implementation, params };
   }
-  async generateRefactoringSuggestions(_feature, _behavior) {
+  generateRefactoringSuggestions(_feature, _behavior) {
     return {
       phase: "refactor",
       refactoringChanges: [
@@ -13494,6 +14332,28 @@ ${implementation}`;
       nextStep: "Apply refactoring changes and ensure all tests still pass"
     };
   }
+  camelCase(str) {
+    return str.replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase()).replace(/^./, (chr) => chr.toLowerCase());
+  }
+};
+
+// src/domains/test-generation/services/property-test-generator.ts
+var PropertyTestGeneratorService = class {
+  /**
+   * Generate property-based tests
+   */
+  async generatePropertyTests(request) {
+    const { function: funcName, properties, constraints = {} } = request;
+    const tests = properties.map((property) => ({
+      property,
+      testCode: this.generatePropertyTestCode(funcName, property, constraints),
+      generators: this.inferGenerators(property, constraints)
+    }));
+    return {
+      tests,
+      arbitraries: this.collectArbitraries(tests)
+    };
+  }
   generatePropertyTestCode(funcName, property, constraints) {
     const propertyLower = property.toLowerCase();
     const { generators, assertion, setupCode } = this.analyzePropertyForTestGeneration(
@@ -13515,9 +14375,6 @@ ${setupCode}
   });
 });`;
   }
-  /**
-   * Analyze property description to determine generators and assertions
-   */
   analyzePropertyForTestGeneration(propertyLower, funcName, constraints) {
     const generators = [];
     let assertion = "return result !== undefined;";
@@ -13611,9 +14468,6 @@ ${setupCode}
     }
     return { generators, assertion, setupCode };
   }
-  /**
-   * Infer the appropriate fast-check generator from constraints
-   */
   inferGeneratorFromConstraints(constraints, hint) {
     const type = constraints.type?.toLowerCase() || hint.toLowerCase();
     if (type.includes("string") || type.includes("text")) {
@@ -13632,34 +14486,19 @@ ${setupCode}
       }
       return "fc.integer()";
     }
-    if (type.includes("float") || type.includes("decimal")) {
-      return "fc.float()";
-    }
-    if (type.includes("boolean") || type.includes("bool")) {
-      return "fc.boolean()";
-    }
+    if (type.includes("float") || type.includes("decimal")) return "fc.float()";
+    if (type.includes("boolean") || type.includes("bool")) return "fc.boolean()";
     if (type.includes("array") || type.includes("list")) {
       const itemType = constraints.itemType || "anything";
       const itemGen = this.getSimpleGenerator(itemType);
       return `fc.array(${itemGen})`;
     }
-    if (type.includes("object") || type.includes("record")) {
-      return "fc.object()";
-    }
-    if (type.includes("date")) {
-      return "fc.date()";
-    }
-    if (type.includes("uuid") || type.includes("id")) {
-      return "fc.uuid()";
-    }
-    if (type.includes("email")) {
-      return "fc.emailAddress()";
-    }
+    if (type.includes("object") || type.includes("record")) return "fc.object()";
+    if (type.includes("date")) return "fc.date()";
+    if (type.includes("uuid") || type.includes("id")) return "fc.uuid()";
+    if (type.includes("email")) return "fc.emailAddress()";
     return "fc.anything()";
   }
-  /**
-   * Get a simple generator for a type name
-   */
   getSimpleGenerator(typeName) {
     const typeMap = {
       string: "fc.string()",
@@ -13673,22 +14512,12 @@ ${setupCode}
     };
     return typeMap[typeName.toLowerCase()] || "fc.anything()";
   }
-  /**
-   * Generate parameter names from generator list
-   */
   generatePropertyParams(generators) {
-    if (generators.length === 1) {
-      return "input";
-    }
+    if (generators.length === 1) return "input";
     return generators.map((_, i) => String.fromCharCode(97 + i)).join(", ");
   }
-  /**
-   * Generate argument list for function call
-   */
   generatePropertyArgs(generators) {
-    if (generators.length === 1) {
-      return "input";
-    }
+    if (generators.length === 1) return "input";
     return generators.map((_, i) => String.fromCharCode(97 + i)).join(", ");
   }
   inferGenerators(property, constraints) {
@@ -13771,8 +14600,33 @@ ${setupCode}
     }
     return Array.from(arbitraries);
   }
+};
+
+// src/domains/test-generation/services/test-data-generator.ts
+import { faker as faker3 } from "@faker-js/faker";
+var TestDataGeneratorService = class {
+  /**
+   * Generate test data based on schema
+   */
+  async generateTestData(request) {
+    const { schema, count, locale = "en", preserveRelationships = false } = request;
+    const seed = Date.now();
+    const records = [];
+    for (let i = 0; i < count; i++) {
+      const record = this.generateRecordFromSchema(schema, seed + i, locale);
+      records.push(record);
+    }
+    if (preserveRelationships) {
+      this.linkRelatedRecords(records, schema);
+    }
+    return {
+      records,
+      schema,
+      seed
+    };
+  }
   generateRecordFromSchema(schema, seed, locale) {
-    faker.seed(seed);
+    faker3.seed(seed);
     if (locale && locale !== "en") {
     }
     const record = {};
@@ -13805,146 +14659,146 @@ ${setupCode}
         return this.generateNumberValue(options);
       case "float":
       case "decimal":
-        return faker.number.float({ min: options?.min ?? 0, max: options?.max ?? 1e3, fractionDigits: 2 });
+        return faker3.number.float({ min: options?.min ?? 0, max: options?.max ?? 1e3, fractionDigits: 2 });
       case "boolean":
       case "bool":
-        return faker.datatype.boolean();
+        return faker3.datatype.boolean();
       case "date":
       case "datetime":
-        return faker.date.recent().toISOString();
+        return faker3.date.recent().toISOString();
       case "email":
-        return faker.internet.email();
+        return faker3.internet.email();
       case "uuid":
       case "id":
-        return faker.string.uuid();
+        return faker3.string.uuid();
       case "url":
-        return faker.internet.url();
+        return faker3.internet.url();
       case "phone":
-        return faker.phone.number();
+        return faker3.phone.number();
       case "address":
         return this.generateAddress();
       case "name":
       case "fullname":
-        return faker.person.fullName();
+        return faker3.person.fullName();
       case "firstname":
-        return faker.person.firstName();
+        return faker3.person.firstName();
       case "lastname":
-        return faker.person.lastName();
+        return faker3.person.lastName();
       case "username":
-        return faker.internet.username();
+        return faker3.internet.username();
       case "password":
-        return faker.internet.password();
+        return faker3.internet.password();
       case "company":
-        return faker.company.name();
+        return faker3.company.name();
       case "jobtitle":
-        return faker.person.jobTitle();
+        return faker3.person.jobTitle();
       case "text":
       case "paragraph":
-        return faker.lorem.paragraph();
+        return faker3.lorem.paragraph();
       case "sentence":
-        return faker.lorem.sentence();
+        return faker3.lorem.sentence();
       case "word":
       case "words":
-        return faker.lorem.word();
+        return faker3.lorem.word();
       case "avatar":
       case "image":
-        return faker.image.avatar();
+        return faker3.image.avatar();
       case "color":
-        return faker.color.rgb();
+        return faker3.color.rgb();
       case "ipaddress":
       case "ip":
-        return faker.internet.ipv4();
+        return faker3.internet.ipv4();
       case "mac":
-        return faker.internet.mac();
+        return faker3.internet.mac();
       case "latitude":
-        return faker.location.latitude();
+        return faker3.location.latitude();
       case "longitude":
-        return faker.location.longitude();
+        return faker3.location.longitude();
       case "country":
-        return faker.location.country();
+        return faker3.location.country();
       case "city":
-        return faker.location.city();
+        return faker3.location.city();
       case "zipcode":
       case "postalcode":
-        return faker.location.zipCode();
+        return faker3.location.zipCode();
       case "creditcard":
-        return faker.finance.creditCardNumber();
+        return faker3.finance.creditCardNumber();
       case "currency":
-        return faker.finance.currencyCode();
+        return faker3.finance.currencyCode();
       case "amount":
       case "price":
-        return faker.finance.amount();
+        return faker3.finance.amount();
       case "json":
       case "object":
-        return { key: faker.lorem.word(), value: faker.lorem.sentence() };
+        return { key: faker3.lorem.word(), value: faker3.lorem.sentence() };
       case "array":
-        return [faker.lorem.word(), faker.lorem.word(), faker.lorem.word()];
+        return [faker3.lorem.word(), faker3.lorem.word(), faker3.lorem.word()];
       case "enum":
         if (options?.enum && options.enum.length > 0) {
-          return faker.helpers.arrayElement(options.enum);
+          return faker3.helpers.arrayElement(options.enum);
         }
-        return faker.lorem.word();
+        return faker3.lorem.word();
       default:
         return this.inferValueFromFieldName(fieldName);
     }
   }
   generateStringValue(fieldName, options) {
     const lowerName = fieldName.toLowerCase();
-    if (lowerName.includes("email")) return faker.internet.email();
-    if (lowerName.includes("name") && lowerName.includes("first")) return faker.person.firstName();
-    if (lowerName.includes("name") && lowerName.includes("last")) return faker.person.lastName();
-    if (lowerName.includes("name")) return faker.person.fullName();
-    if (lowerName.includes("phone")) return faker.phone.number();
-    if (lowerName.includes("address")) return faker.location.streetAddress();
-    if (lowerName.includes("city")) return faker.location.city();
-    if (lowerName.includes("country")) return faker.location.country();
-    if (lowerName.includes("zip") || lowerName.includes("postal")) return faker.location.zipCode();
-    if (lowerName.includes("url") || lowerName.includes("website")) return faker.internet.url();
-    if (lowerName.includes("username") || lowerName.includes("user")) return faker.internet.username();
-    if (lowerName.includes("password")) return faker.internet.password();
-    if (lowerName.includes("description") || lowerName.includes("bio")) return faker.lorem.paragraph();
-    if (lowerName.includes("title")) return faker.lorem.sentence();
-    if (lowerName.includes("company")) return faker.company.name();
-    if (lowerName.includes("job")) return faker.person.jobTitle();
-    if (lowerName.includes("avatar") || lowerName.includes("image")) return faker.image.avatar();
+    if (lowerName.includes("email")) return faker3.internet.email();
+    if (lowerName.includes("name") && lowerName.includes("first")) return faker3.person.firstName();
+    if (lowerName.includes("name") && lowerName.includes("last")) return faker3.person.lastName();
+    if (lowerName.includes("name")) return faker3.person.fullName();
+    if (lowerName.includes("phone")) return faker3.phone.number();
+    if (lowerName.includes("address")) return faker3.location.streetAddress();
+    if (lowerName.includes("city")) return faker3.location.city();
+    if (lowerName.includes("country")) return faker3.location.country();
+    if (lowerName.includes("zip") || lowerName.includes("postal")) return faker3.location.zipCode();
+    if (lowerName.includes("url") || lowerName.includes("website")) return faker3.internet.url();
+    if (lowerName.includes("username") || lowerName.includes("user")) return faker3.internet.username();
+    if (lowerName.includes("password")) return faker3.internet.password();
+    if (lowerName.includes("description") || lowerName.includes("bio")) return faker3.lorem.paragraph();
+    if (lowerName.includes("title")) return faker3.lorem.sentence();
+    if (lowerName.includes("company")) return faker3.company.name();
+    if (lowerName.includes("job")) return faker3.person.jobTitle();
+    if (lowerName.includes("avatar") || lowerName.includes("image")) return faker3.image.avatar();
     if (options?.pattern) {
-      return faker.helpers.fromRegExp(options.pattern);
+      return faker3.helpers.fromRegExp(options.pattern);
     }
-    return faker.lorem.words(3);
+    return faker3.lorem.words(3);
   }
   generateNumberValue(options) {
     const min = options?.min ?? 0;
     const max = options?.max ?? 1e4;
-    return faker.number.int({ min, max });
+    return faker3.number.int({ min, max });
   }
   generateAddress() {
     return {
-      street: faker.location.streetAddress(),
-      city: faker.location.city(),
-      state: faker.location.state(),
-      zipCode: faker.location.zipCode(),
-      country: faker.location.country()
+      street: faker3.location.streetAddress(),
+      city: faker3.location.city(),
+      state: faker3.location.state(),
+      zipCode: faker3.location.zipCode(),
+      country: faker3.location.country()
     };
   }
   inferValueFromFieldName(fieldName) {
     const lowerName = fieldName.toLowerCase();
-    if (lowerName.includes("id")) return faker.string.uuid();
-    if (lowerName.includes("email")) return faker.internet.email();
-    if (lowerName.includes("name")) return faker.person.fullName();
-    if (lowerName.includes("phone")) return faker.phone.number();
-    if (lowerName.includes("date") || lowerName.includes("time")) return faker.date.recent().toISOString();
-    if (lowerName.includes("url")) return faker.internet.url();
-    if (lowerName.includes("count") || lowerName.includes("amount")) return faker.number.int({ min: 0, max: 100 });
-    if (lowerName.includes("price")) return faker.finance.amount();
+    if (lowerName.includes("id")) return faker3.string.uuid();
+    if (lowerName.includes("email")) return faker3.internet.email();
+    if (lowerName.includes("name")) return faker3.person.fullName();
+    if (lowerName.includes("phone")) return faker3.phone.number();
+    if (lowerName.includes("date") || lowerName.includes("time")) return faker3.date.recent().toISOString();
+    if (lowerName.includes("url")) return faker3.internet.url();
+    if (lowerName.includes("count") || lowerName.includes("amount")) return faker3.number.int({ min: 0, max: 100 });
+    if (lowerName.includes("price")) return faker3.finance.amount();
     if (lowerName.includes("active") || lowerName.includes("enabled") || lowerName.includes("is")) {
-      return faker.datatype.boolean();
+      return faker3.datatype.boolean();
     }
-    return faker.lorem.word();
+    return faker3.lorem.word();
   }
   callFakerMethod(methodPath) {
     try {
       const parts = methodPath.split(".");
-      let result = faker;
+      let result = faker3;
       for (const part of parts) {
         if (result && typeof result === "object" && part in result) {
           const next = result[part];
@@ -13954,12 +14808,12 @@ ${setupCode}
             result = next;
           }
         } else {
-          return faker.lorem.word();
+          return faker3.lorem.word();
         }
       }
       return result;
     } catch {
-      return faker.lorem.word();
+      return faker3.lorem.word();
     }
   }
   linkRelatedRecords(records, schema) {
@@ -13978,21 +14832,177 @@ ${setupCode}
         for (const { field, reference } of referenceFields) {
           if (i > 0 && reference === "id") {
             const prevRecord = records[Math.floor(Math.random() * i)];
-            record[field] = prevRecord["id"] ?? faker.string.uuid();
+            record[field] = prevRecord["id"] ?? faker3.string.uuid();
           } else {
-            record[field] = faker.string.uuid();
+            record[field] = faker3.string.uuid();
           }
         }
       }
     }
   }
+};
+
+// src/domains/test-generation/services/test-generator.ts
+var DEFAULT_CONFIG = {
+  defaultFramework: "vitest",
+  maxTestsPerFile: 50,
+  coverageTargetDefault: 80,
+  enableAIGeneration: true
+};
+var TestGeneratorService = class {
+  config;
+  memory;
+  generatorFactory;
+  tddGenerator;
+  propertyTestGenerator;
+  testDataGenerator;
+  constructor(dependencies, config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.memory = dependencies.memory;
+    this.generatorFactory = dependencies.generatorFactory || new TestGeneratorFactory();
+    this.tddGenerator = dependencies.tddGenerator || new TDDGeneratorService();
+    this.propertyTestGenerator = dependencies.propertyTestGenerator || new PropertyTestGeneratorService();
+    this.testDataGenerator = dependencies.testDataGenerator || new TestDataGeneratorService();
+  }
+  /**
+   * Generate tests for given source files
+   */
+  async generateTests(request) {
+    try {
+      const {
+        sourceFiles,
+        testType,
+        framework,
+        coverageTarget = this.config.coverageTargetDefault,
+        patterns = []
+      } = request;
+      if (sourceFiles.length === 0) {
+        return err(new Error("No source files provided"));
+      }
+      const tests = [];
+      const patternsUsed = [];
+      for (const sourceFile of sourceFiles) {
+        const fileTests = await this.generateTestsForFile(
+          sourceFile,
+          testType,
+          framework,
+          patterns
+        );
+        if (fileTests.success) {
+          tests.push(...fileTests.value.tests);
+          patternsUsed.push(...fileTests.value.patternsUsed);
+        }
+      }
+      const coverageEstimate = this.estimateCoverage(tests, coverageTarget);
+      await this.storeGenerationMetadata(tests, patternsUsed);
+      return ok({
+        tests,
+        coverageEstimate,
+        patternsUsed: Array.from(new Set(patternsUsed))
+      });
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Generate tests specifically targeting coverage gaps
+   */
+  async generateForCoverageGap(file, uncoveredLines, framework) {
+    try {
+      if (uncoveredLines.length === 0) {
+        return ok([]);
+      }
+      const tests = [];
+      const lineGroups = this.groupConsecutiveLines(uncoveredLines);
+      const frameworkType = this.generatorFactory.supports(framework) ? framework : this.config.defaultFramework;
+      for (const group of lineGroups) {
+        const test = await this.generateTestForLines(file, group, frameworkType);
+        if (test) {
+          tests.push(test);
+        }
+      }
+      return ok(tests);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Generate tests following TDD workflow - delegates to TDDGeneratorService
+   */
+  async generateTDDTests(request) {
+    try {
+      const result = await this.tddGenerator.generateTDDTests(request);
+      return ok(result);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Generate property-based tests - delegates to PropertyTestGeneratorService
+   */
+  async generatePropertyTests(request) {
+    try {
+      const result = await this.propertyTestGenerator.generatePropertyTests(request);
+      return ok(result);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Generate test data based on schema - delegates to TestDataGeneratorService
+   */
+  async generateTestData(request) {
+    try {
+      const result = await this.testDataGenerator.generateTestData(request);
+      return ok(result);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  // ============================================================================
+  // Private Helper Methods - Core Test Generation
+  // ============================================================================
+  async generateTestsForFile(sourceFile, testType, framework, patterns) {
+    const testFile = this.getTestFilePath(sourceFile, framework);
+    const patternsUsed = [];
+    const applicablePatterns = await this.findApplicablePatterns(sourceFile, patterns);
+    patternsUsed.push(...applicablePatterns.map((p) => p.name));
+    let codeAnalysis = null;
+    try {
+      const content = fs2.readFileSync(sourceFile, "utf-8");
+      codeAnalysis = this.analyzeSourceCode(content, sourceFile);
+    } catch {
+    }
+    const generator = this.generatorFactory.create(framework);
+    const moduleName = this.extractModuleName(sourceFile);
+    const importPath = this.getImportPath(sourceFile);
+    const context = {
+      moduleName,
+      importPath,
+      testType,
+      patterns: applicablePatterns,
+      analysis: codeAnalysis ?? void 0
+    };
+    const testCode = generator.generateTests(context);
+    const test = {
+      id: uuidv44(),
+      name: `${moduleName} tests`,
+      sourceFile,
+      testFile,
+      testCode,
+      type: testType,
+      assertions: this.countAssertions(testCode)
+    };
+    return ok({ tests: [test], patternsUsed });
+  }
   async generateTestForLines(file, lines, framework) {
     if (lines.length === 0) return null;
     const testId = uuidv44();
     const testFile = this.getTestFilePath(file, framework);
     const moduleName = this.extractModuleName(file);
     const importPath = this.getImportPath(file);
-    const testCode = this.generateCoverageTestCode(moduleName, importPath, lines, framework);
+    const generator = this.generatorFactory.create(framework);
+    const testCode = generator.generateCoverageTests(moduleName, importPath, lines);
     return {
       id: testId,
       name: `Coverage test for lines ${lines[0]}-${lines[lines.length - 1]}`,
@@ -14003,62 +15013,187 @@ ${setupCode}
       assertions: this.countAssertions(testCode)
     };
   }
-  /**
-   * Generate actual coverage test code for specific lines
-   */
-  generateCoverageTestCode(moduleName, importPath, lines, framework) {
-    const funcName = this.camelCase(moduleName);
-    const lineRange = lines.length === 1 ? `line ${lines[0]}` : `lines ${lines[0]}-${lines[lines.length - 1]}`;
-    if (framework === "pytest") {
-      return `# Coverage test for ${lineRange} in ${moduleName}
-import pytest
-from ${importPath.replace(/\//g, ".")} import ${funcName}
-
-class Test${this.pascalCase(moduleName)}Coverage:
-    """Tests to cover ${lineRange}"""
-
-    def test_cover_${lines[0]}_${lines[lines.length - 1]}(self):
-        """Exercise code path covering ${lineRange}"""
-        # Arrange: Set up test inputs to reach uncovered lines
-        test_input = None  # Replace with appropriate input
-
-        # Act: Execute the code path
-        try:
-            result = ${funcName}(test_input)
-
-            # Assert: Verify expected behavior
-            assert result is not None
-        except Exception as e:
-            # If exception is expected for this path, verify it
-            pytest.fail(f"Unexpected exception: {e}")
-`;
+  // ============================================================================
+  // Private Helper Methods - AST Analysis
+  // ============================================================================
+  analyzeSourceCode(content, fileName) {
+    const sourceFile = ts.createSourceFile(
+      path2.basename(fileName),
+      content,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TS
+    );
+    const functions = [];
+    const classes = [];
+    const visit = (node) => {
+      if (ts.isFunctionDeclaration(node) && node.name) {
+        functions.push(this.extractFunctionInfo(node, sourceFile));
+      } else if (ts.isVariableStatement(node)) {
+        for (const declaration of node.declarationList.declarations) {
+          if (ts.isVariableDeclaration(declaration) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) {
+            const name = declaration.name.getText(sourceFile);
+            functions.push(
+              this.extractArrowFunctionInfo(name, declaration.initializer, sourceFile, node)
+            );
+          }
+        }
+      } else if (ts.isClassDeclaration(node) && node.name) {
+        classes.push(this.extractClassInfo(node, sourceFile));
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    return { functions, classes };
+  }
+  extractFunctionInfo(node, sourceFile) {
+    const name = node.name?.getText(sourceFile) || "anonymous";
+    const parameters = this.extractParameters(node.parameters, sourceFile);
+    const returnType = node.type?.getText(sourceFile);
+    const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+    const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    return {
+      name,
+      parameters,
+      returnType,
+      isAsync,
+      isExported,
+      complexity: this.calculateComplexity(node),
+      startLine: startLine + 1,
+      endLine: endLine + 1,
+      body: node.body?.getText(sourceFile)
+    };
+  }
+  extractArrowFunctionInfo(name, node, sourceFile, parentNode) {
+    const parameters = this.extractParameters(node.parameters, sourceFile);
+    const returnType = node.type?.getText(sourceFile);
+    const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+    const isExported = ts.isVariableStatement(parentNode) && (parentNode.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
+    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    return {
+      name,
+      parameters,
+      returnType,
+      isAsync,
+      isExported,
+      complexity: this.calculateComplexity(node),
+      startLine: startLine + 1,
+      endLine: endLine + 1,
+      body: node.body?.getText(sourceFile)
+    };
+  }
+  extractClassInfo(node, sourceFile) {
+    const name = node.name?.getText(sourceFile) || "AnonymousClass";
+    const methods = [];
+    const properties = [];
+    let hasConstructor = false;
+    let constructorParams;
+    const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    for (const member of node.members) {
+      if (ts.isMethodDeclaration(member)) {
+        const methodName = member.name.getText(sourceFile);
+        const parameters = this.extractParameters(member.parameters, sourceFile);
+        const returnType = member.type?.getText(sourceFile);
+        const isAsync = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(
+          member.getStart(sourceFile)
+        );
+        const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(member.getEnd());
+        methods.push({
+          name: methodName,
+          parameters,
+          returnType,
+          isAsync,
+          isExported: false,
+          complexity: this.calculateComplexity(member),
+          startLine: startLine + 1,
+          endLine: endLine + 1,
+          body: member.body?.getText(sourceFile)
+        });
+      } else if (ts.isConstructorDeclaration(member)) {
+        hasConstructor = true;
+        constructorParams = this.extractParameters(member.parameters, sourceFile);
+      } else if (ts.isPropertyDeclaration(member)) {
+        const propName = member.name.getText(sourceFile);
+        const propType = member.type?.getText(sourceFile);
+        const isPrivate = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword) ?? false;
+        const isReadonly = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
+        properties.push({
+          name: propName,
+          type: propType,
+          isPrivate,
+          isReadonly
+        });
+      }
     }
-    return `// Coverage test for ${lineRange} in ${moduleName}
-import { ${funcName} } from '${importPath}';
-
-describe('${moduleName} coverage', () => {
-  describe('${lineRange}', () => {
-    it('should execute code path covering ${lineRange}', () => {
-      // Arrange: Set up test inputs to reach uncovered lines
-      const testInput = undefined; // Replace with appropriate input
-
-      // Act: Execute the code path
-      const result = ${funcName}(testInput);
-
-      // Assert: Verify the code was reached and behaves correctly
-      expect(result).toBeDefined();
-    });
-
-    it('should handle edge case for ${lineRange}', () => {
-      // Arrange: Set up edge case input
-      const edgeCaseInput = null;
-
-      // Act & Assert: Verify edge case handling
-      expect(() => ${funcName}(edgeCaseInput)).not.toThrow();
-    });
-  });
-});
-`;
+    return {
+      name,
+      methods,
+      properties,
+      isExported,
+      hasConstructor,
+      constructorParams
+    };
+  }
+  extractParameters(params, sourceFile) {
+    return params.map((param) => ({
+      name: param.name.getText(sourceFile),
+      type: param.type?.getText(sourceFile),
+      optional: param.questionToken !== void 0,
+      defaultValue: param.initializer?.getText(sourceFile)
+    }));
+  }
+  calculateComplexity(node) {
+    let complexity = 1;
+    const visit = (n) => {
+      switch (n.kind) {
+        case ts.SyntaxKind.IfStatement:
+        case ts.SyntaxKind.ForStatement:
+        case ts.SyntaxKind.ForInStatement:
+        case ts.SyntaxKind.ForOfStatement:
+        case ts.SyntaxKind.WhileStatement:
+        case ts.SyntaxKind.DoStatement:
+        case ts.SyntaxKind.CaseClause:
+        case ts.SyntaxKind.CatchClause:
+        case ts.SyntaxKind.ConditionalExpression:
+          complexity++;
+          break;
+        case ts.SyntaxKind.BinaryExpression: {
+          const binary = n;
+          if (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || binary.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+            complexity++;
+          }
+          break;
+        }
+      }
+      ts.forEachChild(n, visit);
+    };
+    ts.forEachChild(node, visit);
+    return complexity;
+  }
+  // ============================================================================
+  // Private Helper Methods - Utility Functions
+  // ============================================================================
+  async findApplicablePatterns(sourceFile, requestedPatterns) {
+    const patterns = [];
+    for (const patternName of requestedPatterns) {
+      const stored = await this.memory.get(`pattern:${patternName}`);
+      if (stored) {
+        patterns.push(stored);
+      }
+    }
+    const extension = sourceFile.split(".").pop() || "";
+    const searchResults = await this.memory.search(`pattern:*:${extension}`, 5);
+    for (const key of searchResults) {
+      const pattern = await this.memory.get(key);
+      if (pattern && !patterns.some((p) => p.id === pattern.id)) {
+        patterns.push(pattern);
+      }
+    }
+    return patterns;
   }
   groupConsecutiveLines(lines) {
     if (lines.length === 0) return [];
@@ -14119,12 +15254,6 @@ describe('${moduleName} coverage', () => {
     const estimatedCoverage = Math.min(target, Math.max(0, diminishedEstimate));
     return Math.round(estimatedCoverage * 10) / 10;
   }
-  camelCase(str) {
-    return str.replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase()).replace(/^./, (chr) => chr.toLowerCase());
-  }
-  pascalCase(str) {
-    return str.replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase()).replace(/^./, (chr) => chr.toUpperCase());
-  }
   async storeGenerationMetadata(tests, patterns) {
     const metadata = {
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -14136,10 +15265,12 @@ describe('${moduleName} coverage', () => {
       `test-generation:metadata:${Date.now()}`,
       metadata,
       { namespace: "test-generation", ttl: 86400 * 7 }
-      // 7 days
     );
   }
 };
+function createTestGeneratorService(memory, config = {}) {
+  return new TestGeneratorService({ memory }, config);
+}
 
 // src/domains/test-generation/services/pattern-matcher.ts
 import { v4 as uuidv45 } from "uuid";
@@ -14310,7 +15441,7 @@ var OllamaClient = class {
 };
 
 // src/shared/embeddings/embedding-cache.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 var EmbeddingCache = class {
   cache;
   maxSize;
@@ -14326,7 +15457,7 @@ var EmbeddingCache = class {
    * Generate SHA-256 hash of content for cache key
    */
   hashContent(content, model) {
-    return createHash("sha256").update(`${model}:${content}`).digest("hex");
+    return createHash2("sha256").update(`${model}:${content}`).digest("hex");
   }
   /**
    * Get cached embedding if available
@@ -17889,7 +19020,7 @@ var DecisionTransformerAlgorithm = class extends BaseRLAlgorithm {
   }
 };
 
-// src/domains/test-generation/coherence-gate.ts
+// src/domains/test-generation/services/coherence-gate-service.ts
 var DEFAULT_COHERENCE_GATE_CONFIG = {
   enabled: true,
   coherenceThreshold: 0.1,
@@ -18297,7 +19428,7 @@ var TestGenerationCoordinator = class {
     this.agentCoordinator = agentCoordinator;
     this.coherenceService = coherenceService;
     this.config = { ...DEFAULT_CONFIG3, ...config };
-    this.testGenerator = new TestGeneratorService(memory);
+    this.testGenerator = createTestGeneratorService(memory);
     this.patternMatcher = new PatternMatcherService(memory);
     if (this.config.enableCoherenceGate && coherenceService) {
       this.coherenceGate = createTestGenerationCoherenceGate(
@@ -19159,7 +20290,7 @@ var TestGenerationPlugin = class extends BaseDomainPlugin {
   // Lifecycle Methods
   // ============================================================================
   async onInitialize() {
-    this.testGenerator = new TestGeneratorService(
+    this.testGenerator = createTestGeneratorService(
       this.memory,
       this.pluginConfig.testGenerator
     );
@@ -19175,7 +20306,7 @@ var TestGenerationPlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       agents: { total: 0, active: 0, idle: 0, failed: 0 },
       lastActivity: /* @__PURE__ */ new Date(),
       errors: []
@@ -21332,7 +22463,46 @@ var RetryHandlerService = class {
   }
 };
 
-// src/domains/test-execution/test-prioritization-types.ts
+// src/domains/test-execution/types/e2e-step.types.ts
+var E2EStepType = {
+  /** Navigate to a URL */
+  NAVIGATE: "navigate",
+  /** Click an element */
+  CLICK: "click",
+  /** Type text into an element */
+  TYPE: "type",
+  /** Wait for a condition */
+  WAIT: "wait",
+  /** Make an assertion */
+  ASSERT: "assert",
+  /** Take a screenshot */
+  SCREENSHOT: "screenshot",
+  /** Perform accessibility check */
+  A11Y_CHECK: "a11y-check"
+};
+function isNavigateStep(step) {
+  return step.type === E2EStepType.NAVIGATE;
+}
+function isClickStep(step) {
+  return step.type === E2EStepType.CLICK;
+}
+function isTypeStep(step) {
+  return step.type === E2EStepType.TYPE;
+}
+function isWaitStep(step) {
+  return step.type === E2EStepType.WAIT;
+}
+function isAssertStep(step) {
+  return step.type === E2EStepType.ASSERT;
+}
+function isScreenshotStep(step) {
+  return step.type === E2EStepType.SCREENSHOT;
+}
+function isA11yCheckStep(step) {
+  return step.type === E2EStepType.A11Y_CHECK;
+}
+
+// src/domains/test-execution/interfaces.ts
 function mapToFeatures(test) {
   const failureProbability = Math.min(1, test.failureRate ?? 0);
   const flakiness = Math.min(1, test.flakinessScore ?? 0);
@@ -23975,45 +25145,6 @@ async function getBrowserClientForUseCase(useCase) {
   return createBrowserClient({ useCase });
 }
 
-// src/domains/test-execution/types/e2e-step.types.ts
-var E2EStepType = {
-  /** Navigate to a URL */
-  NAVIGATE: "navigate",
-  /** Click an element */
-  CLICK: "click",
-  /** Type text into an element */
-  TYPE: "type",
-  /** Wait for a condition */
-  WAIT: "wait",
-  /** Make an assertion */
-  ASSERT: "assert",
-  /** Take a screenshot */
-  SCREENSHOT: "screenshot",
-  /** Perform accessibility check */
-  A11Y_CHECK: "a11y-check"
-};
-function isNavigateStep(step) {
-  return step.type === E2EStepType.NAVIGATE;
-}
-function isClickStep(step) {
-  return step.type === E2EStepType.CLICK;
-}
-function isTypeStep(step) {
-  return step.type === E2EStepType.TYPE;
-}
-function isWaitStep(step) {
-  return step.type === E2EStepType.WAIT;
-}
-function isAssertStep(step) {
-  return step.type === E2EStepType.ASSERT;
-}
-function isScreenshotStep(step) {
-  return step.type === E2EStepType.SCREENSHOT;
-}
-function isA11yCheckStep(step) {
-  return step.type === E2EStepType.A11Y_CHECK;
-}
-
 // src/domains/test-execution/services/e2e-runner.ts
 var DEFAULT_E2E_RUNNER_CONFIG = {
   defaultStepTimeout: 3e4,
@@ -26197,7 +27328,7 @@ var TestExecutionPlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       lastActivity: /* @__PURE__ */ new Date()
     });
   }
@@ -28743,7 +29874,7 @@ var CoverageAnalysisPlugin = class _CoverageAnalysisPlugin extends BaseDomainPlu
   async onInitialize() {
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       lastActivity: /* @__PURE__ */ new Date()
     });
   }
@@ -29590,251 +30721,6 @@ var typescriptParser = new TypeScriptParser();
 // src/shared/io/file-reader.ts
 import * as fs5 from "node:fs/promises";
 import * as path5 from "node:path";
-
-// src/mcp/security/cve-prevention.ts
-var PATH_TRAVERSAL_PATTERNS = [
-  /\.\./,
-  // Basic traversal
-  /%2e%2e/i,
-  // URL encoded ..
-  /%252e%252e/i,
-  // Double URL encoded
-  /\.\.%2f/i,
-  // Mixed encoding
-  /%2f\.\./i,
-  // Forward slash + ..
-  /\.\.%5c/i,
-  // Backslash + ..
-  /\.\.\\/,
-  // Windows backslash traversal
-  /%c0%ae/i,
-  // UTF-8 overlong encoding
-  /%c0%2f/i,
-  // UTF-8 overlong /
-  /%c1%9c/i,
-  // UTF-8 overlong \
-  /\0/,
-  // Null byte injection
-  /%00/i
-  // URL encoded null
-];
-var DANGEROUS_PATH_COMPONENTS = [
-  /^\/etc\//i,
-  /^\/proc\//i,
-  /^\/sys\//i,
-  /^\/dev\//i,
-  /^\/root\//i,
-  /^\/home\/.+\/\./i,
-  /^[A-Z]:\\Windows/i,
-  /^[A-Z]:\\System/i,
-  /^[A-Z]:\\Users\\.+\\AppData/i
-];
-function validatePath(path16, options = {}) {
-  const {
-    basePath = "",
-    allowAbsolute = false,
-    allowedExtensions = [],
-    deniedExtensions = [".exe", ".bat", ".cmd", ".sh", ".ps1", ".dll", ".so"],
-    maxDepth = 10,
-    maxLength = 4096
-  } = options;
-  if (path16.length > maxLength) {
-    return {
-      valid: false,
-      error: `Path exceeds maximum length of ${maxLength}`,
-      riskLevel: "medium"
-    };
-  }
-  for (const pattern of PATH_TRAVERSAL_PATTERNS) {
-    if (pattern.test(path16)) {
-      return {
-        valid: false,
-        error: "Path traversal attempt detected",
-        riskLevel: "critical"
-      };
-    }
-  }
-  if (!allowAbsolute && (path16.startsWith("/") || /^[A-Z]:/i.test(path16))) {
-    return {
-      valid: false,
-      error: "Absolute paths are not allowed",
-      riskLevel: "high"
-    };
-  }
-  for (const pattern of DANGEROUS_PATH_COMPONENTS) {
-    if (pattern.test(path16)) {
-      return {
-        valid: false,
-        error: "Access to system paths is not allowed",
-        riskLevel: "critical"
-      };
-    }
-  }
-  const normalizedPath = normalizePath(path16);
-  if (normalizedPath.includes("..")) {
-    return {
-      valid: false,
-      error: "Path traversal detected after normalization",
-      riskLevel: "critical"
-    };
-  }
-  const depth = normalizedPath.split("/").filter(Boolean).length;
-  if (depth > maxDepth) {
-    return {
-      valid: false,
-      error: `Path depth exceeds maximum of ${maxDepth}`,
-      riskLevel: "low"
-    };
-  }
-  const ext = getExtension(normalizedPath);
-  if (ext) {
-    const extWithDot = `.${ext.toLowerCase()}`;
-    const extWithoutDot = ext.toLowerCase();
-    if (deniedExtensions.length > 0) {
-      const isDenied = deniedExtensions.some(
-        (denied) => denied.toLowerCase() === extWithDot || denied.toLowerCase() === extWithoutDot
-      );
-      if (isDenied) {
-        return {
-          valid: false,
-          error: `File extension '${ext}' is not allowed`,
-          riskLevel: "high"
-        };
-      }
-    }
-    if (allowedExtensions.length > 0) {
-      const isAllowed = allowedExtensions.some(
-        (allowed) => allowed.toLowerCase() === extWithDot || allowed.toLowerCase() === extWithoutDot
-      );
-      if (!isAllowed) {
-        return {
-          valid: false,
-          error: `File extension '${ext}' is not in allowed list`,
-          riskLevel: "medium"
-        };
-      }
-    }
-  }
-  const finalPath = basePath ? joinPathsAbsolute(basePath, normalizedPath) : normalizedPath;
-  const normalizedBase = basePath.startsWith("/") ? `/${normalizePath(basePath)}` : normalizePath(basePath);
-  if (basePath && !finalPath.startsWith(normalizedBase)) {
-    return {
-      valid: false,
-      error: "Path escapes base directory",
-      riskLevel: "critical"
-    };
-  }
-  return {
-    valid: true,
-    normalizedPath: finalPath,
-    riskLevel: "none"
-  };
-}
-function normalizePath(path16) {
-  let normalized = path16.replace(/\\/g, "/");
-  normalized = normalized.replace(/\/+/g, "/");
-  const parts = normalized.split("/");
-  const result = [];
-  for (const part of parts) {
-    if (part === "." || part === "") {
-      continue;
-    }
-    if (part === "..") {
-      if (result.length > 0 && result[result.length - 1] !== "..") {
-        result.pop();
-      }
-    } else {
-      result.push(part);
-    }
-  }
-  return result.join("/");
-}
-function joinPathsAbsolute(...paths) {
-  if (paths.length === 0) return "";
-  const isAbsolute4 = paths[0].startsWith("/");
-  const result = paths.map((p) => {
-    while (p.startsWith("/")) p = p.slice(1);
-    while (p.endsWith("/")) p = p.slice(0, -1);
-    return p;
-  }).filter(Boolean).join("/");
-  return isAbsolute4 ? `/${result}` : result;
-}
-function getExtension(path16) {
-  const match = path16.match(/\.([^./\\]+)$/);
-  return match ? match[1] : null;
-}
-var SHELL_METACHARACTERS = /[|;&$`<>{}[\]!#*?~]/g;
-var DEFAULT_ALLOWED_COMMANDS = [
-  "ls",
-  "cat",
-  "echo",
-  "grep",
-  "find",
-  "head",
-  "tail",
-  "wc",
-  "npm",
-  "node",
-  "yarn",
-  "pnpm",
-  "git",
-  "jest",
-  "vitest",
-  "playwright"
-];
-var BLOCKED_COMMAND_PATTERNS = [
-  /;/,
-  // Command chaining with semicolon
-  /&&/,
-  // Command chaining with AND
-  /\|\|/,
-  // Command chaining with OR
-  /\|/,
-  // Piping
-  /`.*`/,
-  // Backtick command substitution
-  /\$\(.*\)/,
-  // $() command substitution
-  />\s*\/dev\/sd/i,
-  // Writing to block devices
-  />\s*\/etc\//i
-  // Writing to /etc
-];
-function validateCommand(command, allowedCommands = DEFAULT_ALLOWED_COMMANDS) {
-  const blockedPatterns = [];
-  for (const pattern of BLOCKED_COMMAND_PATTERNS) {
-    if (pattern.test(command)) {
-      blockedPatterns.push(pattern.source);
-    }
-  }
-  if (blockedPatterns.length > 0) {
-    return {
-      valid: false,
-      error: "Command contains blocked patterns",
-      blockedPatterns
-    };
-  }
-  const parts = command.trim().split(/\s+/);
-  const baseCommand = parts[0].split("/").pop() || "";
-  if (!allowedCommands.includes(baseCommand)) {
-    return {
-      valid: false,
-      error: `Command '${baseCommand}' is not in the allowed list`,
-      blockedPatterns: []
-    };
-  }
-  const sanitizedParts = parts.map((part, i) => {
-    if (i === 0) return part;
-    return part.replace(SHELL_METACHARACTERS, "");
-  });
-  return {
-    valid: true,
-    sanitizedCommand: sanitizedParts.join(" "),
-    blockedPatterns: []
-  };
-}
-
-// src/shared/io/file-reader.ts
 var FileReadError = class extends Error {
   constructor(message, filePath, code, cause) {
     super(message);
@@ -34313,7 +35199,7 @@ var QualityAssessmentPlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       agents: { total: 0, active: 0, idle: 0, failed: 0 },
       lastActivity: /* @__PURE__ */ new Date(),
       errors: []
@@ -37213,7 +38099,7 @@ var DefectIntelligencePlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       agents: { total: 0, active: 0, idle: 0, failed: 0 },
       lastActivity: /* @__PURE__ */ new Date(),
       errors: []
@@ -39927,7 +40813,7 @@ var RequirementsValidationPlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       agents: { total: 0, active: 0, idle: 0, failed: 0 },
       lastActivity: /* @__PURE__ */ new Date(),
       errors: []
@@ -45803,7 +46689,7 @@ var CodeIntelligencePlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       agents: { total: 0, active: 0, idle: 0, failed: 0 },
       lastActivity: /* @__PURE__ */ new Date(),
       errors: []
@@ -47182,7 +48068,7 @@ var DEFAULT_CONFIG25 = {
   dastMaxDepth: 5,
   dastActiveScanning: false
 };
-var SQL_INJECTION_PATTERNS = [
+var SQL_INJECTION_PATTERNS2 = [
   {
     id: "sqli-string-concat",
     pattern: /query\s*\(\s*['"`].*\+.*['"`]\s*\)/g,
@@ -47590,7 +48476,7 @@ var AUTH_PATTERNS = [
   }
 ];
 var ALL_SECURITY_PATTERNS = [
-  ...SQL_INJECTION_PATTERNS,
+  ...SQL_INJECTION_PATTERNS2,
   ...XSS_PATTERNS,
   ...SECRET_PATTERNS,
   ...PATH_TRAVERSAL_PATTERNS2,
@@ -53300,7 +54186,7 @@ var SecurityCompliancePlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       agents: { total: 0, active: 0, idle: 0, failed: 0 },
       lastActivity: /* @__PURE__ */ new Date(),
       errors: []
@@ -57429,7 +58315,7 @@ var ContractTestingPlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       agents: { total: 0, active: 0, idle: 0, failed: 0 },
       lastActivity: /* @__PURE__ */ new Date(),
       errors: []
@@ -62503,7 +63389,7 @@ var VisualAccessibilityPlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       agents: { total: 0, active: 0, idle: 0, failed: 0 },
       lastActivity: /* @__PURE__ */ new Date(),
       errors: []
@@ -66313,7 +67199,7 @@ var ChaosResiliencePlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       agents: { total: 0, active: 0, idle: 0, failed: 0 },
       lastActivity: /* @__PURE__ */ new Date(),
       errors: []
@@ -70530,7 +71416,7 @@ var LearningOptimizationPlugin = class extends BaseDomainPlugin {
     );
     await this.coordinator.initialize();
     this.updateHealth({
-      status: "healthy",
+      status: "idle",
       agents: { total: 0, active: 0, idle: 0, failed: 0 },
       lastActivity: /* @__PURE__ */ new Date(),
       errors: []
@@ -73527,9 +74413,13 @@ var MinCutHealthMonitor = class {
   /**
    * Issue #205 fix: Check if topology is empty/fresh (no agents spawned yet)
    * An empty topology is normal for a fresh install - not a critical issue
+   *
+   * Note: Domain coordinator vertices and workflow edges are always created,
+   * so we check for actual agent vertices instead of raw counts.
    */
   isEmptyTopology() {
-    return this.graph.vertexCount === 0 || this.graph.edgeCount === 0;
+    const agentVertices = this.graph.getVerticesByType("agent");
+    return agentVertices.length === 0;
   }
   /**
    * Perform health check
@@ -74655,9 +75545,13 @@ var QueenMinCutBridge = class {
   }
   /**
    * Issue #205 fix: Check if topology is empty/fresh (no agents spawned yet)
+   *
+   * Note: Domain coordinator vertices and workflow edges are always created,
+   * so we check for actual agent vertices instead of raw counts.
    */
   isEmptyTopology() {
-    return this.graph.vertexCount === 0 || this.graph.edgeCount === 0;
+    const agentVertices = this.graph.getVerticesByType("agent");
+    return agentVertices.length === 0;
   }
   /**
    * Convert MinCut alerts to Queen health issues
@@ -76979,7 +77873,7 @@ import * as path11 from "path";
 // src/coordination/result-saver.ts
 import * as fs9 from "fs/promises";
 import * as path10 from "path";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 var TEST_FILE_PATTERNS = {
   typescript: {
     jest: ".test.ts",
@@ -77406,7 +78300,7 @@ ${data.recommendations.length === 0 ? "No recommendations - all quality gates pa
   async createFileEntry(filePath, format) {
     const content = await fs9.readFile(filePath);
     const stats = await fs9.stat(filePath);
-    const checksum = createHash2("sha256").update(content).digest("hex").slice(0, 16);
+    const checksum = createHash3("sha256").update(content).digest("hex").slice(0, 16);
     return {
       path: filePath,
       format,
@@ -77501,7 +78395,7 @@ function getSecurityScanner(memory) {
 }
 function getTestGenerator(memory) {
   if (!testGenerator) {
-    testGenerator = new TestGeneratorService(memory);
+    testGenerator = createTestGeneratorService(memory);
   }
   return testGenerator;
 }
@@ -83911,11 +84805,12 @@ var TestGenerateTool = class extends MCPToolBase {
   testGeneratorService = null;
   /**
    * Initialize or get the test generator service with persistent storage
+   * Uses factory function for proper dependency injection
    */
   async getService() {
     if (!this.testGeneratorService) {
       const memory = await getSharedMemoryBackend();
-      this.testGeneratorService = new TestGeneratorService(
+      this.testGeneratorService = createTestGeneratorService(
         memory,
         {
           defaultFramework: "vitest",
@@ -94449,19 +95344,16 @@ function createSpectralEngineWrapper(rawEngine) {
     return indexToString.get(idx) ?? `unknown-${idx}`;
   };
   const buildGraph = () => ({
-    nodes: Array.from(nodes).map((id) => ({
-      id: getOrCreateIndex(id),
-      // Numeric index
-      label: id
-      // Original string ID as label
-    })),
-    edges: edges.map((e) => ({
-      source: getOrCreateIndex(e.source),
-      // Convert to numeric
-      target: getOrCreateIndex(e.target),
-      // Convert to numeric
-      weight: e.weight
-    }))
+    n: nodes.size,
+    // Number of nodes
+    edges: edges.map((e) => [
+      getOrCreateIndex(e.source),
+      // source as numeric index
+      getOrCreateIndex(e.target),
+      // target as numeric index
+      e.weight
+      // weight
+    ])
   });
   return {
     add_node(id) {
@@ -94482,19 +95374,54 @@ function createSpectralEngineWrapper(rawEngine) {
       }
     },
     compute_fiedler_value() {
-      const graph = buildGraph();
-      return rawEngine.algebraicConnectivity(graph);
+      if (nodes.size < 2) {
+        return 0;
+      }
+      if (edges.length === 0) {
+        return 0;
+      }
+      try {
+        const graph = buildGraph();
+        const fiedler = rawEngine.algebraicConnectivity(graph);
+        return Number.isFinite(fiedler) && fiedler >= 0 ? fiedler : 0;
+      } catch (error) {
+        console.warn("[SpectralAdapter] algebraicConnectivity failed:", error);
+        return 0;
+      }
     },
     predict_collapse_risk() {
-      const graph = buildGraph();
-      const fiedler = rawEngine.algebraicConnectivity(graph);
-      return Math.max(0, Math.min(1, 1 - fiedler));
+      if (nodes.size < 2) {
+        return 0;
+      }
+      if (edges.length === 0) {
+        return 1;
+      }
+      try {
+        const graph = buildGraph();
+        const fiedler = rawEngine.algebraicConnectivity(graph);
+        const validFiedler = Number.isFinite(fiedler) && fiedler >= 0 ? fiedler : 0;
+        return Math.max(0, Math.min(1, 1 - validFiedler));
+      } catch (error) {
+        console.warn("[SpectralAdapter] predict_collapse_risk failed:", error);
+        return 0.8;
+      }
     },
     get_weak_vertices(count) {
-      const graph = buildGraph();
-      const minCut = rawEngine.predictMinCut(graph);
-      if (!minCut?.vertices) return Array.from(nodes).slice(0, count);
-      return minCut.vertices.slice(0, count).map((idx) => getStringId(idx));
+      if (nodes.size === 0) {
+        return [];
+      }
+      if (edges.length === 0) {
+        return Array.from(nodes).slice(0, count);
+      }
+      try {
+        const graph = buildGraph();
+        const minCut = rawEngine.predictMinCut(graph);
+        if (!minCut?.vertices) return Array.from(nodes).slice(0, count);
+        return minCut.vertices.slice(0, count).map((idx) => getStringId(idx));
+      } catch (error) {
+        console.warn("[SpectralAdapter] predictMinCut failed:", error);
+        return Array.from(nodes).slice(0, count);
+      }
     },
     clear() {
       nodes.clear();
@@ -94620,9 +95547,21 @@ var SpectralAdapter = class {
     if (this.nodes.size < 2) {
       return 0;
     }
-    const fiedlerValue = this.engine.compute_fiedler_value();
-    this.logger.debug("Computed Fiedler value", { fiedlerValue });
-    return fiedlerValue;
+    if (this.edges.length === 0) {
+      return 0;
+    }
+    try {
+      const fiedlerValue = this.engine.compute_fiedler_value();
+      this.logger.debug("Computed Fiedler value", { fiedlerValue });
+      return fiedlerValue;
+    } catch (error) {
+      this.logger.warn("Failed to compute Fiedler value", {
+        error: error instanceof Error ? error.message : String(error),
+        nodeCount: this.nodes.size,
+        edgeCount: this.edges.length
+      });
+      return 0;
+    }
   }
   /**
    * Predict the risk of swarm collapse
@@ -94636,9 +95575,21 @@ var SpectralAdapter = class {
     if (this.nodes.size < 2) {
       return 0;
     }
-    const risk = this.engine.predict_collapse_risk();
-    this.logger.debug("Predicted collapse risk", { risk });
-    return risk;
+    if (this.edges.length === 0) {
+      return 1;
+    }
+    try {
+      const risk = this.engine.predict_collapse_risk();
+      this.logger.debug("Predicted collapse risk", { risk });
+      return risk;
+    } catch (error) {
+      this.logger.warn("Failed to predict collapse risk", {
+        error: error instanceof Error ? error.message : String(error),
+        nodeCount: this.nodes.size,
+        edgeCount: this.edges.length
+      });
+      return 0.8;
+    }
   }
   /**
    * Get the nodes most at risk of causing collapse
@@ -94654,13 +95605,25 @@ var SpectralAdapter = class {
     if (this.nodes.size === 0) {
       return [];
     }
+    if (this.edges.length === 0) {
+      return Array.from(this.nodes).slice(0, count);
+    }
     const safeCount = Math.min(count, this.nodes.size);
-    const weakVertices = this.engine.get_weak_vertices(safeCount);
-    this.logger.debug("Retrieved weak vertices", {
-      requested: count,
-      returned: weakVertices.length
-    });
-    return weakVertices;
+    try {
+      const weakVertices = this.engine.get_weak_vertices(safeCount);
+      this.logger.debug("Retrieved weak vertices", {
+        requested: count,
+        returned: weakVertices.length
+      });
+      return weakVertices;
+    } catch (error) {
+      this.logger.warn("Failed to get weak vertices", {
+        error: error instanceof Error ? error.message : String(error),
+        nodeCount: this.nodes.size,
+        edgeCount: this.edges.length
+      });
+      return Array.from(this.nodes).slice(0, count);
+    }
   }
   /**
    * Analyze a swarm state for collapse risk
@@ -94719,8 +95682,10 @@ var SpectralAdapter = class {
     const successSim = 1 - Math.abs(agent1.successRate - agent2.successRate);
     const typeBonus = agent1.agentType === agent2.agentType ? 0.2 : 0;
     let beliefSim = 0;
-    if (agent1.beliefs.length > 0 && agent2.beliefs.length > 0) {
-      beliefSim = this.computeBeliefOverlap(agent1.beliefs, agent2.beliefs);
+    const beliefs1 = agent1.beliefs ?? [];
+    const beliefs2 = agent2.beliefs ?? [];
+    if (beliefs1.length > 0 && beliefs2.length > 0) {
+      beliefSim = this.computeBeliefOverlap(beliefs1, beliefs2);
     }
     return healthSim * 0.3 + successSim * 0.3 + typeBonus + beliefSim * 0.2;
   }
@@ -96224,8 +97189,27 @@ var CoherenceService = class {
    */
   async predictCollapse(state2) {
     this.ensureInitialized();
+    if (!state2.agents || state2.agents.length === 0) {
+      return {
+        risk: 0,
+        fiedlerValue: 0,
+        collapseImminent: false,
+        weakVertices: [],
+        recommendations: ["No agents to analyze"],
+        durationMs: 0,
+        usedFallback: true
+      };
+    }
     if (this.spectralAdapter?.isInitialized()) {
-      return this.spectralAdapter.analyzeSwarmState(state2);
+      try {
+        return this.spectralAdapter.analyzeSwarmState(state2);
+      } catch (error) {
+        this.logger.warn("Spectral collapse prediction failed, using fallback", {
+          error: error instanceof Error ? error.message : String(error),
+          agentCount: state2.agents.length
+        });
+        return this.predictCollapseWithFallback(state2);
+      }
     }
     return this.predictCollapseWithFallback(state2);
   }
@@ -96392,34 +97376,60 @@ var CoherenceService = class {
   async verifyConsensus(votes) {
     this.ensureInitialized();
     const startTime = Date.now();
+    if (votes.length < 2) {
+      return {
+        isValid: votes.length === 1,
+        confidence: votes.length === 1 ? votes[0].confidence : 0,
+        isFalseConsensus: false,
+        fiedlerValue: votes.length === 1 ? 1 : 0,
+        collapseRisk: 0,
+        recommendation: votes.length === 0 ? "No votes to analyze" : "Single vote - consensus trivially achieved",
+        durationMs: Date.now() - startTime,
+        usedFallback: true
+      };
+    }
     if (this.spectralAdapter?.isInitialized()) {
-      this.spectralAdapter.clear();
-      for (const vote of votes) {
-        this.spectralAdapter.addNode(vote.agentId);
-      }
-      for (let i = 0; i < votes.length; i++) {
-        for (let j = i + 1; j < votes.length; j++) {
-          if (votes[i].verdict === votes[j].verdict) {
-            this.spectralAdapter.addEdge(
-              votes[i].agentId,
-              votes[j].agentId,
-              Math.min(votes[i].confidence, votes[j].confidence)
-            );
+      try {
+        this.spectralAdapter.clear();
+        for (const vote of votes) {
+          this.spectralAdapter.addNode(vote.agentId);
+        }
+        let edgeCount = 0;
+        for (let i = 0; i < votes.length; i++) {
+          for (let j = i + 1; j < votes.length; j++) {
+            if (votes[i].verdict === votes[j].verdict) {
+              this.spectralAdapter.addEdge(
+                votes[i].agentId,
+                votes[j].agentId,
+                Math.min(votes[i].confidence, votes[j].confidence)
+              );
+              edgeCount++;
+            }
           }
         }
+        if (edgeCount === 0) {
+          this.logger.debug("No agreement edges, using fallback consensus");
+          return this.verifyConsensusWithFallback(votes, startTime);
+        }
+        const collapseRisk = this.spectralAdapter.predictCollapseRisk();
+        const fiedlerValue = this.spectralAdapter.computeFiedlerValue();
+        return {
+          isValid: collapseRisk < 0.3 && fiedlerValue > 0.1,
+          confidence: 1 - collapseRisk,
+          isFalseConsensus: fiedlerValue < 0.05,
+          fiedlerValue,
+          collapseRisk,
+          recommendation: collapseRisk > 0.3 ? "Spawn independent reviewer" : "Consensus verified",
+          durationMs: Date.now() - startTime,
+          usedFallback: false
+        };
+      } catch (error) {
+        this.logger.warn("Spectral consensus verification failed, using fallback", {
+          error: error instanceof Error ? error.message : String(error),
+          voteCount: votes.length
+        });
+        return this.verifyConsensusWithFallback(votes, startTime);
       }
-      const collapseRisk = this.spectralAdapter.predictCollapseRisk();
-      const fiedlerValue = this.spectralAdapter.computeFiedlerValue();
-      return {
-        isValid: collapseRisk < 0.3 && fiedlerValue > 0.1,
-        confidence: 1 - collapseRisk,
-        isFalseConsensus: fiedlerValue < 0.05,
-        fiedlerValue,
-        collapseRisk,
-        recommendation: collapseRisk > 0.3 ? "Spawn independent reviewer" : "Consensus verified",
-        durationMs: Date.now() - startTime,
-        usedFallback: false
-      };
     }
     return this.verifyConsensusWithFallback(votes, startTime);
   }
@@ -96561,16 +97571,17 @@ var CoherenceService = class {
    * Convert agent health to a numerical embedding
    */
   agentHealthToEmbedding(health) {
+    const beliefs = health.beliefs ?? [];
     return [
       health.health,
       health.successRate,
       Math.min(1, health.errorCount / 10),
       this.agentTypeToNumber(health.agentType),
-      health.beliefs.length / 10,
+      beliefs.length / 10,
       // Add belief embeddings (first 3 beliefs, padded)
-      ...health.beliefs[0]?.embedding.slice(0, 5) || [0, 0, 0, 0, 0],
-      ...health.beliefs[1]?.embedding.slice(0, 5) || [0, 0, 0, 0, 0],
-      ...health.beliefs[2]?.embedding.slice(0, 5) || [0, 0, 0, 0, 0]
+      ...beliefs[0]?.embedding.slice(0, 5) || [0, 0, 0, 0, 0],
+      ...beliefs[1]?.embedding.slice(0, 5) || [0, 0, 0, 0, 0],
+      ...beliefs[2]?.embedding.slice(0, 5) || [0, 0, 0, 0, 0]
     ];
   }
   /**
@@ -97777,7 +98788,8 @@ var MemoryCoherenceAuditor = class {
   findBroadPatterns(patterns) {
     return patterns.filter((p) => {
       const hasGenericName = /generic|general|common|basic/i.test(p.name);
-      const hasLowSpecificity = p.context.tags.length < 2;
+      const tags = p.context?.tags;
+      const hasLowSpecificity = !tags || tags.length < 2;
       return hasGenericName || hasLowSpecificity;
     }).map((p) => p.id);
   }