clavix 4.3.1 → 4.4.0

package/dist/core/intelligence/pattern-library.js

@@ -21,11 +21,49 @@ import { SuccessCriteriaEnforcer } from './patterns/success-criteria-enforcer.js
 import { ErrorToleranceEnhancer } from './patterns/error-tolerance-enhancer.js';
 import { PrerequisiteIdentifier } from './patterns/prerequisite-identifier.js';
 import { DomainContextEnricher } from './patterns/domain-context-enricher.js';
+// v4.3.2 PRD patterns
+import { RequirementPrioritizer } from './patterns/requirement-prioritizer.js';
+import { UserPersonaEnricher } from './patterns/user-persona-enricher.js';
+import { SuccessMetricsEnforcer } from './patterns/success-metrics-enforcer.js';
+import { DependencyIdentifier } from './patterns/dependency-identifier.js';
+// v4.3.2 Conversational patterns
+import { ConversationSummarizer } from './patterns/conversation-summarizer.js';
+import { TopicCoherenceAnalyzer } from './patterns/topic-coherence-analyzer.js';
+import { ImplicitRequirementExtractor } from './patterns/implicit-requirement-extractor.js';
 export class PatternLibrary {
     patterns = new Map();
+    config = null;
     constructor() {
         this.registerDefaultPatterns();
     }
+    /**
+     * v4.4: Apply configuration settings to pattern library
+     * Allows enabling/disabling patterns and adjusting priorities via config
+     */
+    applyConfig(config) {
+        this.config = config;
+        // Apply priority overrides
+        if (config.patterns?.priorityOverrides) {
+            for (const [patternId, newPriority] of Object.entries(config.patterns.priorityOverrides)) {
+                const pattern = this.patterns.get(patternId);
+                if (pattern && newPriority >= 1 && newPriority <= 10) {
+                    pattern.priority = newPriority;
+                }
+            }
+        }
+    }
+    /**
+     * v4.4: Check if a pattern is disabled via config
+     */
+    isPatternDisabled(patternId) {
+        return this.config?.patterns?.disabled?.includes(patternId) ?? false;
+    }
+    /**
+     * v4.4: Get custom settings for a pattern
+     */
+    getPatternSettings(patternId) {
+        return this.config?.patterns?.customSettings?.[patternId];
+    }
     registerDefaultPatterns() {
         // Register core patterns (available in fast & deep modes)
         this.register(new ConcisenessFilter()); // HIGH - Remove verbosity
@@ -51,6 +89,15 @@ export class PatternLibrary {
         this.register(new ErrorToleranceEnhancer()); // P5 - Add error handling (deep only)
         this.register(new PrerequisiteIdentifier()); // P6 - Identify prerequisites (deep only)
         this.register(new DomainContextEnricher()); // P5 - Add domain best practices (both modes)
+        // v4.3.2 PRD patterns
+        this.register(new RequirementPrioritizer()); // P7 - Separate must-have from nice-to-have
+        this.register(new UserPersonaEnricher()); // P6 - Add user context and personas
+        this.register(new SuccessMetricsEnforcer()); // P7 - Ensure measurable success criteria
+        this.register(new DependencyIdentifier()); // P5 - Identify technical/external dependencies
+        // v4.3.2 Conversational patterns
+        this.register(new ConversationSummarizer()); // P8 - Extract structured requirements
+        this.register(new TopicCoherenceAnalyzer()); // P6 - Detect topic shifts
+        this.register(new ImplicitRequirementExtractor()); // P7 - Surface implicit requirements
     }
     /**
      * Register a new pattern
@@ -89,6 +136,10 @@ export class PatternLibrary {
     selectPatterns(intent, mode) {
         const applicablePatterns = [];
         for (const pattern of this.patterns.values()) {
+            // v4.4: Check if pattern is disabled via config
+            if (this.isPatternDisabled(pattern.id)) {
+                continue;
+            }
             // Check mode compatibility
             if (pattern.mode !== 'both' && pattern.mode !== mode) {
                 continue;
@@ -102,6 +153,123 @@ export class PatternLibrary {
         // Sort by priority (highest first)
         return applicablePatterns.sort((a, b) => b.priority - a.priority);
     }
+    /**
+     * v4.3.2: Select patterns for specific mode with phase-awareness
+     * Maps PRD and conversational modes to appropriate base modes and patterns
+     */
+    selectPatternsForMode(mode, intent, phase) {
+        // Map PRD/conversational modes to base modes for pattern selection
+        const baseMode = this.mapToBaseMode(mode, phase);
+        const applicablePatterns = [];
+        for (const pattern of this.patterns.values()) {
+            // v4.4: Check if pattern is disabled via config
+            if (this.isPatternDisabled(pattern.id)) {
+                continue;
+            }
+            // Check mode compatibility (use mapped base mode)
+            if (pattern.mode !== 'both' && pattern.mode !== baseMode) {
+                continue;
+            }
+            // Check intent compatibility
+            if (!pattern.applicableIntents.includes(intent.primaryIntent)) {
+                continue;
+            }
+            // Phase-specific filtering for PRD mode
+            if (mode === 'prd' && phase) {
+                if (!this.isPatternApplicableForPRDPhase(pattern, phase)) {
+                    continue;
+                }
+            }
+            // Phase-specific filtering for conversational mode
+            if (mode === 'conversational' && phase) {
+                if (!this.isPatternApplicableForConversationalPhase(pattern, phase)) {
+                    continue;
+                }
+            }
+            applicablePatterns.push(pattern);
+        }
+        // Sort by priority (highest first)
+        return applicablePatterns.sort((a, b) => b.priority - a.priority);
+    }
+    /**
+     * Map extended modes to base modes for pattern compatibility
+     */
+    mapToBaseMode(mode, phase) {
+        switch (mode) {
+            case 'prd':
+                // PRD uses deep mode for output generation, fast for validation
+                return phase === 'question-validation' ? 'fast' : 'deep';
+            case 'conversational':
+                // Conversational uses fast mode for tracking, deep for summarization
+                return phase === 'summarization' ? 'deep' : 'fast';
+            case 'fast':
+            case 'deep':
+            default:
+                return mode;
+        }
+    }
+    /**
+     * Check if pattern is applicable for PRD phase
+     */
+    isPatternApplicableForPRDPhase(pattern, phase) {
+        // Patterns for question validation (lightweight, clarity-focused)
+        const questionValidationPatterns = [
+            'ambiguity-detector',
+            'completeness-validator',
+            'objective-clarifier',
+        ];
+        // Patterns for output generation (comprehensive)
+        const outputGenerationPatterns = [
+            'prd-structure-enforcer',
+            'structure-organizer',
+            'success-criteria-enforcer',
+            'scope-definer',
+            'edge-case-identifier',
+            'assumption-explicitizer',
+            'technical-context-enricher',
+            'domain-context-enricher',
+            // v4.3.2 PRD patterns will be added here
+            'requirement-prioritizer',
+            'user-persona-enricher',
+            'success-metrics-enforcer',
+            'dependency-identifier',
+        ];
+        if (phase === 'question-validation') {
+            return questionValidationPatterns.includes(pattern.id);
+        }
+        if (phase === 'output-generation') {
+            return outputGenerationPatterns.includes(pattern.id);
+        }
+        return true; // Default: allow pattern
+    }
+    /**
+     * Check if pattern is applicable for conversational phase
+     */
+    isPatternApplicableForConversationalPhase(pattern, phase) {
+        // Patterns for conversation tracking (minimal, non-intrusive)
+        const conversationTrackingPatterns = ['ambiguity-detector', 'completeness-validator'];
+        // Patterns for summarization (comprehensive extraction)
+        const summarizationPatterns = [
+            'structure-organizer',
+            'completeness-validator',
+            'success-criteria-enforcer',
+            'edge-case-identifier',
+            'actionability-enhancer',
+            'technical-context-enricher',
+            'domain-context-enricher',
+            // v4.3.2 Conversational patterns will be added here
+            'conversation-summarizer',
+            'topic-coherence-analyzer',
+            'implicit-requirement-extractor',
+        ];
+        if (phase === 'conversation-tracking') {
+            return conversationTrackingPatterns.includes(pattern.id);
+        }
+        if (phase === 'summarization') {
+            return summarizationPatterns.includes(pattern.id);
+        }
+        return true; // Default: allow pattern
+    }
     /**
      * Get all registered patterns
      */

package/dist/core/intelligence/patterns/conversation-summarizer.d.ts

@@ -0,0 +1,28 @@
+import { BasePattern } from './base-pattern.js';
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+/**
+ * v4.4 Conversational Pattern: ConversationSummarizer
+ *
+ * Extracts structured requirements from conversational messages.
+ * Organizes free-form discussion into actionable requirements.
+ * Enhanced with expanded marker detection and confidence scoring.
+ */
+export declare class ConversationSummarizer extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: OptimizationMode | 'both';
+    priority: number;
+    private readonly conversationalMarkers;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private isAlreadyStructured;
+    private isConversationalContent;
+    private calculateConfidence;
+    private extractAndStructure;
+    private extractRequirements;
+    private extractConstraints;
+    private extractGoals;
+    private cleanRequirement;
+}
+//# sourceMappingURL=conversation-summarizer.d.ts.map

package/dist/core/intelligence/patterns/conversation-summarizer.js

@@ -0,0 +1,253 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * v4.4 Conversational Pattern: ConversationSummarizer
+ *
+ * Extracts structured requirements from conversational messages.
+ * Organizes free-form discussion into actionable requirements.
+ * Enhanced with expanded marker detection and confidence scoring.
+ */
+export class ConversationSummarizer extends BasePattern {
+    id = 'conversation-summarizer';
+    name = 'ConversationSummarizer';
+    description = 'Extracts structured requirements from messages';
+    applicableIntents = ['summarization', 'planning', 'prd-generation'];
+    mode = 'deep';
+    priority = 8;
+    // Expanded conversational markers (~30 markers)
+    conversationalMarkers = [
+        // Intent expressions
+        'i want',
+        'i need',
+        'we need',
+        'we want',
+        'i would like',
+        'we would like',
+        'would like to',
+        'should be able to',
+        'needs to',
+        // Thinking/exploring
+        'thinking about',
+        'maybe we could',
+        'what if',
+        'how about',
+        'perhaps we',
+        'considering',
+        'wondering if',
+        // Conversational connectors
+        "let's",
+        'let me',
+        'also',
+        'and then',
+        'plus',
+        'another thing',
+        'oh and',
+        'by the way',
+        // Informal markers
+        'basically',
+        'so basically',
+        'essentially',
+        'kind of like',
+        'sort of',
+        'something like',
+        // Collaborative
+        'can we',
+        'could we',
+        'shall we',
+    ];
+    apply(prompt, _context) {
+        // Check if content is already well-structured
+        if (this.isAlreadyStructured(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'structure',
+                    description: 'Content already well-structured',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Check if this looks like conversational content
+        if (!this.isConversationalContent(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'structure',
+                    description: 'Not conversational content',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Extract and structure requirements
+        const enhanced = this.extractAndStructure(prompt);
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'structure',
+                description: 'Extracted structured requirements from conversation',
+                impact: 'high',
+            },
+            applied: true,
+        };
+    }
+    isAlreadyStructured(prompt) {
+        // Check for markdown structure
+        const structureIndicators = [
+            '##',
+            '###',
+            '**Requirements:**',
+            '**Features:**',
+            '- [ ]',
+            '1.',
+            '2.',
+            '3.',
+        ];
+        const matches = structureIndicators.filter((indicator) => prompt.includes(indicator));
+        return matches.length >= 3;
+    }
+    isConversationalContent(prompt) {
+        const lowerPrompt = prompt.toLowerCase();
+        const matches = this.conversationalMarkers.filter((marker) => lowerPrompt.includes(marker));
+        // Also check for lack of structure (sentences without bullet points)
+        const sentences = this.extractSentences(prompt);
+        const hasBulletPoints = prompt.includes('- ') || prompt.includes('* ');
+        // More lenient threshold with expanded markers
+        return matches.length >= 2 || (sentences.length > 3 && !hasBulletPoints);
+    }
+    calculateConfidence(requirements, goals, constraints) {
+        // Calculate extraction confidence based on what was found
+        const hasRequirements = requirements.length > 0;
+        const hasGoals = goals.length > 0;
+        const hasConstraints = constraints.length > 0;
+        let confidence = 50; // Base confidence for conversational detection
+        if (hasRequirements)
+            confidence += 20;
+        if (hasGoals)
+            confidence += 15;
+        if (hasConstraints)
+            confidence += 15;
+        return Math.min(confidence, 100);
+    }
+    extractAndStructure(prompt) {
+        const requirements = this.extractRequirements(prompt);
+        const constraints = this.extractConstraints(prompt);
+        const goals = this.extractGoals(prompt);
+        const confidence = this.calculateConfidence(requirements, goals, constraints);
+        let structured = '### Extracted Requirements\n\n';
+        structured += `*Extraction confidence: ${confidence}%*\n\n`;
+        if (goals.length > 0) {
+            structured += '**Goals:**\n';
+            structured += goals.map((g) => `- ${g}`).join('\n');
+            structured += '\n\n';
+        }
+        if (requirements.length > 0) {
+            structured += '**Requirements:**\n';
+            structured += requirements.map((r) => `- ${r}`).join('\n');
+            structured += '\n\n';
+        }
+        if (constraints.length > 0) {
+            structured += '**Constraints:**\n';
+            structured += constraints.map((c) => `- ${c}`).join('\n');
+            structured += '\n\n';
+        }
+        // Add verification prompt if confidence is below 80%
+        if (confidence < 80) {
+            structured +=
+                '> **Note:** Please verify these extracted requirements are complete and accurate.\n\n';
+        }
+        structured += '---\n\n**Original Context:**\n' + prompt;
+        return structured;
+    }
+    extractRequirements(prompt) {
+        const requirements = [];
+        const sentences = this.extractSentences(prompt);
+        // Expanded requirement patterns
+        const requirementPatterns = [
+            /(?:i |we )?(?:need|want|should|must|require)\s+(?:to\s+)?(.+)/i,
+            /(?:should be able to|needs to|has to|have to)\s+(.+)/i,
+            /(?:feature|functionality|capability):\s*(.+)/i,
+            /(?:it should|it must|it needs to)\s+(.+)/i,
+            /(?:users? (?:can|should|will|must))\s+(.+)/i,
+            /(?:the system (?:should|must|will))\s+(.+)/i,
+            /(?:support(?:s|ing)?)\s+(.+)/i,
+            /(?:provide(?:s)?|enable(?:s)?|allow(?:s)?)\s+(.+)/i,
+        ];
+        for (const sentence of sentences) {
+            for (const pattern of requirementPatterns) {
+                const match = sentence.match(pattern);
+                if (match && match[1]) {
+                    const req = this.cleanRequirement(match[1]);
+                    if (req && !requirements.includes(req)) {
+                        requirements.push(req);
+                    }
+                }
+            }
+        }
+        return requirements.slice(0, 10); // Max 10 requirements
+    }
+    extractConstraints(prompt) {
+        const constraints = [];
+        const lowerPrompt = prompt.toLowerCase();
+        const constraintPatterns = [
+            /(?:can't|cannot|shouldn't|must not)\s+(.+)/gi,
+            /(?:limited to|restricted to|only)\s+(.+)/gi,
+            /(?:within|budget|deadline|timeline):\s*(.+)/gi,
+            /(?:no more than|at most|maximum)\s+(.+)/gi,
+        ];
+        for (const pattern of constraintPatterns) {
+            const matches = prompt.matchAll(pattern);
+            for (const match of matches) {
+                if (match[1]) {
+                    const constraint = this.cleanRequirement(match[1]);
+                    if (constraint && !constraints.includes(constraint)) {
+                        constraints.push(constraint);
+                    }
+                }
+            }
+        }
+        // Common constraint keywords
+        if (lowerPrompt.includes('performance')) {
+            constraints.push('Performance requirements to be defined');
+        }
+        if (lowerPrompt.includes('security')) {
+            constraints.push('Security requirements to be defined');
+        }
+        if (lowerPrompt.includes('mobile') && lowerPrompt.includes('desktop')) {
+            constraints.push('Must work on both mobile and desktop');
+        }
+        return constraints.slice(0, 5); // Max 5 constraints
+    }
+    extractGoals(prompt) {
+        const goals = [];
+        // Expanded goal patterns
+        const goalPatterns = [
+            /(?:goal is to|aim(?:ing)? to|objective is to)\s+(.+)/gi,
+            /(?:trying to|looking to|hoping to|want(?:ing)? to)\s+(.+)/gi,
+            /(?:so that|in order to|to achieve)\s+(.+)/gi,
+            /(?:the purpose is|main purpose|key purpose)\s+(.+)/gi,
+            /(?:ultimately|end goal|final goal|main goal)\s+(.+)/gi,
+            /(?:we're building this to|this will help)\s+(.+)/gi,
+        ];
+        for (const pattern of goalPatterns) {
+            const matches = prompt.matchAll(pattern);
+            for (const match of matches) {
+                if (match[1]) {
+                    const goal = this.cleanRequirement(match[1]);
+                    if (goal && !goals.includes(goal)) {
+                        goals.push(goal);
+                    }
+                }
+            }
+        }
+        return goals.slice(0, 3); // Max 3 goals
+    }
+    cleanRequirement(text) {
+        return text
+            .trim()
+            .replace(/[.!?,;:]+$/, '')
+            .replace(/\s+/g, ' ')
+            .substring(0, 200);
+    }
+}
+//# sourceMappingURL=conversation-summarizer.js.map

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

@@ -0,0 +1,21 @@
+import { BasePattern } from './base-pattern.js';
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+/**
+ * v4.3.2 PRD Pattern: DependencyIdentifier
+ *
+ * Identifies technical and external dependencies in PRD content.
+ * Helps surface hidden requirements and blockers.
+ */
+export declare class DependencyIdentifier extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: OptimizationMode | 'both';
+    priority: number;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private hasDependencySection;
+    private identifyDependencies;
+    private addDependencySection;
+}
+//# sourceMappingURL=dependency-identifier.d.ts.map

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

@@ -0,0 +1,149 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * v4.3.2 PRD Pattern: DependencyIdentifier
+ *
+ * Identifies technical and external dependencies in PRD content.
+ * Helps surface hidden requirements and blockers.
+ */
+export class DependencyIdentifier extends BasePattern {
+    id = 'dependency-identifier';
+    name = 'DependencyIdentifier';
+    description = 'Identifies technical and external dependencies';
+    applicableIntents = ['prd-generation', 'planning', 'migration'];
+    mode = 'deep';
+    priority = 5;
+    apply(prompt, _context) {
+        // Check if dependencies are already documented
+        if (this.hasDependencySection(prompt)) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'Dependencies already documented',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Check if this content has identifiable dependencies
+        const dependencies = this.identifyDependencies(prompt);
+        if (dependencies.length === 0) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'No clear dependencies identified',
+                    impact: 'low',
+                },
+                applied: false,
+            };
+        }
+        // Add dependency section
+        const enhanced = this.addDependencySection(prompt, dependencies);
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'completeness',
+                description: `Identified ${dependencies.length} dependencies (technical/external)`,
+                impact: 'medium',
+            },
+            applied: true,
+        };
+    }
+    hasDependencySection(prompt) {
+        const dependencyKeywords = [
+            'dependencies',
+            'depends on',
+            'prerequisite',
+            'requires',
+            'blocked by',
+            'blocker',
+            'external service',
+            'third-party',
+            'integration with',
+        ];
+        return this.hasSection(prompt, dependencyKeywords);
+    }
+    identifyDependencies(prompt) {
+        const dependencies = [];
+        const lowerPrompt = prompt.toLowerCase();
+        // Technical dependencies
+        if (lowerPrompt.includes('api')) {
+            dependencies.push('API availability and documentation');
+        }
+        if (lowerPrompt.includes('database') || lowerPrompt.includes('db')) {
+            dependencies.push('Database schema and migrations');
+        }
+        if (lowerPrompt.includes('authentication') || lowerPrompt.includes('auth')) {
+            dependencies.push('Authentication system integration');
+        }
+        if (lowerPrompt.includes('payment') ||
+            lowerPrompt.includes('stripe') ||
+            lowerPrompt.includes('billing')) {
+            dependencies.push('Payment provider integration');
+        }
+        if (lowerPrompt.includes('email') || lowerPrompt.includes('notification')) {
+            dependencies.push('Email/notification service');
+        }
+        if (lowerPrompt.includes('storage') ||
+            lowerPrompt.includes('s3') ||
+            lowerPrompt.includes('file')) {
+            dependencies.push('File storage service');
+        }
+        if (lowerPrompt.includes('search') || lowerPrompt.includes('elasticsearch')) {
+            dependencies.push('Search infrastructure');
+        }
+        if (lowerPrompt.includes('analytics') || lowerPrompt.includes('tracking')) {
+            dependencies.push('Analytics platform');
+        }
+        if (lowerPrompt.includes('ci/cd') || lowerPrompt.includes('deploy')) {
+            dependencies.push('CI/CD pipeline');
+        }
+        if (lowerPrompt.includes('cache') || lowerPrompt.includes('redis')) {
+            dependencies.push('Caching infrastructure');
+        }
+        // External dependencies
+        if (lowerPrompt.includes('third-party') || lowerPrompt.includes('external')) {
+            dependencies.push('Third-party service availability');
+        }
+        if (lowerPrompt.includes('team') || lowerPrompt.includes('collaboration')) {
+            dependencies.push('Cross-team coordination');
+        }
+        if (lowerPrompt.includes('approval') || lowerPrompt.includes('sign-off')) {
+            dependencies.push('Stakeholder approvals');
+        }
+        if (lowerPrompt.includes('legal') || lowerPrompt.includes('compliance')) {
+            dependencies.push('Legal/compliance review');
+        }
+        if (lowerPrompt.includes('design') ||
+            lowerPrompt.includes('ui') ||
+            lowerPrompt.includes('ux')) {
+            dependencies.push('Design specifications');
+        }
+        return dependencies;
+    }
+    addDependencySection(prompt, dependencies) {
+        // Categorize dependencies
+        const technical = dependencies.filter((d) => d.includes('API') ||
+            d.includes('Database') ||
+            d.includes('Authentication') ||
+            d.includes('service') ||
+            d.includes('infrastructure') ||
+            d.includes('pipeline'));
+        const external = dependencies.filter((d) => !technical.includes(d));
+        let section = '\n\n### Dependencies\n';
+        if (technical.length > 0) {
+            section += '**Technical Dependencies:**\n';
+            section += technical.map((d) => `- ${d}`).join('\n');
+            section += '\n\n';
+        }
+        if (external.length > 0) {
+            section += '**External Dependencies:**\n';
+            section += external.map((d) => `- ${d}`).join('\n');
+            section += '\n';
+        }
+        section += '\n**Dependency Status:** [Track status of each dependency]';
+        return prompt + section;
+    }
+}
+//# sourceMappingURL=dependency-identifier.js.map

package/dist/core/intelligence/patterns/implicit-requirement-extractor.d.ts

@@ -0,0 +1,22 @@
+import { BasePattern } from './base-pattern.js';
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+/**
+ * v4.4 Conversational Pattern: ImplicitRequirementExtractor
+ *
+ * Surfaces requirements mentioned indirectly in conversations.
+ * Identifies hidden assumptions and unstated needs.
+ * Enhanced with more detection patterns and categorization.
+ */
+export declare class ImplicitRequirementExtractor extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: OptimizationMode | 'both';
+    priority: number;
+    private readonly implicitPatterns;
+    apply(prompt: string, _context: PatternContext): PatternResult;
+    private extractImplicitRequirements;
+    private addImplicitRequirementsSection;
+}
+//# sourceMappingURL=implicit-requirement-extractor.d.ts.map