mcp-adr-analysis-server 2.10.3 → 2.11.0

package/dist/src/tools/rule-generation-tool.js

@@ -43,101 +43,25 @@ export async function generateRules(args) {
                 }
                 const result = await extractRulesFromAdrs(adrDirectory, existingRules, projectPath);
                 enhancedPrompt = knowledgeContext + result.extractionPrompt;
-                // Execute the rule extraction with AI if enabled, otherwise return prompt
-                const { executePromptWithFallback, formatMCPResponse } = await import('../utils/prompt-execution.js');
-                const executionResult = await executePromptWithFallback(enhancedPrompt, result.instructions, {
-                    temperature: 0.1,
-                    maxTokens: 6000,
-                    systemPrompt: `You are an expert software architect specializing in architectural rule extraction and governance.
-Analyze the provided ADRs to extract actionable architectural rules and governance policies.
-Leverage the provided architectural governance knowledge to create comprehensive, industry-standard rules.
-Focus on creating specific, measurable rules that can be validated automatically.
-Provide clear reasoning for each rule and practical implementation guidance.
-Consider compliance standards, governance frameworks, and architectural best practices.`,
-                    responseFormat: 'text',
-                });
-                if (executionResult.isAIGenerated) {
-                    // AI execution successful - return actual rule extraction results
-                    return formatMCPResponse({
-                        ...executionResult,
-                        content: `# ADR-Based Rule Generation Results (GKP Enhanced)
-
-## Enhancement Features
-- **Generated Knowledge Prompting**: ${knowledgeEnhancement ? '✅ Enabled' : '❌ Disabled'}
-- **Enhanced Mode**: ${enhancedMode ? '✅ Enabled' : '❌ Disabled'}
-- **Knowledge Domains**: Governance frameworks, software architecture, compliance standards
-
-## Analysis Information
-- **ADR Directory**: ${adrDirectory}
-- **Existing Rules**: ${existingRules?.length || 0} rules
-- **Output Format**: ${outputFormat.toUpperCase()}
-
-${knowledgeContext
-                            ? `## Applied Governance Knowledge
-
-${knowledgeContext}
-`
-                            : ''}
-
-## AI Rule Extraction Results
-
-${executionResult.content}
-
-## Next Steps
-
-Based on the extracted rules:
-
-1. **Review Generated Rules**: Examine each rule for accuracy and completeness
-2. **Save Rule Set**: Create ${outputFormat.toUpperCase()} files for the extracted rules
-3. **Implement Validation**: Set up automated rule checking in your CI/CD pipeline
-4. **Team Training**: Share rules with development team for adoption
-5. **Monitor Compliance**: Track rule adherence and adjust as needed
-
-## Integration Commands
-
-To validate code against these rules, use:
-\`\`\`json
-{
-  "tool": "validate_rules",
-  "args": {
-    "filePath": "path/to/code/file.js",
-    "rules": [extracted rules from above]
-  }
-}
-\`\`\`
-
-To create a machine-readable rule set:
-\`\`\`json
-{
-  "tool": "create_rule_set",
-  "args": {
-    "name": "ADR-Based Architectural Rules",
-    "adrRules": [extracted rules from above],
-    "outputFormat": "${outputFormat}"
-  }
-}
-\`\`\`
-`,
-                    });
-                }
-                else {
-                    // Fallback to prompt-only mode
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `# Rule Generation: ADR-Based Rules (GKP Enhanced)
+                // CE-MCP: return prompt text for the host LLM. The directive path in
+                // mcp-adr-analysis-server.ts intercepts this tool before it reaches here
+                // when CE-MCP mode is active; this return serves legacy/prompt-only mode.
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# Rule Generation: ADR-Based Rules (GKP Enhanced)
 
 ## Enhancement Status
 - **Generated Knowledge Prompting**: ${knowledgeEnhancement ? '✅ Applied' : '❌ Disabled'}
 - **Enhanced Mode**: ${enhancedMode ? '✅ Applied' : '❌ Disabled'}
 
 ${knowledgeContext
-                                    ? `## Governance Knowledge Context
+                                ? `## Governance Knowledge Context
 
 ${knowledgeContext}
 `
-                                    : ''}
+                                : ''}
 
 ${result.instructions}
 
@@ -153,10 +77,9 @@ ${enhancedPrompt}
 4. **Save rules** in ${outputFormat.toUpperCase()} format using the rule format utilities
 5. **Integrate with validation tools** for automated compliance checking
 `,
-                            },
-                        ],
-                    };
-                }
+                        },
+                    ],
+                };
             }
             case 'patterns': {
                 let enhancedPrompt = '';
@@ -251,91 +174,12 @@ ${enhancedPrompt}
                 const existingRuleNames = existingRules?.map(r => r.name);
                 const result = await generateRulesFromPatterns(projectPath, existingRuleNames);
                 enhancedPrompt = knowledgeContext + patternImplementationContext + result.generationPrompt;
-                // Execute the pattern-based rule generation with AI if enabled, otherwise return prompt
-                const { executePromptWithFallback, formatMCPResponse } = await import('../utils/prompt-execution.js');
-                const executionResult = await executePromptWithFallback(enhancedPrompt, result.instructions, {
-                    temperature: 0.1,
-                    maxTokens: 6000,
-                    systemPrompt: `You are an expert software architect specializing in code pattern analysis and rule generation.
-Analyze the provided codebase to identify consistent patterns and generate actionable architectural rules.
-Leverage the provided design pattern and code quality knowledge to create comprehensive, industry-standard rules.
-Focus on creating rules that enforce consistency, quality, and maintainability based on observed patterns.
-Consider established design patterns, code quality metrics, and architectural best practices.
-Provide confidence scores and practical implementation guidance for each rule.`,
-                    responseFormat: 'text',
-                });
-                if (executionResult.isAIGenerated) {
-                    // AI execution successful - return actual pattern-based rule generation results
-                    return formatMCPResponse({
-                        ...executionResult,
-                        content: `# Pattern-Based Rule Generation Results (Enhanced with Smart Code Linking)
-
-## Enhancement Features
-- **Smart Code Linking**: ${patternImplementationContext ? '✅ Active' : '❌ No patterns found'}
-- **Generated Knowledge Prompting**: ${knowledgeEnhancement ? '✅ Enabled' : '❌ Disabled'}
-- **Enhanced Mode**: ${enhancedMode ? '✅ Enabled' : '❌ Disabled'}
-- **Knowledge Domains**: Design patterns, code quality, software architecture
-
-## Analysis Information
-- **Project Path**: ${projectPath}
-- **Existing Rules**: ${existingRules?.length || 0} rules
-- **Output Format**: ${outputFormat.toUpperCase()}
-
-${patternImplementationContext ? `${patternImplementationContext}` : ''}
-
-${knowledgeContext
-                            ? `## Applied Pattern Knowledge
-
-${knowledgeContext}
-`
-                            : ''}
-
-## AI Pattern Analysis Results
-
-${executionResult.content}
-
-## Next Steps
-
-Based on the pattern analysis:
-
-1. **Review Generated Rules**: Examine each rule for relevance and accuracy
-2. **Validate Patterns**: Confirm patterns are representative of desired practices
-3. **Implement High-Confidence Rules**: Start with rules that have high confidence scores
-4. **Combine with ADR Rules**: Merge with ADR-extracted rules for comprehensive coverage
-5. **Set Up Validation**: Implement automated checking for pattern-based rules
-
-## Pattern-Based Benefits
-
-These rules offer:
-- **Consistency Enforcement**: Based on actual project patterns
-- **Team Alignment**: Reflects current team practices
-- **Gradual Improvement**: Incremental quality improvements
-- **Automated Detection**: High automatability for validation tools
-
-## Integration Commands
-
-To create a comprehensive rule set combining patterns and ADRs:
-\`\`\`json
-{
-  "tool": "generate_rules",
-  "args": {
-    "source": "both",
-    "projectPath": "${projectPath}",
-    "adrDirectory": "${adrDirectory}",
-    "outputFormat": "${outputFormat}"
-  }
-}
-\`\`\`
-`,
-                    });
-                }
-                else {
-                    // Fallback to prompt-only mode
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `# Rule Generation: Pattern-Based Rules (Enhanced with Smart Code Linking)
+                // CE-MCP: return prompt text directly; directive intercepts in CE-MCP mode.
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# Rule Generation: Pattern-Based Rules (Enhanced with Smart Code Linking)
 
 ## Enhancement Status
 - **Smart Code Linking**: ${patternImplementationContext ? '✅ Pattern implementations discovered' : '❌ No patterns found'}
@@ -343,286 +187,36 @@ To create a comprehensive rule set combining patterns and ADRs:
 - **Enhanced Mode**: ${enhancedMode ? '✅ Applied' : '❌ Disabled'}
 
 ${patternImplementationContext
-                                    ? `${patternImplementationContext}
+                                ? `${patternImplementationContext}
 
 `
-                                    : ''}${knowledgeContext
-                                    ? `## Governance Knowledge Context
+                                : ''}${knowledgeContext
+                                ? `## Governance Knowledge Context
 
 ${knowledgeContext}
 `
-                                    : ''}
+                                : ''}
 
 ${result.instructions}
 
 ## Enhanced AI Analysis Prompt
 
 ${enhancedPrompt}
-
-## Next Steps
-
-1. **Submit the enhanced prompt** to an AI agent for comprehensive pattern analysis
-2. **Parse the JSON response** to get generated rules and pattern metrics
-3. **Review pattern-based rules** using the discovered implementation context
-4. **Combine with ADR-extracted rules** for comprehensive rule set
-5. **Implement validation** for high-confidence pattern rules
-
-## Pattern Implementation Benefits
-
-The Smart Code Linking enhancement provides:
-- **Real Examples**: Rules based on actual pattern implementations found in your codebase
-- **Context-Aware**: Better understanding of how patterns are actually used
-- **Higher Confidence**: Rules validated against existing code patterns
-- **Team Alignment**: Rules that reflect current team practices and implementations
 `,
-                            },
-                        ],
-                    };
-                }
+                        },
+                    ],
+                };
             }
             case 'both': {
-                let comprehensiveKnowledgeContext = '';
-                let comprehensivePatternContext = '';
-                // Smart Code Linking - comprehensive pattern and ADR implementation discovery
-                try {
-                    // Find all code and documentation files
-                    const findResult = await findFiles(projectPath, [
-                        '**/*.{ts,js,jsx,tsx,py,java,cs,go,rs,rb,php,swift,kt,scala,c,cpp}',
-                        '**/*.{md,adoc,rst}',
-                        '!**/node_modules/**',
-                        '!**/dist/**',
-                        '!**/build/**',
-                        '!**/target/**',
-                    ]);
-                    if (findResult.files.length > 0) {
-                        // Use Smart Code Linking to find comprehensive architectural patterns and ADR implementations
-                        const comprehensiveContext = [
-                            'architectural decisions',
-                            'design patterns',
-                            'architectural patterns',
-                            'software architecture',
-                            'architectural governance',
-                            'code standards',
-                            'best practices',
-                            'quality attributes',
-                            'security patterns',
-                            'performance patterns',
-                            'scalability patterns',
-                            'maintainability',
-                            'testability',
-                            'deployment patterns',
-                            'integration patterns',
-                        ].join(' ');
-                        const relatedCodeResult = await findRelatedCode('comprehensive-architecture-analysis', comprehensiveContext, projectPath, {
-                            useAI: true,
-                            maxFiles: 30,
-                            includeContent: false,
-                        });
-                        if (relatedCodeResult.relatedFiles.length > 0) {
-                            // Categorize files by type for better analysis
-                            const codeFiles = relatedCodeResult.relatedFiles.filter(f => f.extension?.match(/\.(ts|js|jsx|tsx|py|java|cs|go|rs|rb|php|swift|kt|scala|c|cpp)$/));
-                            const docFiles = relatedCodeResult.relatedFiles.filter(f => f.extension?.match(/\.(md|adoc|rst)$/));
-                            comprehensivePatternContext = [
-                                '',
-                                '## 🔗 Comprehensive Architecture Discovery',
-                                '',
-                                `Found **${relatedCodeResult.relatedFiles.length}** files relevant to architectural rule generation:`,
-                                '',
-                                `### Code Implementation Files (${codeFiles.length})`,
-                                ...codeFiles.slice(0, 12).map((file, index) => `${index + 1}. **${file.path}**`),
-                                codeFiles.length > 12 ? `*Showing top 12 of ${codeFiles.length} code files*` : '',
-                                '',
-                                docFiles.length > 0
-                                    ? [
-                                        `### Documentation Files (${docFiles.length})`,
-                                        ...docFiles
-                                            .slice(0, 8)
-                                            .map((file, index) => `${index + 1}. **${file.path}**`),
-                                        docFiles.length > 8
-                                            ? `*Showing top 8 of ${docFiles.length} documentation files*`
-                                            : '',
-                                        '',
-                                    ].join('\n')
-                                    : '',
-                                `**Overall Analysis Confidence**: ${(relatedCodeResult.confidence * 100).toFixed(0)}%`,
-                                `**Architectural Keywords**: ${relatedCodeResult.keywords?.slice(0, 12).join(', ') || 'N/A'}`,
-                                '',
-                                '## Technology Stack Analysis',
-                                ...Object.entries(relatedCodeResult.relatedFiles.reduce((acc, file) => {
-                                    const ext = file.extension || 'unknown';
-                                    acc[ext] = (acc[ext] || 0) + 1;
-                                    return acc;
-                                }, {}))
-                                    .slice(0, 8)
-                                    .map(([ext, count]) => `- **${ext.toUpperCase()}**: ${count} files`),
-                                '',
-                            ]
-                                .filter(Boolean)
-                                .join('\n');
-                        }
-                    }
-                }
-                catch (error) {
-                    console.warn('Smart Code Linking failed for comprehensive analysis:', error);
-                }
-                // Generate comprehensive domain knowledge if enabled
-                if (enhancedMode && knowledgeEnhancement) {
-                    try {
-                        const { generateArchitecturalKnowledge } = await import('../utils/knowledge-generation.js');
-                        const knowledgeResult = await generateArchitecturalKnowledge({
-                            projectPath,
-                            technologies: [],
-                            patterns: [],
-                            projectType: 'comprehensive-rule-generation',
-                        }, {
-                            domains: ['api-design', 'security-patterns', 'performance-optimization'],
-                            depth: 'advanced',
-                            cacheEnabled: true,
-                        });
-                        comprehensiveKnowledgeContext = `\n## Comprehensive Architectural Knowledge Enhancement\n\n${knowledgeResult.prompt}\n\n---\n`;
-                    }
-                    catch (error) {
-                        console.error('[WARNING] GKP knowledge generation failed for comprehensive analysis:', error);
-                        comprehensiveKnowledgeContext =
-                            '<!-- Comprehensive knowledge generation unavailable -->\n';
-                    }
-                }
                 const adrResult = await extractRulesFromAdrs(adrDirectory, existingRules, projectPath);
                 const existingRuleNames = existingRules?.map(r => r.name);
                 const patternResult = await generateRulesFromPatterns(projectPath, existingRuleNames);
-                // Create comprehensive prompt combining both ADR and pattern analysis with knowledge enhancement
-                const comprehensivePrompt = `${comprehensiveKnowledgeContext}${comprehensivePatternContext}
-# Comprehensive Architectural Rule Generation
-
-Generate a complete set of architectural rules by analyzing both ADRs and code patterns with Smart Code Linking context.
-
-## ADR-Based Rule Extraction
-
-${adrResult.extractionPrompt}
-
-## Pattern-Based Rule Generation
-
-${patternResult.generationPrompt}
-
-## Consolidation Requirements
-
-After extracting rules from both sources:
-
-1. **Merge and Deduplicate**: Combine rules from ADRs and patterns, removing duplicates
-2. **Resolve Conflicts**: When ADR rules conflict with pattern rules, prioritize ADR rules (explicit decisions)
-3. **Assign Priorities**: High priority for ADR rules, medium for consistent patterns, low for inconsistent patterns
-4. **Create Dependencies**: Identify relationships between rules and create dependency chains
-5. **Validate Completeness**: Ensure rules cover all major architectural concerns
-
-## Output Requirements
-
-Provide a unified rule set with:
-- **Rule Source**: Whether from ADR, pattern, or both
-- **Confidence Score**: 1-10 rating of rule validity
-- **Priority Level**: High/Medium/Low implementation priority
-- **Validation Pattern**: How to automatically check compliance
-- **Examples**: Valid and invalid code examples
-- **Dependencies**: Other rules this rule depends on
-`;
-                // Execute the comprehensive rule generation with AI if enabled, otherwise return prompt
-                const { executePromptWithFallback, formatMCPResponse } = await import('../utils/prompt-execution.js');
-                const executionResult = await executePromptWithFallback(comprehensivePrompt, `${adrResult.instructions}\n\n${patternResult.instructions}`, {
-                    temperature: 0.1,
-                    maxTokens: 8000,
-                    systemPrompt: `You are an expert software architect specializing in comprehensive architectural rule generation.
-Analyze both ADRs and code patterns to create a unified, actionable rule set for the project.
-Leverage the provided comprehensive architectural knowledge including governance frameworks, design patterns, and compliance standards.
-Focus on creating rules that are specific, measurable, and can be validated automatically.
-Prioritize explicit architectural decisions (ADRs) over implicit patterns when conflicts arise.
-Consider industry best practices, compliance requirements, and established architectural principles.`,
-                    responseFormat: 'text',
-                });
-                if (executionResult.isAIGenerated) {
-                    // AI execution successful - return actual comprehensive rule generation results
-                    return formatMCPResponse({
-                        ...executionResult,
-                        content: `# Comprehensive Rule Generation Results (Enhanced with Smart Code Linking & GKP)
-
-## Enhancement Features
-- **Smart Code Linking**: ${comprehensivePatternContext ? '✅ Active' : '❌ No patterns found'}
-- **Generated Knowledge Prompting**: ${knowledgeEnhancement ? '✅ Enabled' : '❌ Disabled'}
-- **Enhanced Mode**: ${enhancedMode ? '✅ Enabled' : '❌ Disabled'}
-- **Knowledge Domains**: Governance frameworks, software architecture, design patterns, compliance standards, code quality
-- **Knowledge Depth**: Advanced (comprehensive coverage)
-
-## Analysis Information
-- **ADR Directory**: ${adrDirectory}
-- **Project Path**: ${projectPath}
-- **Existing Rules**: ${existingRules?.length || 0} rules
-- **Output Format**: ${outputFormat.toUpperCase()}
-
-${comprehensivePatternContext ? `${comprehensivePatternContext}` : ''}
-
-${comprehensiveKnowledgeContext
-                            ? `## Applied Comprehensive Knowledge
-
-${comprehensiveKnowledgeContext}
-`
-                            : ''}
-
-## AI Comprehensive Analysis Results
-
-${executionResult.content}
-
-## Next Steps
-
-Based on the comprehensive analysis:
-
-1. **Review Unified Rule Set**: Examine the consolidated rules for completeness
-2. **Validate Rule Priorities**: Confirm priority assignments align with project needs
-3. **Implement High-Priority Rules**: Start with rules marked as high priority
-4. **Set Up Automated Validation**: Configure CI/CD to check rule compliance
-5. **Create Rule Documentation**: Document rules for team reference and training
-
-## Comprehensive Benefits
-
-This approach provides:
-- **Complete Coverage**: Both explicit (ADR) and implicit (pattern) rules
-- **Balanced Approach**: Combines intentional decisions with observed practices
-- **High Confidence**: Rules backed by both documentation and code evidence
-- **Practical Implementation**: Rules that can be validated and enforced
-- **Team Alignment**: Rules that reflect both intentions and reality
-
-## Integration Commands
-
-To create the final rule set:
-\`\`\`json
-{
-  "tool": "create_rule_set",
-  "args": {
-    "name": "Comprehensive Architectural Rules",
-    "adrRules": [ADR rules from above],
-    "patternRules": [pattern rules from above],
-    "outputFormat": "${outputFormat}"
-  }
-}
-\`\`\`
-
-To validate code against the complete rule set:
-\`\`\`json
-{
-  "tool": "validate_rules",
-  "args": {
-    "filePath": "path/to/code/file.js",
-    "rules": [unified rules from above]
-  }
-}
-\`\`\`
-`,
-                    });
-                }
-                else {
-                    // Fallback to prompt-only mode
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `# Comprehensive Rule Generation
+                // CE-MCP: return prompt text directly; directive intercepts in CE-MCP mode.
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `# Comprehensive Rule Generation
 
 This comprehensive analysis will generate architectural rules from both ADRs and code patterns for complete coverage.
 
@@ -656,10 +250,9 @@ Submit the pattern analysis prompt to generate rules from code patterns
 - Prioritize based on confidence and impact
 - Create unified rule set with dependencies
 `,
-                            },
-                        ],
-                    };
-                }
+                        },
+                    ],
+                };
             }
             default:
                 throw new McpAdrError(`Unknown rule generation source: ${source}`, 'INVALID_INPUT');
@@ -673,7 +266,7 @@ Submit the pattern analysis prompt to generate rules from code patterns
  * Validate code against architectural rules
  */
 export async function validateRules(args) {
-    const { filePath, fileContent, fileName, rules, validationType = 'file', reportFormat = 'detailed', projectPath = process.cwd(), findRelatedFiles = false, } = args;
+    const { filePath, fileContent, fileName, rules, validationType = 'file', reportFormat: _reportFormat = 'detailed', } = args;
     try {
         const { validateCodeAgainstRules } = await import('../utils/rule-generation.js');
         if (!filePath && !fileContent) {
@@ -682,52 +275,6 @@ export async function validateRules(args) {
         if (!rules || rules.length === 0) {
             throw new McpAdrError('Rules array is required and cannot be empty', 'INVALID_INPUT');
         }
-        // Smart Code Linking - find related files for comprehensive validation context
-        let relatedFilesContext = '';
-        if (findRelatedFiles && filePath) {
-            try {
-                // Create context from the file being validated and the rules
-                const validationContext = [
-                    `File being validated: ${filePath}`,
-                    'Architectural rules validation',
-                    ...rules.slice(0, 5).map(rule => `Rule: ${rule.name} - ${rule.description}`),
-                ].join('\n');
-                const relatedCodeResult = await findRelatedCode('rule-validation-context', validationContext, projectPath, {
-                    useAI: true,
-                    maxFiles: 12,
-                    includeContent: false,
-                });
-                if (relatedCodeResult.relatedFiles.length > 0) {
-                    // Filter out the file being validated itself
-                    const otherRelatedFiles = relatedCodeResult.relatedFiles.filter(f => f.path !== filePath && !filePath.endsWith(f.path));
-                    if (otherRelatedFiles.length > 0) {
-                        relatedFilesContext = [
-                            '',
-                            '## 🔗 Related Files for Validation Context',
-                            '',
-                            `Found **${otherRelatedFiles.length}** related files that may need similar validation:`,
-                            '',
-                            ...otherRelatedFiles
-                                .slice(0, 8)
-                                .map((file, index) => `${index + 1}. **${file.path}**`),
-                            otherRelatedFiles.length > 8
-                                ? `*Showing top 8 of ${otherRelatedFiles.length} related files*`
-                                : '',
-                            '',
-                            `**Context Confidence**: ${(relatedCodeResult.confidence * 100).toFixed(0)}%`,
-                            '',
-                            '💡 **Recommendation**: Consider validating these related files against the same rules for comprehensive compliance.',
-                            '',
-                        ]
-                            .filter(Boolean)
-                            .join('\n');
-                    }
-                }
-            }
-            catch (error) {
-                console.warn('Smart Code Linking failed for validation context:', error);
-            }
-        }
         // Convert rules to ArchitecturalRule format
         const architecturalRules = rules.map(rule => ({
             id: rule.id,
@@ -758,84 +305,12 @@ export async function validateRules(args) {
                 instructions: `Validation for ${tempFileName} with ${rules.length} rules`,
             };
         }
-        // Execute the rule validation with AI if enabled, otherwise return prompt
-        const { executePromptWithFallback, formatMCPResponse } = await import('../utils/prompt-execution.js');
-        const executionResult = await executePromptWithFallback(result.validationPrompt, result.instructions, {
-            temperature: 0.1,
-            maxTokens: 5000,
-            systemPrompt: `You are a senior software architect specializing in code quality and architectural compliance.
-Analyze the provided code against architectural rules to identify violations and provide improvement recommendations.
-Focus on providing specific, actionable feedback with clear explanations and fix suggestions.
-Prioritize violations by severity and impact on system architecture.`,
-            responseFormat: 'text',
-        });
-        if (executionResult.isAIGenerated) {
-            // AI execution successful - return actual rule validation results
-            return formatMCPResponse({
-                ...executionResult,
-                content: `# Code Validation Results (Enhanced with Smart Code Linking)
-
-## Validation Information
-- **File**: ${fileName || filePath || 'Content provided'}
-- **Validation Type**: ${validationType}
-- **Rules Applied**: ${rules.length} rules
-- **Report Format**: ${reportFormat}
-- **Smart Code Linking**: ${relatedFilesContext ? '✅ Related files discovered' : findRelatedFiles ? '❌ No related files found' : '⚪ Not requested'}
-
-${relatedFilesContext ? `${relatedFilesContext}` : ''}
-
-## AI Validation Results
-
-${executionResult.content}
-
-## Next Steps
-
-Based on the validation results:
-
-1. **Address Critical Issues**: Fix any critical violations immediately
-2. **Plan Error Fixes**: Schedule error-level violations for next release
-3. **Batch Warning Fixes**: Group warning-level issues for efficient resolution
-4. **Track Compliance**: Monitor improvement trends over time
-5. **Update Rules**: Refine rules based on validation experience
-
-## Violation Severity Levels
-
-- **Critical**: Must be fixed immediately (security, breaking changes)
-- **Error**: Should be fixed before deployment (functionality issues)
-- **Warning**: Should be addressed in next iteration (quality issues)
-- **Info**: Consider for future improvements (style, optimization)
-
-## Compliance Tracking
-
-Use validation results to:
-- Track compliance trends over time
-- Identify problematic areas or patterns
-- Measure improvement after fixes
-- Generate compliance reports for stakeholders
-
-## Re-validation Command
-
-After applying fixes, re-validate with:
-\`\`\`json
-{
-  "tool": "validate_rules",
-  "args": {
-    "filePath": "${filePath || 'updated-file-path'}",
-    "rules": [same rules array],
-    "reportFormat": "${reportFormat}"
-  }
-}
-\`\`\`
-`,
-            });
-        }
-        else {
-            // Fallback to prompt-only mode
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `# Code Validation Against Architectural Rules
+        // CE-MCP: return prompt text directly; directive intercepts in CE-MCP mode.
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `# Code Validation Against Architectural Rules
 
 ${result.instructions}
 
@@ -851,10 +326,9 @@ ${result.validationPrompt}
 4. **Apply suggested fixes** to improve compliance
 5. **Re-validate** to confirm improvements
 `,
-                    },
-                ],
-            };
-        }
+                },
+            ],
+        };
     }
     catch (error) {
         throw new McpAdrError(`Failed to validate rules: ${error instanceof Error ? error.message : String(error)}`, 'RULE_VALIDATION_ERROR');