DDD Model: ResponsePersonalityEnhancer

@dataclass
class PersonalityProfile:
    """User's preferred personality configuration"""
    id: str
    user_id: str
    warmth_level: float  # 0.0 (professional) to 1.0 (friendly)
    confidence_style: ConfidenceDisplayStyle  # NUMERIC, DESCRIPTIVE, CONTEXTUAL, HIDDEN
    action_orientation: ActionLevel  # HIGH, MEDIUM, LOW
    technical_depth: TechnicalPreference  # DETAILED, BALANCED, SIMPLIFIED
    created_at: datetime
    updated_at: datetime

    def adjust_for_context(self, context: ResponseContext) -> 'PersonalityProfile':
        """Create context-adjusted profile without mutating original"""
        pass

@dataclass
class ResponseContext:
    """Context for response enhancement"""
    intent_confidence: float  # From Intent (0.0-1.0)
    intent_category: IntentCategory
    intent_action: str
    response_type: ResponseType  # STANDUP, CHAT, CLI, WEB, ERROR
    user_stress_indicators: List[str]  # deadline pressure, error recovery, etc.
    conversation_history: Optional[List[Message]]

@dataclass
class EnhancedResponse:
    """Response after personality enhancement"""
    original_content: str
    enhanced_content: str
    personality_profile_used: PersonalityProfile
    confidence_displayed: Optional[float]
    enhancements_applied: List[Enhancement]
    processing_time_ms: float

class ConfidenceDisplayStyle(Enum):
    NUMERIC = "numeric"  # "87% confident"
    DESCRIPTIVE = "descriptive"  # "high confidence"
    CONTEXTUAL = "contextual"  # "Based on recent patterns..."
    HIDDEN = "hidden"  # No confidence shown

class ActionLevel(Enum):
    HIGH = "high"  # Every response has explicit next steps
    MEDIUM = "medium"  # Actionable when relevant
    LOW = "low"  # Minimal action orientation

class ResponseType(Enum):
    STANDUP = "standup"
    CHAT = "chat"
    CLI = "cli"
    WEB = "web"
    ERROR = "error"

class Enhancement(Enum):
    WARMTH_ADDED = "warmth_added"
    CONFIDENCE_INJECTED = "confidence_injected"
    ACTION_EXTRACTED = "action_extracted"
    CONTEXT_ADAPTED = "context_adapted"
    ERROR_SOFTENED = "error_softened"

class ResponsePersonalityEnhancer:
    """Aggregate root for personality enhancement"""

    def __init__(self,
                 profile_repository: PersonalityProfileRepository,
                 transformation_rules: TransformationRuleSet):
        self.profile_repository = profile_repository
        self.transformation_rules = transformation_rules
        self.metrics_collector = MetricsCollector()

    async def enhance_response(self,
                              content: str,
                              context: ResponseContext,
                              user_id: str) -> EnhancedResponse:
        """Core domain operation"""
        # 1. Load or create personality profile
        profile = await self._get_profile(user_id)

        # 2. Adjust profile for context
        adjusted_profile = profile.adjust_for_context(context)

        # 3. Apply transformations
        enhanced = await self._apply_transformations(
            content, adjusted_profile, context
        )

        # 4. Record metrics
        self.metrics_collector.record(enhanced)

        return enhanced

    def _apply_transformations(self, content, profile, context):
        """Apply personality transformations in order"""
        # Order matters: warmth → confidence → actions
        pass

class TransformationService:
    """Domain service for content transformation"""

    def add_warmth(self, content: str, warmth_level: float) -> str:
        """Add appropriate warmth without losing professionalism"""
        pass

    def inject_confidence(self,
                         content: str,
                         confidence: float,
                         style: ConfidenceDisplayStyle) -> str:
        """Add confidence indicators based on intent confidence"""
        pass

    def extract_actions(self, content: str, action_level: ActionLevel) -> str:
        """Make response actionable with clear next steps"""
        pass

class StandupToChatBridge:
    """Service to unify standup and chat experiences"""

    def adapt_standup_for_chat(self, standup_response: str) -> str:
        """Transform standup HTML/markdown for conversational UI"""
        pass

    def apply_personality_to_standup(self,
                                    standup_data: dict,
                                    profile: PersonalityProfile) -> str:
        """Apply personality to standup-specific formatting"""
        pass

class PersonalityProfileRepository:
    """Repository for personality profiles"""

    async def get_by_user_id(self, user_id: str) -> Optional[PersonalityProfile]:
        pass

    async def save(self, profile: PersonalityProfile) -> None:
        pass

    async def get_default(self) -> PersonalityProfile:
        """Return default Piper personality"""
        pass

class TemplateCompatibilityLayer:
    """Ensure personality enhancement doesn't break existing templates"""

    def validate_enhanced_response(self,
                                  original: str,
                                  enhanced: str) -> bool:
        """Ensure critical information preserved"""
        # Check: issue numbers, URLs, data values maintained
        # Check: markdown/HTML structure intact
        # Check: action buttons/links functional
        pass

class PersonalityEnhancementCompleted:
    """Event when response enhanced"""
    response_id: str
    user_id: str
    enhancements_applied: List[Enhancement]
    processing_time_ms: float
    confidence_level: float

class PersonalityProfileUpdated:
    """Event when user updates preferences"""
    user_id: str
    changes: Dict[str, Any]

class LowConfidenceResponseDetected:
    """Event for responses below confidence threshold"""
    response_id: str
    confidence: float
    context: ResponseContext