clavix 4.3.2 → 4.4.0

package/dist/core/intelligence/pattern-library.d.ts

@@ -1,8 +1,23 @@
 import { BasePattern } from './patterns/base-pattern.js';
 import { IntentAnalysis, OptimizationMode, OptimizationPhase } from './types.js';
+import { IntelligenceConfig } from '../../types/config.js';
 export declare class PatternLibrary {
     private patterns;
+    private config;
     constructor();
+    /**
+     * v4.4: Apply configuration settings to pattern library
+     * Allows enabling/disabling patterns and adjusting priorities via config
+     */
+    applyConfig(config: IntelligenceConfig): void;
+    /**
+     * v4.4: Check if a pattern is disabled via config
+     */
+    private isPatternDisabled;
+    /**
+     * v4.4: Get custom settings for a pattern
+     */
+    getPatternSettings(patternId: string): Record<string, unknown> | undefined;
     private registerDefaultPatterns;
     /**
      * Register a new pattern

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

@@ -32,9 +32,38 @@ 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
@@ -107,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;
@@ -129,6 +162,10 @@ export class PatternLibrary {
         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;

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

@@ -1,10 +1,11 @@
 import { BasePattern } from './base-pattern.js';
 import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
 /**
- * v4.3.2 Conversational Pattern: ConversationSummarizer
+ * 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;
@@ -13,9 +14,11 @@ export declare class ConversationSummarizer extends BasePattern {
     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;

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

@@ -1,9 +1,10 @@
 import { BasePattern } from './base-pattern.js';
 /**
- * v4.3.2 Conversational Pattern: ConversationSummarizer
+ * 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';
@@ -12,6 +13,47 @@ export class ConversationSummarizer extends BasePattern {
     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)) {
@@ -65,36 +107,35 @@ export class ConversationSummarizer extends BasePattern {
         return matches.length >= 3;
     }
     isConversationalContent(prompt) {
-        // Conversational markers
-        const conversationalMarkers = [
-            'i want',
-            'i need',
-            'we need',
-            'should be able to',
-            'would like',
-            'thinking about',
-            'maybe we could',
-            'what if',
-            'how about',
-            'let me',
-            "let's",
-            'also',
-            'and then',
-            'basically',
-            'so basically',
-        ];
         const lowerPrompt = prompt.toLowerCase();
-        const matches = conversationalMarkers.filter((marker) => lowerPrompt.includes(marker));
+        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');
@@ -110,16 +151,27 @@ export class ConversationSummarizer extends BasePattern {
             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 = [
-            /(?:need|want|should|must|require)\s+(?:to\s+)?(.+)/i,
-            /(?:should be able to|needs to)\s+(.+)/i,
-            /(?:feature|functionality):\s*(.+)/i,
+            /(?: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) {
@@ -168,10 +220,14 @@ export class ConversationSummarizer extends BasePattern {
     }
     extractGoals(prompt) {
         const goals = [];
+        // Expanded goal patterns
         const goalPatterns = [
-            /(?:goal is to|aim to|objective is to)\s+(.+)/gi,
-            /(?:trying to|looking to|hoping to)\s+(.+)/gi,
-            /(?:so that|in order to)\s+(.+)/gi,
+            /(?: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);

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

@@ -1,10 +1,11 @@
 import { BasePattern } from './base-pattern.js';
 import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
 /**
- * v4.3.2 Conversational Pattern: ImplicitRequirementExtractor
+ * 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;
@@ -13,8 +14,9 @@ export declare class ImplicitRequirementExtractor extends BasePattern {
     applicableIntents: PromptIntent[];
     mode: OptimizationMode | 'both';
     priority: number;
+    private readonly implicitPatterns;
     apply(prompt: string, _context: PatternContext): PatternResult;
     private extractImplicitRequirements;
-    private addImplicitRequirements;
+    private addImplicitRequirementsSection;
 }
 //# sourceMappingURL=implicit-requirement-extractor.d.ts.map

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

@@ -1,9 +1,10 @@
 import { BasePattern } from './base-pattern.js';
 /**
- * v4.3.2 Conversational Pattern: ImplicitRequirementExtractor
+ * 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 class ImplicitRequirementExtractor extends BasePattern {
     id = 'implicit-requirement-extractor';
@@ -12,6 +13,102 @@ export class ImplicitRequirementExtractor extends BasePattern {
     applicableIntents = ['summarization', 'planning', 'prd-generation'];
     mode = 'deep';
     priority = 7;
+    // 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 +125,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 +143,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/topic-coherence-analyzer.d.ts

@@ -1,10 +1,11 @@
 import { BasePattern } from './base-pattern.js';
 import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
 /**
- * v4.3.2 Conversational Pattern: TopicCoherenceAnalyzer
+ * v4.4 Conversational Pattern: TopicCoherenceAnalyzer
  *
  * Detects topic shifts and multi-topic conversations.
  * Helps organize scattered discussions into coherent themes.
+ * Enhanced with expanded topic dictionary and better detection.
  */
 export declare class TopicCoherenceAnalyzer extends BasePattern {
     id: string;
@@ -13,6 +14,7 @@ export declare class TopicCoherenceAnalyzer extends BasePattern {
     applicableIntents: PromptIntent[];
     mode: OptimizationMode | 'both';
     priority: number;
+    private readonly topicIndicators;
     apply(prompt: string, _context: PatternContext): PatternResult;
     private detectTopics;
     private hasTopicOrganization;

package/dist/core/intelligence/patterns/topic-coherence-analyzer.js

@@ -1,9 +1,10 @@
 import { BasePattern } from './base-pattern.js';
 /**
- * v4.3.2 Conversational Pattern: TopicCoherenceAnalyzer
+ * v4.4 Conversational Pattern: TopicCoherenceAnalyzer
  *
  * Detects topic shifts and multi-topic conversations.
  * Helps organize scattered discussions into coherent themes.
+ * Enhanced with expanded topic dictionary and better detection.
  */
 export class TopicCoherenceAnalyzer extends BasePattern {
     id = 'topic-coherence-analyzer';
@@ -12,6 +13,183 @@ export class TopicCoherenceAnalyzer extends BasePattern {
     applicableIntents = ['summarization', 'planning'];
     mode = 'deep';
     priority = 6;
+    // Expanded topic indicators (~15 topics with more keywords)
+    topicIndicators = {
+        'User Interface': [
+            'ui',
+            'interface',
+            'design',
+            'layout',
+            'button',
+            'form',
+            'page',
+            'screen',
+            'component',
+            'modal',
+            'dialog',
+            'navigation',
+            'menu',
+            'sidebar',
+            'header',
+            'footer',
+        ],
+        'Backend/API': [
+            'api',
+            'backend',
+            'server',
+            'endpoint',
+            'route',
+            'controller',
+            'service',
+            'middleware',
+            'rest',
+            'graphql',
+            'websocket',
+        ],
+        Database: [
+            'database',
+            'db',
+            'schema',
+            'table',
+            'query',
+            'migration',
+            'model',
+            'orm',
+            'sql',
+            'nosql',
+            'index',
+            'relationship',
+        ],
+        Authentication: [
+            'auth',
+            'login',
+            'password',
+            'session',
+            'token',
+            'permission',
+            'role',
+            'oauth',
+            'jwt',
+            'sso',
+            'mfa',
+            '2fa',
+        ],
+        Performance: [
+            'performance',
+            'speed',
+            'cache',
+            'optimize',
+            'latency',
+            'load time',
+            'bundle',
+            'lazy',
+            'memory',
+            'cpu',
+        ],
+        Testing: [
+            'test',
+            'spec',
+            'coverage',
+            'qa',
+            'validation',
+            'unit test',
+            'integration',
+            'e2e',
+            'mock',
+            'fixture',
+        ],
+        Deployment: [
+            'deploy',
+            'ci/cd',
+            'pipeline',
+            'release',
+            'environment',
+            'production',
+            'staging',
+            'docker',
+            'kubernetes',
+        ],
+        'User Experience': [
+            'ux',
+            'usability',
+            'accessibility',
+            'user flow',
+            'journey',
+            'experience',
+            'onboarding',
+            'feedback',
+        ],
+        'Business Logic': [
+            'business',
+            'workflow',
+            'process',
+            'rule',
+            'logic',
+            'requirement',
+            'feature',
+            'use case',
+        ],
+        Integration: [
+            'integration',
+            'third-party',
+            'external',
+            'webhook',
+            'sync',
+            'connect',
+            'import',
+            'export',
+        ],
+        Security: [
+            'security',
+            'encryption',
+            'vulnerability',
+            'xss',
+            'csrf',
+            'injection',
+            'sanitize',
+            'audit',
+        ],
+        Analytics: [
+            'analytics',
+            'tracking',
+            'metrics',
+            'dashboard',
+            'report',
+            'insight',
+            'data',
+            'statistics',
+        ],
+        'Error Handling': [
+            'error',
+            'exception',
+            'fallback',
+            'retry',
+            'timeout',
+            'failure',
+            'recovery',
+            'logging',
+        ],
+        Documentation: [
+            'documentation',
+            'docs',
+            'readme',
+            'guide',
+            'tutorial',
+            'api docs',
+            'comment',
+            'jsdoc',
+        ],
+        'State Management': [
+            'state',
+            'store',
+            'redux',
+            'context',
+            'global state',
+            'local state',
+            'persist',
+            'hydrate',
+        ],
+    };
     apply(prompt, _context) {
         // Detect topics in the content
         const topics = this.detectTopics(prompt);
@@ -54,20 +232,7 @@ export class TopicCoherenceAnalyzer extends BasePattern {
     detectTopics(prompt) {
         const topics = [];
         const lowerPrompt = prompt.toLowerCase();
-        // Topic detection patterns
-        const topicIndicators = {
-            'User Interface': ['ui', 'interface', 'design', 'layout', 'button', 'form', 'page', 'screen'],
-            'Backend/API': ['api', 'backend', 'server', 'endpoint', 'route', 'controller'],
-            Database: ['database', 'db', 'schema', 'table', 'query', 'migration'],
-            Authentication: ['auth', 'login', 'password', 'session', 'token', 'permission'],
-            Performance: ['performance', 'speed', 'cache', 'optimize', 'latency'],
-            Testing: ['test', 'spec', 'coverage', 'qa', 'validation'],
-            Deployment: ['deploy', 'ci/cd', 'pipeline', 'release', 'environment'],
-            'User Experience': ['ux', 'usability', 'accessibility', 'user flow', 'journey'],
-            'Business Logic': ['business', 'workflow', 'process', 'rule', 'logic'],
-            Integration: ['integration', 'third-party', 'external', 'webhook', 'sync'],
-        };
-        for (const [topic, keywords] of Object.entries(topicIndicators)) {
+        for (const [topic, keywords] of Object.entries(this.topicIndicators)) {
             const hasKeyword = keywords.some((kw) => lowerPrompt.includes(kw));
             if (hasKeyword) {
                 topics.push(topic);
@@ -99,30 +264,7 @@ export class TopicCoherenceAnalyzer extends BasePattern {
         return organized;
     }
     extractTopicContent(prompt, topic) {
-        // Simple extraction based on topic keywords
-        const topicKeywords = {
-            'User Interface': [
-                'ui',
-                'interface',
-                'design',
-                'layout',
-                'button',
-                'form',
-                'page',
-                'screen',
-                'component',
-            ],
-            'Backend/API': ['api', 'backend', 'server', 'endpoint', 'route', 'controller', 'service'],
-            Database: ['database', 'db', 'schema', 'table', 'query', 'migration', 'model'],
-            Authentication: ['auth', 'login', 'password', 'session', 'token', 'permission', 'user'],
-            Performance: ['performance', 'speed', 'cache', 'optimize', 'latency', 'fast', 'slow'],
-            Testing: ['test', 'spec', 'coverage', 'qa', 'validation', 'verify'],
-            Deployment: ['deploy', 'ci/cd', 'pipeline', 'release', 'environment', 'production'],
-            'User Experience': ['ux', 'usability', 'accessibility', 'user flow', 'journey', 'experience'],
-            'Business Logic': ['business', 'workflow', 'process', 'rule', 'logic', 'requirement'],
-            Integration: ['integration', 'third-party', 'external', 'webhook', 'sync', 'connect'],
-        };
-        const keywords = topicKeywords[topic] || [];
+        const keywords = this.topicIndicators[topic] || [];
         const sentences = this.extractSentences(prompt);
         const relevantSentences = sentences.filter((sentence) => {
             const lower = sentence.toLowerCase();

package/dist/templates/slash-commands/_canonical/deep.md

@@ -179,7 +179,7 @@ Deep mode provides **Clavix Intelligence™** with comprehensive analysis that g
 
 ---
 
-## Agent Transparency (v4.1)
+## Agent Transparency (v4.4)
 
 ### Quality Output Format
 {{INCLUDE:agent-protocols/quality-output.md}}

package/dist/templates/slash-commands/_canonical/execute.md

@@ -109,7 +109,7 @@ clavix prompts clear --executed
 
 ---
 
-## Agent Transparency (v4.1)
+## Agent Transparency (v4.4)
 
 ### File Format Reference
 {{INCLUDE:agent-protocols/file-formats.md}}

package/dist/templates/slash-commands/_canonical/fast.md

@@ -158,7 +158,7 @@ Clavix provides **Clavix Intelligence™** that automatically detects intent and
 
 ---
 
-## Agent Transparency (v4.1)
+## Agent Transparency (v4.4)
 
 ### Quality Output Format
 {{INCLUDE:agent-protocols/quality-output.md}}

package/dist/templates/slash-commands/_canonical/implement.md

@@ -315,7 +315,7 @@ To find the task ID programmatically, read tasks.md and look for the pattern `ph
 
 ---
 
-## Agent Transparency (v4.1)
+## Agent Transparency (v4.4)
 
 ### Workflow State Detection
 {{INCLUDE:agent-protocols/state-awareness.md}}

package/dist/templates/slash-commands/_canonical/plan.md

@@ -288,7 +288,7 @@ The generated `tasks.md` will look like:
 
 ---
 
-## Agent Transparency (v4.1)
+## Agent Transparency (v4.4)
 
 ### Workflow State Detection
 {{INCLUDE:agent-protocols/state-awareness.md}}

package/dist/templates/slash-commands/_canonical/prd.md

@@ -316,7 +316,7 @@ The validation ensures generated PRDs are immediately usable for AI consumption
 
 ---
 
-## Agent Transparency (v4.1)
+## Agent Transparency (v4.4)
 
 ### Quality Output Format
 {{INCLUDE:agent-protocols/quality-output.md}}

package/dist/templates/slash-commands/_canonical/start.md

@@ -190,7 +190,27 @@ The goal is natural exploration of requirements, not a rigid questionnaire. Foll
 
 ---
 
-## Agent Transparency (v4.1)
+## Agent Transparency (v4.4)
+
+### Enhanced Conversational Analysis (v4.4)
+
+Clavix Intelligence™ now includes enhanced conversational pattern recognition:
+
+**Topic Detection** (~15 topic areas):
+- Automatically detects: User Interface, Backend/API, Database, Authentication, Performance, Testing, Deployment, User Experience, Business Logic, Integration, Security, Analytics, Error Handling, Documentation, State Management
+- Groups related keywords for more accurate multi-topic detection
+- Triggers focus suggestions when 3+ distinct topics detected
+
+**Conversational Markers** (~30 patterns):
+- Intent expressions: "i want", "we need", "should be able to"
+- Thinking/exploring: "thinking about", "what if", "how about"
+- Informal markers: "basically", "kind of like", "something like"
+- Collaborative: "can we", "could we", "shall we"
+
+**Implicit Requirement Detection**:
+- Surfaces unstated requirements from context
+- Categories: Infrastructure, Security, Performance, UX, Integration
+- Examples: "mobile" → responsive design, "real-time" → WebSocket infrastructure
 
 ### Agent Decision Rules
 {{INCLUDE:agent-protocols/decision-rules.md}}

package/dist/templates/slash-commands/_canonical/summarize.md

@@ -104,7 +104,15 @@ Implementation: BLOCKED - I will extract requirements, not implement them
    - **Success Criteria** [confidence]: How will success be measured?
    - **Context** [confidence]: Any important background or constraints?
 
-   **CHECKPOINT:** Extracted [N] requirements, [M] constraints from conversation
+   **Calculate Extraction Confidence (v4.4):**
+   - Start with 50% base (conversational content detected)
+   - Add 20% if concrete requirements extracted
+   - Add 15% if clear goals identified
+   - Add 15% if constraints defined
+   - Display: "*Extraction confidence: X%*"
+   - If confidence < 80%, include verification prompt in output
+
+   **CHECKPOINT:** Extracted [N] requirements, [M] constraints from conversation (confidence: X%)
 
 3. **CREATE OUTPUT FILES (REQUIRED)** - You MUST create three files. This is not optional.
 
@@ -156,6 +164,12 @@ Implementation: BLOCKED - I will extract requirements, not implement them
    - [Edge case 1 and how it should be handled]
    - [Open question 1 - needs clarification]
 
+   ## Implicit Requirements (v4.4)
+   *Inferred from conversation context - please verify:*
+   - [Category] [Requirement inferred from discussion]
+   - [Category] [Another requirement]
+   > **Note:** These requirements were surfaced by analyzing conversation patterns.
+
    ## Success Criteria
    How we know this is complete and working:
    - ✓ [Specific success criterion 1]
@@ -344,7 +358,34 @@ Implementation: BLOCKED - I will extract requirements, not implement them
 
 ---
 
-## Agent Transparency (v4.1)
+## Agent Transparency (v4.4)
+
+### Enhanced Extraction Capabilities (v4.4)
+
+Clavix Intelligence™ now includes enhanced extraction with confidence scoring:
+
+**Extraction Confidence** (auto-calculated):
+- Base confidence: 50% (conversational content detected)
+- +20% if concrete requirements extracted
+- +15% if clear goals identified
+- +15% if constraints defined
+- Display: "Extraction confidence: X%"
+- If <80%, add verification prompt to output
+
+**Implicit Requirements** (auto-surfaced):
+- Inferred from conversation context, grouped by category:
+  - **Infrastructure**: Mobile-responsive, real-time, scalability, offline, multi-tenant
+  - **Security**: Audit compliance, data privacy, encryption
+  - **Performance**: Speed optimization, low-latency
+  - **UX**: Simplicity focus, accessibility (WCAG)
+  - **Integration**: Notifications, search, analytics, APIs, data import/export
+- Up to 10 implicit requirements per extraction
+- Always marked with verification note
+
+**Topic Organization**:
+- Detects 15 topic categories with expanded keyword matching
+- Groups multi-topic extractions by area
+- Suggests separate PRDs for 3+ distinct topics
 
 ### Quality Output Format
 {{INCLUDE:agent-protocols/quality-output.md}}

package/dist/types/config.d.ts

@@ -7,8 +7,32 @@ export interface ClavixConfig {
     templates: TemplateConfig;
     outputs: OutputConfig;
     preferences: PreferencesConfig;
+    intelligence?: IntelligenceConfig;
     experimental?: Record<string, unknown>;
 }
+/**
+ * v4.4 Intelligence Configuration
+ * Configure pattern behavior, enable/disable patterns, adjust priorities
+ */
+export interface IntelligenceConfig {
+    /** Pattern-specific settings */
+    patterns?: PatternSettingsConfig;
+    /** Default mode for optimization */
+    defaultMode?: 'fast' | 'deep';
+    /** Enable verbose pattern logging */
+    verbosePatternLogs?: boolean;
+}
+/**
+ * Pattern-specific settings
+ */
+export interface PatternSettingsConfig {
+    /** Disabled pattern IDs (won't run even if applicable) */
+    disabled?: string[];
+    /** Priority overrides (pattern-id → new priority 1-10) */
+    priorityOverrides?: Record<string, number>;
+    /** Custom pattern parameters (pattern-id → settings) */
+    customSettings?: Record<string, Record<string, unknown>>;
+}
 /**
  * Legacy config format (pre-v3.5.0)
  * Supports migration from:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clavix",
-  "version": "4.3.2",
+  "version": "4.4.0",
   "description": "Clavix Intelligence™ for AI coding. Automatically optimizes prompts with intent detection, quality assessment, and adaptive patterns—no framework to learn. Works with Claude Code, Cursor, Windsurf, and 19+ other AI coding tools.",
   "type": "module",
   "main": "dist/index.js",