clavix 4.3.2 → 4.5.0

package/dist/core/intelligence/patterns/implicit-requirement-extractor.js

@@ -1,17 +1,137 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * v4.3.2 Conversational Pattern: ImplicitRequirementExtractor
+ * v4.5 Pattern: Implicit Requirement Extractor
  *
  * Surfaces requirements mentioned indirectly in conversations.
  * Identifies hidden assumptions and unstated needs.
+ * Enhanced with more detection patterns and categorization.
  */
 export class ImplicitRequirementExtractor extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'implicit-requirement-extractor';
-    name = 'ImplicitRequirementExtractor';
+    name = 'Implicit Requirement Extractor';
     description = 'Surfaces requirements mentioned indirectly';
     applicableIntents = ['summarization', 'planning', 'prd-generation'];
     mode = 'deep';
-    priority = 7;
+    priority = 5; // MEDIUM-LOW - supplementary
+    phases = ['conversation-tracking', 'summarization'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        maxImplicitRequirements: {
+            type: 'number',
+            default: 10,
+            description: 'Maximum number of implicit requirements to surface',
+            validation: { min: 1, max: 15 },
+        },
+        groupByCategory: {
+            type: 'boolean',
+            default: true,
+            description: 'Group requirements by category',
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Data
+    // -------------------------------------------------------------------------
+    // Categories for implicit requirements
+    implicitPatterns = [
+        // Infrastructure requirements
+        {
+            check: (p) => p.includes('mobile'),
+            requirement: 'Mobile-responsive design required',
+            category: 'infrastructure',
+        },
+        {
+            check: (p) => p.includes('real-time') || p.includes('realtime'),
+            requirement: 'Real-time updates infrastructure needed',
+            category: 'infrastructure',
+        },
+        {
+            check: (p) => p.includes('scale') || p.includes('thousands') || p.includes('millions'),
+            requirement: 'Scalability architecture required',
+            category: 'infrastructure',
+        },
+        {
+            check: (p) => p.includes('offline') || p.includes('without internet'),
+            requirement: 'Offline-capable architecture needed',
+            category: 'infrastructure',
+        },
+        {
+            check: (p) => p.includes('multi-tenant') || p.includes('multiple organizations'),
+            requirement: 'Multi-tenancy support required',
+            category: 'infrastructure',
+        },
+        // Security requirements
+        {
+            check: (p) => p.includes('secure') || p.includes('security'),
+            requirement: 'Security audit and compliance requirements',
+            category: 'security',
+        },
+        {
+            check: (p) => p.includes('gdpr') || p.includes('privacy') || p.includes('compliant'),
+            requirement: 'Data privacy and compliance infrastructure',
+            category: 'security',
+        },
+        {
+            check: (p) => p.includes('encrypt') || p.includes('sensitive'),
+            requirement: 'Data encryption requirements',
+            category: 'security',
+        },
+        // Performance requirements
+        {
+            check: (p) => p.includes('fast') || p.includes('quick'),
+            requirement: 'Performance optimization requirements',
+            category: 'performance',
+        },
+        {
+            check: (p) => p.includes('responsive') || p.includes('instant'),
+            requirement: 'Low-latency response requirements',
+            category: 'performance',
+        },
+        // UX requirements
+        {
+            check: (p) => p.includes('easy') || p.includes('simple') || p.includes('intuitive'),
+            requirement: 'User experience priority (simplicity mentioned)',
+            category: 'ux',
+        },
+        {
+            check: (p) => p.includes('accessible') || p.includes('a11y'),
+            requirement: 'Accessibility (WCAG) compliance required',
+            category: 'ux',
+        },
+        // Integration requirements
+        {
+            check: (p) => p.includes('notify') ||
+                p.includes('alert') ||
+                p.includes('email') ||
+                p.includes('notification'),
+            requirement: 'Notification system infrastructure',
+            category: 'integration',
+        },
+        {
+            check: (p) => p.includes('search') || p.includes('find'),
+            requirement: 'Search functionality and indexing',
+            category: 'integration',
+        },
+        {
+            check: (p) => p.includes('report') || p.includes('analytics') || p.includes('dashboard'),
+            requirement: 'Analytics and reporting infrastructure',
+            category: 'integration',
+        },
+        {
+            check: (p) => p.includes('integrate') || p.includes('connect') || p.includes('sync'),
+            requirement: 'Integration APIs and webhooks',
+            category: 'integration',
+        },
+        {
+            check: (p) => p.includes('import') || p.includes('export') || p.includes('csv'),
+            requirement: 'Data import/export functionality',
+            category: 'integration',
+        },
+    ];
     apply(prompt, _context) {
         // Extract implicit requirements
         const implicitReqs = this.extractImplicitRequirements(prompt);
@@ -28,7 +148,7 @@ export class ImplicitRequirementExtractor extends BasePattern {
             };
         }
         // Add implicit requirements section
-        const enhanced = this.addImplicitRequirements(prompt, implicitReqs);
+        const enhanced = this.addImplicitRequirementsSection(prompt, implicitReqs);
         return {
             enhancedPrompt: enhanced,
             improvement: {
@@ -46,83 +166,93 @@ export class ImplicitRequirementExtractor extends BasePattern {
         const likePatterns = prompt.matchAll(/(?:like|similar to|same as)\s+([A-Za-z0-9\s]+)/gi);
         for (const match of likePatterns) {
             if (match[1]) {
-                implicitReqs.push(`Feature parity with "${match[1].trim()}" (implied)`);
+                implicitReqs.push({
+                    requirement: `Feature parity with "${match[1].trim()}" (implied)`,
+                    category: 'feature',
+                });
             }
         }
-        // Pattern 2: Technical mentions imply requirements
-        if (lowerPrompt.includes('mobile')) {
-            implicitReqs.push('Mobile-responsive design required');
-        }
-        if (lowerPrompt.includes('real-time') || lowerPrompt.includes('realtime')) {
-            implicitReqs.push('Real-time updates infrastructure needed');
-        }
-        if (lowerPrompt.includes('scale') ||
-            lowerPrompt.includes('thousands') ||
-            lowerPrompt.includes('millions')) {
-            implicitReqs.push('Scalability architecture required');
-        }
-        if (lowerPrompt.includes('secure') || lowerPrompt.includes('security')) {
-            implicitReqs.push('Security audit and compliance requirements');
-        }
-        if (lowerPrompt.includes('fast') || lowerPrompt.includes('quick')) {
-            implicitReqs.push('Performance optimization requirements');
+        // Use pattern-based detection
+        for (const pattern of this.implicitPatterns) {
+            if (pattern.check(lowerPrompt)) {
+                implicitReqs.push({
+                    requirement: pattern.requirement,
+                    category: pattern.category,
+                });
+            }
         }
-        // Pattern 3: User mentions imply auth/permissions
+        // Pattern: User mentions imply auth/permissions
         if ((lowerPrompt.includes('user') || lowerPrompt.includes('admin')) &&
             !lowerPrompt.includes('authentication')) {
-            implicitReqs.push('User authentication system (implied by user roles)');
+            implicitReqs.push({
+                requirement: 'User authentication system (implied by user roles)',
+                category: 'security',
+            });
         }
-        // Pattern 4: Data mentions imply storage
+        // Pattern: Data mentions imply storage
         if ((lowerPrompt.includes('save') ||
             lowerPrompt.includes('store') ||
             lowerPrompt.includes('data')) &&
             !lowerPrompt.includes('database')) {
-            implicitReqs.push('Data persistence/storage (implied by data operations)');
-        }
-        // Pattern 5: "Easy" or "simple" implies UX focus
-        if (lowerPrompt.includes('easy') ||
-            lowerPrompt.includes('simple') ||
-            lowerPrompt.includes('intuitive')) {
-            implicitReqs.push('User experience priority (simplicity mentioned)');
-        }
-        // Pattern 6: Notifications/alerts imply communication system
-        if (lowerPrompt.includes('notify') ||
-            lowerPrompt.includes('alert') ||
-            lowerPrompt.includes('email') ||
-            lowerPrompt.includes('notification')) {
-            implicitReqs.push('Notification system infrastructure');
-        }
-        // Pattern 7: Search implies search infrastructure
-        if (lowerPrompt.includes('search') || lowerPrompt.includes('find')) {
-            implicitReqs.push('Search functionality and indexing');
+            implicitReqs.push({
+                requirement: 'Data persistence/storage (implied by data operations)',
+                category: 'infrastructure',
+            });
         }
-        // Pattern 8: Reports/analytics implies data aggregation
-        if (lowerPrompt.includes('report') ||
-            lowerPrompt.includes('analytics') ||
-            lowerPrompt.includes('dashboard')) {
-            implicitReqs.push('Analytics and reporting infrastructure');
-        }
-        // Pattern 9: Integration mentions
-        if (lowerPrompt.includes('integrate') ||
-            lowerPrompt.includes('connect') ||
-            lowerPrompt.includes('sync')) {
-            implicitReqs.push('Integration APIs and webhooks');
-        }
-        // Pattern 10: "Always" or "never" implies validation rules
+        // Pattern: "Always" or "never" implies validation rules
         const alwaysNeverPatterns = prompt.matchAll(/(?:always|never|must always|must never)\s+([^.!?]+)/gi);
         for (const match of alwaysNeverPatterns) {
             if (match[1]) {
-                implicitReqs.push(`Business rule: "${match[1].trim()}" (implied constraint)`);
+                implicitReqs.push({
+                    requirement: `Business rule: "${match[1].trim()}" (implied constraint)`,
+                    category: 'business',
+                });
             }
         }
-        // Deduplicate
-        return [...new Set(implicitReqs)].slice(0, 8);
+        // Deduplicate by requirement text
+        const seen = new Set();
+        return implicitReqs
+            .filter((r) => {
+            if (seen.has(r.requirement))
+                return false;
+            seen.add(r.requirement);
+            return true;
+        })
+            .slice(0, 10); // Increased to 10
     }
-    addImplicitRequirements(prompt, implicitReqs) {
+    addImplicitRequirementsSection(prompt, implicitReqs) {
         let section = '\n\n### Implicit Requirements (Inferred)\n';
         section += '*The following requirements are implied by the discussion:*\n\n';
-        section += implicitReqs.map((r) => `- ${r}`).join('\n');
-        section += '\n\n> **Note:** Please verify these inferred requirements are accurate.';
+        // Group by category for better organization
+        const byCategory = new Map();
+        for (const req of implicitReqs) {
+            const existing = byCategory.get(req.category) || [];
+            existing.push(req.requirement);
+            byCategory.set(req.category, existing);
+        }
+        // Format with category headers if multiple categories
+        if (byCategory.size > 2) {
+            const categoryLabels = {
+                infrastructure: '🏗️ Infrastructure',
+                security: '🔒 Security',
+                performance: '⚡ Performance',
+                ux: '✨ User Experience',
+                integration: '🔗 Integration',
+                feature: '📋 Feature',
+                business: '📊 Business Rules',
+            };
+            for (const [category, reqs] of byCategory) {
+                section += `**${categoryLabels[category] || category}:**\n`;
+                section += reqs.map((r) => `- ${r}`).join('\n');
+                section += '\n\n';
+            }
+        }
+        else {
+            // Simple list for fewer categories
+            section += implicitReqs.map((r) => `- ${r.requirement}`).join('\n');
+            section += '\n\n';
+        }
+        section += '> **Note:** Please verify these inferred requirements are accurate.';
         return prompt + section;
     }
 }

package/dist/core/intelligence/patterns/objective-clarifier.d.ts

@@ -1,12 +1,20 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, PatternMode, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
 import { PatternContext, PatternResult, PromptIntent } from '../types.js';
+/**
+ * v4.5 Pattern: Objective Clarifier
+ *
+ * Extracts or infers clear goal statement from prompts.
+ * Ensures every prompt has an explicit objective section.
+ */
 export declare class ObjectiveClarifier extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: 'fast' | 'deep' | 'both';
-    priority: number;
+    readonly id = "objective-clarifier";
+    readonly name = "Objective Clarifier";
+    readonly description = "Extracts or infers clear goal statement";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     apply(prompt: string, context: PatternContext): PatternResult;
     private hasExplicitObjective;
     private extractObjective;

package/dist/core/intelligence/patterns/objective-clarifier.js

@@ -1,11 +1,45 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
+/**
+ * v4.5 Pattern: Objective Clarifier
+ *
+ * Extracts or infers clear goal statement from prompts.
+ * Ensures every prompt has an explicit objective section.
+ */
 export class ObjectiveClarifier extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'objective-clarifier';
     name = 'Objective Clarifier';
     description = 'Extracts or infers clear goal statement';
-    applicableIntents = ['code-generation', 'planning', 'refinement', 'debugging', 'documentation'];
+    applicableIntents = [
+        'code-generation',
+        'planning',
+        'refinement',
+        'debugging',
+        'documentation',
+    ];
     mode = 'both';
-    priority = 9;
+    priority = 9; // VERY HIGH - structural integrity
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        inferFromContext: {
+            type: 'boolean',
+            default: true,
+            description: 'Attempt to infer objective when not explicitly stated',
+        },
+        addHeaderPrefix: {
+            type: 'boolean',
+            default: true,
+            description: 'Add "# Objective" header prefix when adding objective',
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Application
+    // -------------------------------------------------------------------------
     apply(prompt, context) {
         // Check if prompt already has clear objective section
         if (this.hasExplicitObjective(prompt)) {
@@ -14,9 +48,9 @@ export class ObjectiveClarifier extends BasePattern {
                 improvement: {
                     dimension: 'clarity',
                     description: 'Objective already clearly stated',
-                    impact: 'low'
+                    impact: 'low',
                 },
-                applied: false
+                applied: false,
             };
         }
         // Extract or infer objective
@@ -28,9 +62,9 @@ export class ObjectiveClarifier extends BasePattern {
                 improvement: {
                     dimension: 'clarity',
                     description: 'Could not infer clear objective',
-                    impact: 'low'
+                    impact: 'low',
                 },
-                applied: false
+                applied: false,
             };
         }
         // Add objective section
@@ -40,26 +74,21 @@ export class ObjectiveClarifier extends BasePattern {
             improvement: {
                 dimension: 'clarity',
                 description: 'Added clear objective statement',
-                impact: 'high'
+                impact: 'high',
             },
-            applied: true
+            applied: true,
         };
     }
     hasExplicitObjective(prompt) {
-        const objectiveMarkers = [
-            /^#+ objective/im,
-            /^objective:/im,
-            /^goal:/im,
-            /^purpose:/im
-        ];
-        return objectiveMarkers.some(marker => marker.test(prompt));
+        const objectiveMarkers = [/^#+ objective/im, /^objective:/im, /^goal:/im, /^purpose:/im];
+        return objectiveMarkers.some((marker) => marker.test(prompt));
     }
     extractObjective(prompt, intent) {
         const lowerPrompt = prompt.toLowerCase();
         // Look for explicit goal statements
         const goalPatterns = [
             /(?:i need to|i want to|i'm trying to|goal is to|objective is to|purpose is to)\s+(.+?)(?:\.|$)/i,
-            /(?:create|build|make|implement|develop|write)\s+(.+?)(?:\.|$)/i
+            /(?:create|build|make|implement|develop|write)\s+(.+?)(?:\.|$)/i,
         ];
         for (const pattern of goalPatterns) {
             const match = prompt.match(pattern);

package/dist/core/intelligence/patterns/output-format-enforcer.d.ts

@@ -1,18 +1,20 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, PatternMode, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
 import { PatternContext, PatternResult, PromptIntent } from '../types.js';
 /**
- * OutputFormatEnforcer Pattern (v4.1)
+ * v4.5 Pattern: Output Format Enforcer
  *
  * Ensures prompts specify the expected output format, which is critical
  * for agent-first design - agents need to know exactly what to produce.
  */
 export declare class OutputFormatEnforcer extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: 'fast' | 'deep' | 'both';
-    priority: number;
+    readonly id = "output-format-enforcer";
+    readonly name = "Output Format Enforcer";
+    readonly description = "Adds explicit output format specifications for agent clarity";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     private formatIndicators;
     private intentFormats;
     apply(prompt: string, context: PatternContext): PatternResult;

package/dist/core/intelligence/patterns/output-format-enforcer.js

@@ -1,11 +1,14 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * OutputFormatEnforcer Pattern (v4.1)
+ * v4.5 Pattern: Output Format Enforcer
  *
  * Ensures prompts specify the expected output format, which is critical
  * for agent-first design - agents need to know exactly what to produce.
  */
 export class OutputFormatEnforcer extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'output-format-enforcer';
     name = 'Output Format Enforcer';
     description = 'Adds explicit output format specifications for agent clarity';
@@ -17,7 +20,21 @@ export class OutputFormatEnforcer extends BasePattern {
         'testing',
     ];
     mode = 'both';
-    priority = 7; // Medium-high priority
+    priority = 7; // MEDIUM-HIGH - important enrichment
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        showFormatSuggestions: {
+            type: 'boolean',
+            default: true,
+            description: 'Show format suggestions based on intent',
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Data
+    // -------------------------------------------------------------------------
     // Format indicators that suggest format is already specified
     formatIndicators = [
         'output format',

package/dist/core/intelligence/patterns/prd-structure-enforcer.d.ts

@@ -1,18 +1,20 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, PatternMode, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
 import { PromptIntent, PatternContext, PatternResult } from '../types.js';
 /**
- * v4.0 Deep Mode Pattern: PRD Structure Enforcer
+ * v4.5 Pattern: PRD Structure Enforcer
  *
  * Ensures PRD prompts include all necessary sections
  * for comprehensive product requirement documentation.
  */
 export declare class PRDStructureEnforcer extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: "deep";
-    priority: number;
+    readonly id = "prd-structure-enforcer";
+    readonly name = "PRD Structure Enforcer";
+    readonly description = "Ensure PRD prompts include all necessary sections";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     private readonly PRD_SECTIONS;
     apply(prompt: string, _context: PatternContext): PatternResult;
     private analyzePRDCompleteness;

package/dist/core/intelligence/patterns/prd-structure-enforcer.js

@@ -1,17 +1,39 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * v4.0 Deep Mode Pattern: PRD Structure Enforcer
+ * v4.5 Pattern: PRD Structure Enforcer
  *
  * Ensures PRD prompts include all necessary sections
  * for comprehensive product requirement documentation.
  */
 export class PRDStructureEnforcer extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'prd-structure-enforcer';
     name = 'PRD Structure Enforcer';
     description = 'Ensure PRD prompts include all necessary sections';
     applicableIntents = ['prd-generation'];
     mode = 'deep';
-    priority = 9;
+    priority = 9; // VERY HIGH - structural integrity
+    phases = ['question-validation', 'output-generation'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        showCompletenessScore: {
+            type: 'boolean',
+            default: true,
+            description: 'Show PRD completeness percentage',
+        },
+        includeBestPractices: {
+            type: 'boolean',
+            default: true,
+            description: 'Include PRD best practices reminder',
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Data
+    // -------------------------------------------------------------------------
     // Required PRD sections with their purposes
     PRD_SECTIONS = [
         {

package/dist/core/intelligence/patterns/prerequisite-identifier.d.ts

@@ -1,18 +1,20 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, PatternMode, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
 import { PatternContext, PatternResult, PromptIntent } from '../types.js';
 /**
- * PrerequisiteIdentifier Pattern (v4.1)
+ * v4.5 Pattern: Prerequisite Identifier
  *
  * Identifies and explicitly states prerequisites and dependencies
  * that must be in place before the task can be executed.
  */
 export declare class PrerequisiteIdentifier extends BasePattern {
-    id: string;
-    name: string;
-    description: string;
-    applicableIntents: PromptIntent[];
-    mode: 'fast' | 'deep' | 'both';
-    priority: number;
+    readonly id = "prerequisite-identifier";
+    readonly name = "Prerequisite Identifier";
+    readonly description = "Identifies and documents prerequisites and dependencies for task execution";
+    readonly applicableIntents: PromptIntent[];
+    readonly mode: PatternMode;
+    readonly priority: PatternPriority;
+    readonly phases: PatternPhase[];
+    static readonly configSchema: PatternConfigSchema;
     private prerequisiteIndicators;
     private techPrerequisites;
     private intentPrerequisites;

package/dist/core/intelligence/patterns/prerequisite-identifier.js

@@ -1,11 +1,14 @@
-import { BasePattern } from './base-pattern.js';
+import { BasePattern, } from './base-pattern.js';
 /**
- * PrerequisiteIdentifier Pattern (v4.1)
+ * v4.5 Pattern: Prerequisite Identifier
  *
  * Identifies and explicitly states prerequisites and dependencies
  * that must be in place before the task can be executed.
  */
 export class PrerequisiteIdentifier extends BasePattern {
+    // -------------------------------------------------------------------------
+    // Pattern Metadata (v4.5 unified types)
+    // -------------------------------------------------------------------------
     id = 'prerequisite-identifier';
     name = 'Prerequisite Identifier';
     description = 'Identifies and documents prerequisites and dependencies for task execution';
@@ -16,8 +19,29 @@ export class PrerequisiteIdentifier extends BasePattern {
         'testing',
         'debugging',
     ];
-    mode = 'deep'; // Only in deep mode
-    priority = 6; // Medium priority
+    mode = 'deep';
+    priority = 6; // MEDIUM - standard enhancement
+    phases = ['all'];
+    // -------------------------------------------------------------------------
+    // Configuration Schema (v4.5)
+    // -------------------------------------------------------------------------
+    static configSchema = {
+        maxPrerequisites: {
+            type: 'number',
+            default: 8,
+            description: 'Maximum number of prerequisites to list',
+            validation: { min: 1, max: 15 },
+        },
+        maxTechnologies: {
+            type: 'number',
+            default: 3,
+            description: 'Maximum number of technologies to detect',
+            validation: { min: 1, max: 5 },
+        },
+    };
+    // -------------------------------------------------------------------------
+    // Pattern Data
+    // -------------------------------------------------------------------------
     // Keywords that suggest prerequisites are already addressed
     prerequisiteIndicators = [
         'prerequisite',