Rename utils/psychology_layer.py to utils/psychology_layer_enhanced.py

utils/psychology_layer.py

@@ -1,191 +0,0 @@
-"""
-Psychological Persuasion Layer
-Implements: Loss aversion, social proof, scarcity, authority
-"""
-
-import random
-from typing import Dict, List
-
-class PsychologyEngine:
-    """Applies psychological principles to demo presentation"""
-    
-    def __init__(self):
-        # Loss aversion scenarios
-        self.loss_scenarios = {
-            "high": [
-                "Data breach ($3.9M average cost)",
-                "Service disruption ($300k/hour)",
-                "Compliance fines (up to $20M)"
-            ],
-            "medium": [
-                "Data corruption (24h recovery time)",
-                "Performance degradation (50% slower)",
-                "Security vulnerability exposure"
-            ],
-            "low": [
-                "Minor configuration drift",
-                "Increased operational overhead",
-                "Manual review delays"
-            ]
-        }
-        
-        # Social proof statements
-        self.social_proofs = {
-            "oss": [
-                "92% of Enterprise users report reduced incidents",
-                "Fortune 500 companies save $2.3M annually with mechanical gates",
-                "Developers report 15 minutes saved per decision"
-            ],
-            "trial": [
-                "Join 1,000+ developers using ARF",
-                "50+ companies started with trial and upgraded",
-                "Average user prevents 3 high-risk actions weekly"
-            ],
-            "professional": [
-                "Trusted by 200+ scale-ups",
-                "Teams report 92% faster incident response",
-                "40% reduction in on-call alerts"
-            ],
-            "enterprise": [
-                "Deployed at 50+ Fortune 500 companies",
-                "99.9% reliability across 1M+ decisions",
-                "SOC 2 certified with zero findings"
-            ]
-        }
-        
-        # Authority signals
-        self.authority_signals = [
-            "SOC 2 Type II Certified",
-            "GDPR & CCPA Compliant",
-            "ISO 27001 Certified",
-            "99.9% SLA Guarantee",
-            "24/7 Dedicated Support",
-            "On-prem Deployment Available"
-        ]
-        
-        # Scarcity messages
-        self.scarcity_messages = {
-            "trial": [
-                "⏳ Limited time: {days} days remaining in trial",
-                "🎁 Free trial ends soon - upgrade to keep mechanical gates",
-                "⚠️ Trial license expires in {days} days"
-            ],
-            "starter": [
-                "💰 Special pricing: First 3 months at 50% off",
-                "👥 Limited seats available at current price",
-                "⏰ Offer ends this quarter"
-            ]
-        }
-    
-    def generate_loss_aversion_message(self, risk_score: float) -> Dict:
-        """Generate loss aversion framing based on risk"""
-        if risk_score > 0.7:
-            category = "high"
-        elif risk_score > 0.4:
-            category = "medium"
-        else:
-            category = "low"
-        
-        scenarios = self.loss_scenarios[category]
-        selected = random.sample(scenarios, min(3, len(scenarios)))
-        
-        return {
-            "title": f"🚨 Without Enterprise, you risk:",
-            "points": selected,
-            "category": category,
-            "risk_score": risk_score
-        }
-    
-    def generate_social_proof(self, license_tier: str) -> str:
-        """Generate tier-specific social proof"""
-        proofs = self.social_proofs.get(license_tier, self.social_proofs["oss"])
-        return random.choice(proofs)
-    
-    def generate_scarcity_message(self, license_tier: str, days_remaining: int = 14) -> str:
-        """Generate scarcity messaging"""
-        if license_tier in self.scarcity_messages:
-            messages = self.scarcity_messages[license_tier]
-            message = random.choice(messages)
-            return message.format(days=days_remaining)
-        return ""
-    
-    def generate_authority_signals(self, count: int = 3) -> List[str]:
-        """Generate authority signals"""
-        return random.sample(self.authority_signals, min(count, len(self.authority_signals)))
-    
-    def apply_prospect_theory(self, risk_score: float) -> float:
-        """
-        Apply Kahneman & Tversky's Prospect Theory:
-        - Losses loom larger than gains (λ ≈ 2.25)
-        - Value function is concave for gains, convex for losses
-        """
-        # For losses (risk > 0), apply convex weighting
-        if risk_score > 0:
-            # Diminishing sensitivity for losses
-            perceived_risk = risk_score ** 0.88
-            # Loss aversion coefficient (losses feel 2.25x worse)
-            perceived_risk *= 2.25
-        else:
-            # For gains, apply concave weighting
-            perceived_risk = -((-risk_score) ** 0.88)
-        
-        return min(1.0, max(0.0, perceived_risk))
-    
-    def generate_psychological_insights(self, risk_score: float, recommendation: str, license_tier: str) -> Dict:
-        """Generate comprehensive psychological insights"""
-        return {
-            "loss_aversion": self.generate_loss_aversion_message(risk_score),
-            "social_proof": self.generate_social_proof(license_tier),
-            "scarcity": self.generate_scarcity_message(license_tier),
-            "authority": self.generate_authority_signals(2),
-            "perceived_risk": self.apply_prospect_theory(risk_score),
-            "recommendation_impact": self._assess_recommendation_impact(recommendation),
-            "tier_motivation": self._generate_tier_motivation(license_tier, risk_score)
-        }
-    
-    def _assess_recommendation_impact(self, recommendation: str) -> str:
-        """Assess psychological impact of recommendation"""
-        if "BLOCKED" in recommendation or "HIGH RISK" in recommendation:
-            return "high_anxiety"
-        elif "REQUIRES APPROVAL" in recommendation or "MODERATE RISK" in recommendation:
-            return "moderate_concern"
-        else:
-            return "low_concern"
-    
-    def _generate_tier_motivation(self, current_tier: str, risk_score: float) -> Dict:
-        """Generate motivation to upgrade from current tier"""
-        if current_tier == "oss":
-            return {
-                "target_tier": "trial",
-                "value_prop": "Get mechanical gates for free",
-                "motivation": "fear_of_loss",
-                "urgency": "high" if risk_score > 0.5 else "medium"
-            }
-        elif current_tier == "trial":
-            return {
-                "target_tier": "starter",
-                "value_prop": "Keep mechanical gates after trial",
-                "motivation": "fear_of_loss",
-                "urgency": "high"
-            }
-        elif current_tier == "starter":
-            return {
-                "target_tier": "professional",
-                "value_prop": "Get 24/7 support and advanced gates",
-                "motivation": "aspiration",
-                "urgency": "medium"
-            }
-        elif current_tier == "professional":
-            return {
-                "target_tier": "enterprise",
-                "value_prop": "Enterprise features and dedicated support",
-                "motivation": "authority",
-                "urgency": "low"
-            }
-        else:
-            return {
-                "target_tier": None,
-                "value_prop": "You have the highest tier",
-                "motivation": None,
-                "urgency": None
-            }

utils/psychology_layer_enhanced.py

@@ -0,0 +1,689 @@
+"""
+Enhanced Psychology Layer with Prospect Theory Mathematics
+PhD-Level Psychological Optimization for Investor Demos
+"""
+
+import random
+import numpy as np
+from typing import Dict, List, Tuple, Any
+from dataclasses import dataclass
+from enum import Enum
+
+class PsychologicalPrinciple(Enum):
+    """Psychological principles with mathematical implementations"""
+    LOSS_AVERSION = "loss_aversion"
+    PROSPECT_THEORY = "prospect_theory"
+    SOCIAL_PROOF = "social_proof"
+    SCARCITY = "scarcity"
+    AUTHORITY = "authority"
+    ANCHORING = "anchoring"
+
+@dataclass
+class ProspectTheoryParameters:
+    """Kahneman & Tversky's Prospect Theory parameters"""
+    alpha: float = 0.88      # Risk aversion for gains (0 ≤ α ≤ 1)
+    beta: float = 0.88       # Risk seeking for losses (0 ≤ β ≤ 1)
+    lambda_param: float = 2.25  # Loss aversion coefficient (λ > 1)
+    gamma: float = 0.61      # Probability weighting for gains
+    delta: float = 0.69      # Probability weighting for losses
+    
+    def __post_init__(self):
+        """Validate parameters"""
+        assert 0 < self.alpha <= 1, "Alpha must be between 0 and 1"
+        assert 0 < self.beta <= 1, "Beta must be between 0 and 1"
+        assert self.lambda_param > 1, "Lambda must be greater than 1"
+        assert 0 < self.gamma <= 1, "Gamma must be between 0 and 1"
+        assert 0 < self.delta <= 1, "Delta must be between 0 and 1"
+
+class ProspectTheoryEngine:
+    """Mathematical implementation of Kahneman & Tversky's Prospect Theory"""
+    
+    def __init__(self, params: ProspectTheoryParameters = None):
+        self.params = params or ProspectTheoryParameters()
+        
+    def value_function(self, x: float) -> float:
+        """
+        Kahneman & Tversky's value function:
+        v(x) = { x^α if x ≥ 0, -λ(-x)^β if x < 0 }
+        
+        For risk scores (always positive loss domain):
+        perceived_loss = risk_score^α * λ
+        """
+        if x >= 0:
+            # Gains domain (not typically used for risk)
+            return x ** self.params.alpha
+        else:
+            # Loss domain (risk is always positive loss)
+            return -self.params.lambda_param * ((-x) ** self.params.beta)
+    
+    def probability_weighting(self, p: float, is_gain: bool = False) -> float:
+        """
+        Probability weighting function π(p)
+        Overweights small probabilities, underweights large probabilities
+        
+        π(p) = p^γ / (p^γ + (1-p)^γ)^(1/γ) for gains
+        π(p) = p^δ / (p^δ + (1-p)^δ)^(1/δ) for losses
+        """
+        if p == 0:
+            return 0
+        if p == 1:
+            return 1
+        
+        gamma = self.params.gamma if is_gain else self.params.delta
+        
+        numerator = p ** gamma
+        denominator = (p ** gamma + (1 - p) ** gamma) ** (1 / gamma)
+        
+        return numerator / denominator
+    
+    def weighted_perceived_risk(self, risk_score: float) -> float:
+        """
+        Calculate prospect-theory weighted perceived risk
+        Combines value function with probability weighting
+        """
+        # Loss domain (risk is always positive loss)
+        base_value = self.value_function(-risk_score)  # Negative because it's a loss
+        
+        # Probability weighting for losses
+        weighted_prob = self.probability_weighting(risk_score, is_gain=False)
+        
+        # Combine
+        perceived_risk = abs(base_value) * weighted_prob
+        
+        return min(1.0, perceived_risk)
+    
+    def calculate_psychological_impact(self, risk_score: float, license_tier: str) -> Dict[str, Any]:
+        """
+        Multi-dimensional psychological impact calculation
+        Based on Prospect Theory with tier-specific adjustments
+        """
+        # Base perceived risk using Prospect Theory
+        perceived_risk = self.weighted_perceived_risk(risk_score)
+        
+        # License-tier anxiety multiplier (enterprise reduces anxiety)
+        anxiety_multipliers = {
+            'oss': 1.3,      # Higher anxiety without protection
+            'trial': 1.0,    # Balanced with temporary protection
+            'starter': 0.9,  # Some protection
+            'professional': 0.8, # Good protection
+            'enterprise': 0.7  # Full protection
+        }
+        
+        final_anxiety = perceived_risk * anxiety_multipliers.get(license_tier, 1.0)
+        
+        # Conversion probability based on anxiety and tier (sigmoid function)
+        # Higher anxiety → higher conversion probability up to a point
+        conversion_probability = self._sigmoid_conversion(final_anxiety, license_tier)
+        
+        # Urgency score (derivative of anxiety)
+        urgency_score = min(1.0, final_anxiety * 1.2)
+        
+        # Loss aversion weight (tier-specific)
+        loss_aversion_weight = self.params.lambda_param * (1 + (license_tier == 'oss') * 0.5)
+        
+        return {
+            'perceived_risk': round(perceived_risk, 3),
+            'anxiety_level': round(final_anxiety, 3),
+            'conversion_probability': round(conversion_probability, 3),
+            'urgency_score': round(urgency_score, 3),
+            'loss_aversion_weight': round(loss_aversion_weight, 2),
+            'psychological_impact_category': self._categorize_impact(final_anxiety),
+            'prospect_theory_parameters': {
+                'alpha': self.params.alpha,
+                'beta': self.params.beta,
+                'lambda': self.params.lambda_param,
+                'gamma': self.params.gamma,
+                'delta': self.params.delta
+            }
+        }
+    
+    def _sigmoid_conversion(self, anxiety: float, license_tier: str) -> float:
+        """Sigmoid function for conversion probability"""
+        # Base conversion curve
+        x = (anxiety - 0.5) * 3  # Center at 0.5 anxiety, scale by 3
+        
+        # Sigmoid with tier-specific adjustments
+        base_sigmoid = 1 / (1 + np.exp(-x))
+        
+        # Tier multipliers (enterprise users convert more easily)
+        tier_multipliers = {
+            'oss': 0.6,
+            'trial': 0.8,
+            'starter': 0.85,
+            'professional': 0.9,
+            'enterprise': 0.95
+        }
+        
+        multiplier = tier_multipliers.get(license_tier, 0.8)
+        converted = base_sigmoid * multiplier
+        
+        # Add minimum conversion probability
+        return min(0.95, max(0.1, converted))
+    
+    def _categorize_impact(self, anxiety: float) -> str:
+        """Categorize psychological impact"""
+        if anxiety > 0.8:
+            return "CRITICAL_IMPACT"
+        elif anxiety > 0.6:
+            return "HIGH_IMPACT"
+        elif anxiety > 0.4:
+            return "MODERATE_IMPACT"
+        elif anxiety > 0.2:
+            return "LOW_IMPACT"
+        else:
+            return "MINIMAL_IMPACT"
+
+class BayesianSocialProofEngine:
+    """Bayesian social proof optimization with credibility updating"""
+    
+    def __init__(self):
+        # Beta distribution priors for different proof types
+        # α = successes + 1, β = failures + 1
+        self.priors = {
+            'fortune_500': (9, 2),    # α=9, β=2 → 82% prior credibility
+            'scaleup': (7, 4),        # α=7, β=4 → 64% prior credibility
+            'developer_count': (8, 3), # α=8, β=3 → 73% prior credibility
+            'savings': (10, 1),       # α=10, β=1 → 91% prior credibility
+            'incident_reduction': (9, 2), # 82% prior credibility
+            'compliance': (8, 2),     # 80% prior credibility
+        }
+        
+        # User type profiles with likelihood weights
+        self.user_profiles = {
+            'engineer': {
+                'fortune_500': 0.6,
+                'scaleup': 0.8,
+                'developer_count': 0.9,
+                'savings': 0.7,
+                'incident_reduction': 0.95,
+                'compliance': 0.5
+            },
+            'executive': {
+                'fortune_500': 0.9,
+                'savings': 0.95,
+                'scaleup': 0.7,
+                'incident_reduction': 0.85,
+                'compliance': 0.9,
+                'developer_count': 0.4
+            },
+            'investor': {
+                'savings': 0.9,
+                'fortune_500': 0.85,
+                'growth': 0.8,
+                'incident_reduction': 0.75,
+                'compliance': 0.7,
+                'scaleup': 0.6
+            },
+            'compliance_officer': {
+                'compliance': 0.95,
+                'fortune_500': 0.8,
+                'incident_reduction': 0.85,
+                'savings': 0.6,
+                'developer_count': 0.3,
+                'scaleup': 0.4
+            }
+        }
+        
+        # Proof templates
+        self.proof_templates = {
+            'fortune_500': {
+                'title': '🏢 Trusted by Fortune 500',
+                'message': 'Deployed at 50+ Fortune 500 companies including FAANG',
+                'icon': '🏢',
+                'credibility_baseline': 0.85
+            },
+            'scaleup': {
+                'title': '🚀 Scale-up Proven',
+                'message': 'Trusted by 200+ high-growth tech scale-ups',
+                'icon': '🚀',
+                'credibility_baseline': 0.75
+            },
+            'developer_count': {
+                'title': '👨‍💻 Developer Love',
+                'message': 'Join 1,000+ active developers using ARF for AI safety',
+                'icon': '👨‍💻',
+                'credibility_baseline': 0.8
+            },
+            'savings': {
+                'title': '💰 Proven Savings',
+                'message': 'Average $3.9M breach cost prevented, 92% incident reduction',
+                'icon': '💰',
+                'credibility_baseline': 0.9
+            },
+            'incident_reduction': {
+                'title': '🛡️ Risk Reduction',
+                'message': '92% of incidents prevented with mechanical gates',
+                'icon': '🛡️',
+                'credibility_baseline': 0.88
+            },
+            'compliance': {
+                'title': '📋 Compliance Ready',
+                'message': 'SOC 2, GDPR, ISO 27001 certified with zero findings',
+                'icon': '📋',
+                'credibility_baseline': 0.82
+            }
+        }
+    
+    def get_optimized_proof(self, user_type: str, license_tier: str, 
+                          risk_context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Get psychologically optimized social proof using Bayesian updating
+        """
+        user_type = user_type if user_type in self.user_profiles else 'engineer'
+        user_profile = self.user_profiles[user_type]
+        
+        # Calculate posterior credibility for each proof type
+        posteriors = {}
+        for proof_type, (alpha_prior, beta_prior) in self.priors.items():
+            if proof_type not in user_profile:
+                continue
+            
+            likelihood = user_profile[proof_type]
+            
+            # Bayesian update: Posterior = Beta(α + successes, β + failures)
+            # successes = likelihood * 10, failures = (1 - likelihood) * 10
+            successes = likelihood * 10
+            failures = (1 - likelihood) * 10
+            
+            posterior_alpha = alpha_prior + successes
+            posterior_beta = beta_prior + failures
+            
+            posterior_mean = posterior_alpha / (posterior_alpha + posterior_beta)
+            posterior_variance = (posterior_alpha * posterior_beta) / \
+                               ((posterior_alpha + posterior_beta) ** 2 * \
+                                (posterior_alpha + posterior_beta + 1))
+            
+            posteriors[proof_type] = {
+                'credibility': posterior_mean,
+                'confidence': 1 - posterior_variance,
+                'alpha': posterior_alpha,
+                'beta': posterior_beta,
+                'likelihood': likelihood
+            }
+        
+        if not posteriors:
+            return self._get_default_proof(license_tier)
+        
+        # Select proof with highest credibility
+        best_proof_type = max(posteriors.items(), key=lambda x: x[1]['credibility'])[0]
+        best_proof_data = posteriors[best_proof_type]
+        
+        return self._format_proof(
+            best_proof_type, 
+            best_proof_data, 
+            user_type, 
+            license_tier, 
+            risk_context
+        )
+    
+    def _format_proof(self, proof_type: str, proof_data: Dict[str, Any],
+                     user_type: str, license_tier: str, 
+                     risk_context: Dict[str, Any]) -> Dict[str, Any]:
+        """Format social proof with credibility metrics"""
+        template = self.proof_templates.get(
+            proof_type, 
+            self.proof_templates['developer_count']
+        )
+        
+        # Adjust message based on license tier
+        tier_adjustments = {
+            'trial': "Start your free trial today",
+            'starter': "Upgrade to Starter for mechanical gates",
+            'professional': "Professional includes 24/7 support",
+            'enterprise': "Enterprise includes dedicated support"
+        }
+        
+        adjusted_message = f"{template['message']}. {tier_adjustments.get(license_tier, '')}"
+        
+        return {
+            **template,
+            'message': adjusted_message,
+            'proof_type': proof_type,
+            'credibility': round(proof_data['credibility'], 3),
+            'confidence': round(proof_data['confidence'], 3),
+            'credibility_interval': self._calculate_credibility_interval(
+                proof_data['alpha'], proof_data['beta']
+            ),
+            'optimized_for': user_type,
+            'recommended_for_tier': license_tier,
+            'risk_context_match': self._assess_risk_context_match(proof_type, risk_context),
+            'bayesian_parameters': {
+                'prior_alpha': self.priors[proof_type][0],
+                'prior_beta': self.priors[proof_type][1],
+                'posterior_alpha': proof_data['alpha'],
+                'posterior_beta': proof_data['beta'],
+                'likelihood': proof_data['likelihood']
+            }
+        }
+    
+    def _calculate_credibility_interval(self, alpha: float, beta: float, 
+                                       confidence: float = 0.95) -> Tuple[float, float]:
+        """Calculate credibility interval for Beta distribution"""
+        # Simplified calculation for demo
+        mean = alpha / (alpha + beta)
+        variance = (alpha * beta) / ((alpha + beta) ** 2 * (alpha + beta + 1))
+        std_dev = np.sqrt(variance)
+        
+        # Approximate 95% interval
+        lower = max(0, mean - 1.96 * std_dev)
+        upper = min(1, mean + 1.96 * std_dev)
+        
+        return round(lower, 3), round(upper, 3)
+    
+    def _assess_risk_context_match(self, proof_type: str, risk_context: Dict[str, Any]) -> float:
+        """Assess how well proof matches risk context"""
+        risk_score = risk_context.get('risk_score', 0.5)
+        risk_category = risk_context.get('risk_category', 'MEDIUM')
+        
+        # Proof effectiveness by risk level
+        effectiveness = {
+            'fortune_500': {'LOW': 0.7, 'MEDIUM': 0.8, 'HIGH': 0.9, 'CRITICAL': 0.95},
+            'savings': {'LOW': 0.6, 'MEDIUM': 0.8, 'HIGH': 0.9, 'CRITICAL': 0.95},
+            'incident_reduction': {'LOW': 0.5, 'MEDIUM': 0.7, 'HIGH': 0.85, 'CRITICAL': 0.9},
+            'compliance': {'LOW': 0.6, 'MEDIUM': 0.7, 'HIGH': 0.8, 'CRITICAL': 0.85},
+            'developer_count': {'LOW': 0.8, 'MEDIUM': 0.7, 'HIGH': 0.6, 'CRITICAL': 0.5},
+            'scaleup': {'LOW': 0.7, 'MEDIUM': 0.75, 'HIGH': 0.8, 'CRITICAL': 0.7}
+        }
+        
+        return effectiveness.get(proof_type, {}).get(risk_category, 0.7)
+    
+    def _get_default_proof(self, license_tier: str) -> Dict[str, Any]:
+        """Get default social proof"""
+        return {
+            'title': '👨‍💻 Developer Trusted',
+            'message': 'Join 1,000+ developers using ARF for AI safety',
+            'icon': '👨‍💻',
+            'credibility': 0.8,
+            'confidence': 0.7,
+            'proof_type': 'default',
+            'optimized_for': 'default',
+            'recommended_for_tier': license_tier,
+            'risk_context_match': 0.7,
+            'credibility_interval': (0.72, 0.88)
+        }
+
+class EnhancedPsychologyEngine:
+    """Complete psychology engine combining all principles"""
+    
+    def __init__(self):
+        self.prospect_theory = ProspectTheoryEngine()
+        self.social_proof = BayesianSocialProofEngine()
+        
+        # Loss aversion scenarios with financial impact
+        self.loss_scenarios = {
+            "CRITICAL": [
+                {"text": "Data breach ($3.9M average cost)", "impact": 3900000},
+                {"text": "Service disruption ($300k/hour)", "impact": 7200000},
+                {"text": "Compliance fines (up to $20M)", "impact": 20000000},
+                {"text": "Reputational damage (6+ months recovery)", "impact": 5000000}
+            ],
+            "HIGH": [
+                {"text": "Data corruption (24h recovery)", "impact": 1000000},
+                {"text": "Performance degradation (50% slower)", "impact": 500000},
+                {"text": "Security vulnerability exposure", "impact": 750000},
+                {"text": "Customer churn (15% increase)", "impact": 1500000}
+            ],
+            "MEDIUM": [
+                {"text": "Increased operational overhead", "impact": 250000},
+                {"text": "Manual review delays (2+ hours)", "impact": 150000},
+                {"text": "Team productivity loss (20%)", "impact": 300000},
+                {"text": "Audit findings & remediation", "impact": 200000}
+            ],
+            "LOW": [
+                {"text": "Minor configuration drift", "impact": 50000},
+                {"text": "Documentation gaps", "impact": 25000},
+                {"text": "Process inefficiencies", "impact": 75000},
+                {"text": "Training requirements", "impact": 100000}
+            ]
+        }
+        
+        # Scarcity messaging with mathematical decay
+        self.scarcity_patterns = {
+            "trial": {
+                "base_urgency": 0.8,
+                "decay_rate": 0.07,  # per day
+                "messages": [
+                    "⏳ {days} days remaining in free trial",
+                    "🎁 Trial ends in {days} days - upgrade to keep mechanical gates",
+                    "⚠️ Free access expires in {days} days"
+                ]
+            },
+            "starter": {
+                "base_urgency": 0.6,
+                "decay_rate": 0.05,
+                "messages": [
+                    "💰 Special pricing ends in {days} days",
+                    "👥 Limited seats at current price",
+                    "⏰ Quarterly offer expires soon"
+                ]
+            }
+        }
+        
+        # Authority signals with credibility scores
+        self.authority_signals = [
+            {"text": "SOC 2 Type II Certified", "credibility": 0.95, "audience": ["executive", "compliance"]},
+            {"text": "GDPR & CCPA Compliant", "credibility": 0.9, "audience": ["compliance", "executive"]},
+            {"text": "ISO 27001 Certified", "credibility": 0.92, "audience": ["executive", "compliance"]},
+            {"text": "99.9% SLA Guarantee", "credibility": 0.88, "audience": ["engineer", "executive"]},
+            {"text": "24/7 Dedicated Support", "credibility": 0.85, "audience": ["engineer", "executive"]},
+            {"text": "On-prem Deployment Available", "credibility": 0.87, "audience": ["executive", "compliance"]},
+            {"text": "Fortune 500 Deployed", "credibility": 0.93, "audience": ["executive", "investor"]},
+            {"text": "Venture Backed", "credibility": 0.8, "audience": ["investor", "executive"]}
+        ]
+    
+    def generate_comprehensive_insights(self, risk_score: float, risk_category: str,
+                                       license_tier: str, user_type: str = "engineer",
+                                       days_remaining: int = 14) -> Dict[str, Any]:
+        """
+        Generate comprehensive psychological insights for investor demos
+        """
+        # Prospect Theory impact
+        prospect_impact = self.prospect_theory.calculate_psychological_impact(
+            risk_score, license_tier
+        )
+        
+        # Social proof optimization
+        social_proof = self.social_proof.get_optimized_proof(
+            user_type, license_tier, 
+            {"risk_score": risk_score, "risk_category": risk_category}
+        )
+        
+        # Loss aversion framing
+        loss_aversion = self._generate_loss_aversion_framing(risk_category, risk_score)
+        
+        # Scarcity messaging
+        scarcity = self._generate_scarcity_message(license_tier, days_remaining)
+        
+        # Authority signals
+        authority = self._generate_authority_signals(user_type)
+        
+        # Anchoring effect (reference pricing)
+        anchoring = self._generate_anchoring_effect(license_tier)
+        
+        # Conversion prediction
+        conversion_prediction = self._predict_conversion(
+            prospect_impact['anxiety_level'],
+            social_proof['credibility'],
+            scarcity.get('urgency', 0.5),
+            license_tier
+        )
+        
+        return {
+            "prospect_theory_impact": prospect_impact,
+            "optimized_social_proof": social_proof,
+            "loss_aversion_framing": loss_aversion,
+            "scarcity_signaling": scarcity,
+            "authority_signals": authority,
+            "anchoring_effects": anchoring,
+            "conversion_prediction": conversion_prediction,
+            "psychological_summary": self._generate_psychological_summary(
+                prospect_impact, social_proof, loss_aversion
+            ),
+            "user_type": user_type,
+            "license_tier": license_tier,
+            "risk_context": {
+                "score": risk_score,
+                "category": risk_category,
+                "perceived_impact": prospect_impact['perceived_risk']
+            }
+        }
+    
+    def _generate_loss_aversion_framing(self, risk_category: str, risk_score: float) -> Dict[str, Any]:
+        """Generate loss aversion framing with financial impact"""
+        scenarios = self.loss_scenarios.get(risk_category, self.loss_scenarios["MEDIUM"])
+        
+        # Select scenarios based on risk score
+        num_scenarios = min(3, int(risk_score * 4) + 1)
+        selected = random.sample(scenarios, min(num_scenarios, len(scenarios)))
+        
+        # Calculate total potential impact
+        total_impact = sum(s["impact"] for s in selected)
+        
+        return {
+            "title": f"🚨 Without Enterprise protection, you risk:",
+            "scenarios": [s["text"] for s in selected],
+            "total_potential_impact": f"${total_impact:,.0f}",
+            "average_scenario_impact": f"${total_impact/len(selected):,.0f}",
+            "risk_category": risk_category,
+            "psychological_impact": "HIGH" if risk_category in ["CRITICAL", "HIGH"] else "MODERATE"
+        }
+    
+    def _generate_scarcity_message(self, license_tier: str, days_remaining: int) -> Dict[str, Any]:
+        """Generate scarcity messaging with mathematical urgency"""
+        if license_tier not in self.scarcity_patterns:
+            return {"message": "", "urgency": 0.0}
+        
+        pattern = self.scarcity_patterns[license_tier]
+        
+        # Calculate urgency with decay
+        urgency = pattern["base_urgency"] * (1 - pattern["decay_rate"] * (14 - days_remaining))
+        urgency = max(0.1, min(0.95, urgency))
+        
+        # Select message
+        message_template = random.choice(pattern["messages"])
+        message = message_template.format(days=days_remaining)
+        
+        return {
+            "message": message,
+            "urgency": round(urgency, 2),
+            "days_remaining": days_remaining,
+            "urgency_category": "HIGH" if urgency > 0.7 else "MEDIUM" if urgency > 0.4 else "LOW"
+        }
+    
+    def _generate_authority_signals(self, user_type: str, count: int = 3) -> List[Dict[str, Any]]:
+        """Generate authority signals optimized for user type"""
+        # Filter signals for user type
+        relevant_signals = [
+            s for s in self.authority_signals 
+            if user_type in s["audience"]
+        ]
+        
+        # Sort by credibility
+        relevant_signals.sort(key=lambda x: x["credibility"], reverse=True)
+        
+        # Select top signals
+        selected = relevant_signals[:count]
+        
+        return [
+            {
+                "text": s["text"],
+                "credibility": s["credibility"],
+                "relevance_to_user": "HIGH" if user_type in s["audience"] else "MEDIUM",
+                "formatted": f"✓ {s['text']} ({s['credibility']:.0%} credibility)"
+            }
+            for s in selected
+        ]
+    
+    def _generate_anchoring_effect(self, current_tier: str) -> Dict[str, Any]:
+        """Generate anchoring effects for pricing"""
+        tier_prices = {
+            "oss": 0,
+            "trial": 0,
+            "starter": 2000,
+            "professional": 5000,
+            "enterprise": 15000
+        }
+        
+        current_price = tier_prices.get(current_tier, 0)
+        
+        # Generate reference prices (anchors)
+        anchors = []
+        for tier, price in tier_prices.items():
+            if price > current_price:
+                discount = ((price - current_price) / price) * 100
+                anchors.append({
+                    "reference_tier": tier,
+                    "reference_price": price,
+                    "discount_percentage": round(discount, 1),
+                    "anchor_strength": "STRONG" if discount > 50 else "MODERATE"
+                })
+        
+        # Select strongest anchor
+        if anchors:
+            strongest_anchor = max(anchors, key=lambda x: x["discount_percentage"])
+        else:
+            strongest_anchor = {
+                "reference_tier": "enterprise",
+                "reference_price": 15000,
+                "discount_percentage": 100.0,
+                "anchor_strength": "MAXIMUM"
+            }
+        
+        return {
+            "current_tier": current_tier,
+            "current_price": current_price,
+            "anchors": anchors,
+            "strongest_anchor": strongest_anchor,
+            "perceived_value": f"{strongest_anchor['discount_percentage']:.0f}% discount vs {strongest_anchor['reference_tier']}",
+            "anchoring_effect_strength": strongest_anchor["anchor_strength"]
+        }
+    
+    def _predict_conversion(self, anxiety: float, social_credibility: float,
+                           scarcity_urgency: float, license_tier: str) -> Dict[str, Any]:
+        """Predict conversion probability using multiple factors"""
+        # Base conversion probability
+        base_prob = anxiety * 0.6 + social_credibility * 0.3 + scarcity_urgency * 0.1
+        
+        # Tier adjustment
+        tier_multipliers = {
+            'oss': 1.0,
+            'trial': 1.2,
+            'starter': 1.1,
+            'professional': 1.0,
+            'enterprise': 0.8
+        }
+        
+        adjusted_prob = base_prob * tier_multipliers.get(license_tier, 1.0)
+        adjusted_prob = min(0.95, max(0.05, adjusted_prob))
+        
+        # Confidence interval
+        std_error = np.sqrt(adjusted_prob * (1 - adjusted_prob) / 100)  # Assuming 100 samples
+        ci_lower = max(0, adjusted_prob - 1.96 * std_error)
+        ci_upper = min(1, adjusted_prob + 1.96 * std_error)
+        
+        return {
+            "conversion_probability": round(adjusted_prob, 3),
+            "confidence_interval": (round(ci_lower, 3), round(ci_upper, 3)),
+            "confidence_width": round(ci_upper - ci_lower, 3),
+            "key_factors": {
+                "anxiety_contribution": round(anxiety * 0.6, 3),
+                "social_proof_contribution": round(social_credibility * 0.3, 3),
+                "scarcity_contribution": round(scarcity_urgency * 0.1, 3)
+            },
+            "prediction_quality": "HIGH" if (ci_upper - ci_lower) < 0.2 else "MODERATE"
+        }
+    
+    def _generate_psychological_summary(self, prospect_impact: Dict,
+                                       social_proof: Dict, loss_aversion: Dict) -> str:
+        """Generate psychological summary for investors"""
+        anxiety = prospect_impact.get('anxiety_level', 0.5)
+        credibility = social_proof.get('credibility', 0.7)
+        
+        if anxiety > 0.7 and credibility > 0.8:
+            return "HIGH CONVERSION POTENTIAL: Strong anxiety combined with credible social proof creates ideal conversion conditions."
+        elif anxiety > 0.5:
+            return "GOOD CONVERSION POTENTIAL: Moderate anxiety levels with supporting social proof suggest healthy conversion rates."
+        elif credibility > 0.85:
+            return "STRONG SOCIAL PROOF: High credibility signals will drive conversions even with lower anxiety levels."
+        else:
+            return "BASIC CONVERSION SETUP: Standard psychological triggers in place. Consider increasing urgency or social proof."