feat(notifications): implement comprehensive notification system

- Add email service with SMTP support and Jinja2 templates
- Implement webhook service with retry logic and signature verification
- Integrate notification channels (email, webhook, future push support)
- Create notification API endpoints for preferences and history
- Add email templates for various notification types
- Support notification filtering and batch operations
- Implement user preference management
- Add webhook configuration and testing endpoints

The notification system supports multiple channels, template-based emails,
secure webhook delivery, and comprehensive preference management.

Co-Authored-By: Claude <[email protected]>

src/api/app.py

@@ -20,7 +20,7 @@ from fastapi.openapi.utils import get_openapi
 from src.core import get_logger, settings
 from src.core.exceptions import CidadaoAIError, create_error_response
 from src.core.audit import audit_logger, AuditEventType, AuditSeverity, AuditContext
-from src.api.routes import investigations, analysis, reports, health, auth, oauth, audit, chat, websocket_chat, batch, graphql, cqrs, resilience, observability, chat_simple, chat_stable, chat_optimized, chat_emergency
+from src.api.routes import investigations, analysis, reports, health, auth, oauth, audit, chat, websocket_chat, batch, graphql, cqrs, resilience, observability, chat_simple, chat_stable, chat_optimized, chat_emergency, notifications
 from src.api.middleware.rate_limiting import RateLimitMiddleware
 from src.api.middleware.authentication import AuthenticationMiddleware
 from src.api.middleware.logging_middleware import LoggingMiddleware
@@ -349,6 +349,11 @@ app.include_router(
     tags=["Observability"]
 )
 
+app.include_router(
+    notifications.router,
+    tags=["Notifications"]
+)
+
 
 # Global exception handler
 @app.exception_handler(CidadaoAIError)

src/api/routes/__init__.py

@@ -6,6 +6,6 @@ Date: 2025-01-24
 License: Proprietary - All rights reserved
 """
 
-from . import health, investigations, analysis, reports, chat, websocket_chat, cqrs, resilience, observability, monitoring, chaos
+from . import health, investigations, analysis, reports, chat, websocket_chat, cqrs, resilience, observability, monitoring, chaos, notifications
 
-__all__ = ["health", "investigations", "analysis", "reports", "chat", "websocket_chat", "cqrs", "resilience", "observability", "monitoring", "chaos"]
+__all__ = ["health", "investigations", "analysis", "reports", "chat", "websocket_chat", "cqrs", "resilience", "observability", "monitoring", "chaos", "notifications"]

src/api/routes/notifications.py

@@ -0,0 +1,355 @@
+"""Notification API endpoints."""
+
+from typing import List, Optional, Dict, Any
+from fastapi import APIRouter, Depends, HTTPException, status, Query
+from pydantic import BaseModel, EmailStr, HttpUrl
+
+from src.services.notification_service import (
+    notification_service,
+    NotificationType,
+    NotificationLevel,
+    Notification
+)
+from src.services.webhook_service import webhook_service, WebhookConfig
+from src.models.notification_models import NotificationPreference
+from src.api.dependencies import get_current_user
+from src.core.logging import get_logger
+
+logger = get_logger(__name__)
+router = APIRouter(prefix="/api/v1/notifications", tags=["notifications"])
+
+
+class NotificationResponse(BaseModel):
+    """Notification response model."""
+    id: str
+    type: str
+    level: str
+    title: str
+    message: str
+    timestamp: str
+    read: bool
+    channels_sent: List[str]
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class NotificationPreferencesUpdate(BaseModel):
+    """Update notification preferences."""
+    enabled: Optional[bool] = None
+    email_enabled: Optional[bool] = None
+    webhook_enabled: Optional[bool] = None
+    push_enabled: Optional[bool] = None
+    frequency: Optional[str] = None
+    quiet_hours_start: Optional[str] = None
+    quiet_hours_end: Optional[str] = None
+    timezone: Optional[str] = None
+    type_preferences: Optional[Dict[str, Dict[str, Any]]] = None
+
+
+class WebhookConfigRequest(BaseModel):
+    """Webhook configuration request."""
+    url: HttpUrl
+    events: Optional[List[str]] = None
+    secret: Optional[str] = None
+    description: Optional[str] = None
+    headers: Optional[Dict[str, str]] = None
+
+
+class TestNotificationRequest(BaseModel):
+    """Test notification request."""
+    type: NotificationType = NotificationType.SYSTEM_ALERT
+    level: NotificationLevel = NotificationLevel.INFO
+    title: str = "Test Notification"
+    message: str = "This is a test notification from Cidadão.AI"
+    channels: Optional[List[str]] = None
+
+
+@router.get("", response_model=List[NotificationResponse])
+async def get_notifications(
+    unread_only: bool = Query(False, description="Filter unread notifications only"),
+    type: Optional[str] = Query(None, description="Filter by notification type"),
+    level: Optional[str] = Query(None, description="Filter by notification level"),
+    limit: int = Query(100, ge=1, le=500, description="Maximum notifications to return"),
+    current_user: dict = Depends(get_current_user)
+) -> List[NotificationResponse]:
+    """Get user notifications with filtering options."""
+    try:
+        # Parse filters
+        notification_type = NotificationType(type) if type else None
+        notification_level = NotificationLevel(level) if level else None
+        
+        # Get notifications
+        notifications = notification_service.get_notifications(
+            user_id=current_user["id"],
+            unread_only=unread_only,
+            type=notification_type,
+            level=notification_level,
+            limit=limit
+        )
+        
+        # Convert to response format
+        return [
+            NotificationResponse(
+                id=n.id,
+                type=n.type.value,
+                level=n.level.value,
+                title=n.title,
+                message=n.message,
+                timestamp=n.timestamp.isoformat(),
+                read=n.read,
+                channels_sent=n.channels_sent,
+                metadata=n.metadata
+            )
+            for n in notifications
+        ]
+        
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Invalid filter parameter: {str(e)}"
+        )
+    except Exception as e:
+        logger.error(f"Error getting notifications: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve notifications"
+        )
+
+
+@router.get("/unread-count")
+async def get_unread_count(
+    current_user: dict = Depends(get_current_user)
+) -> Dict[str, int]:
+    """Get count of unread notifications."""
+    notifications = notification_service.get_notifications(
+        user_id=current_user["id"],
+        unread_only=True
+    )
+    return {"unread_count": len(notifications)}
+
+
+@router.post("/{notification_id}/read")
+async def mark_as_read(
+    notification_id: str,
+    current_user: dict = Depends(get_current_user)
+) -> Dict[str, bool]:
+    """Mark a notification as read."""
+    success = notification_service.mark_as_read(notification_id)
+    
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Notification not found"
+        )
+        
+    return {"success": True}
+
+
+@router.post("/mark-all-read")
+async def mark_all_as_read(
+    current_user: dict = Depends(get_current_user)
+) -> Dict[str, Any]:
+    """Mark all notifications as read."""
+    count = notification_service.mark_all_as_read(current_user["id"])
+    return {"success": True, "marked_count": count}
+
+
+@router.delete("/{notification_id}")
+async def delete_notification(
+    notification_id: str,
+    current_user: dict = Depends(get_current_user)
+) -> Dict[str, bool]:
+    """Delete a notification."""
+    success = notification_service.delete_notification(notification_id)
+    
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Notification not found"
+        )
+        
+    return {"success": True}
+
+
+# Preferences endpoints
+@router.get("/preferences", response_model=Dict[str, Any])
+async def get_preferences(
+    current_user: dict = Depends(get_current_user)
+) -> Dict[str, Any]:
+    """Get user notification preferences."""
+    preferences = notification_service.get_user_preferences(current_user["id"])
+    
+    # Return default preferences if none exist
+    if not preferences:
+        preferences = {
+            "enabled": True,
+            "email_enabled": True,
+            "webhook_enabled": False,
+            "push_enabled": False,
+            "frequency": "immediate",
+            "type_preferences": {}
+        }
+        
+    return preferences
+
+
+@router.put("/preferences")
+async def update_preferences(
+    preferences: NotificationPreferencesUpdate,
+    current_user: dict = Depends(get_current_user)
+) -> Dict[str, Any]:
+    """Update user notification preferences."""
+    try:
+        # Get current preferences
+        current_prefs = notification_service.get_user_preferences(current_user["id"]) or {}
+        
+        # Update with new values
+        update_dict = preferences.dict(exclude_unset=True)
+        current_prefs.update(update_dict)
+        
+        # Save preferences
+        await notification_service.set_user_preferences(
+            current_user["id"],
+            current_prefs
+        )
+        
+        return {"success": True, "preferences": current_prefs}
+        
+    except Exception as e:
+        logger.error(f"Error updating preferences: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to update preferences"
+        )
+
+
+# Webhook endpoints
+@router.get("/webhooks", response_model=List[Dict[str, Any]])
+async def get_webhooks(
+    current_user: dict = Depends(get_current_user)
+) -> List[Dict[str, Any]]:
+    """Get user's webhook configurations."""
+    webhooks = webhook_service.list_webhooks()
+    
+    # Filter by user (in production, this would be from database)
+    return [
+        {
+            "url": str(w.url),
+            "events": w.events,
+            "active": w.active,
+            "max_retries": w.max_retries,
+            "timeout": w.timeout
+        }
+        for w in webhooks
+    ]
+
+
+@router.post("/webhooks")
+async def add_webhook(
+    webhook: WebhookConfigRequest,
+    current_user: dict = Depends(get_current_user)
+) -> Dict[str, Any]:
+    """Add a new webhook configuration."""
+    try:
+        config = WebhookConfig(
+            url=str(webhook.url),
+            events=webhook.events,
+            secret=webhook.secret,
+            headers=webhook.headers
+        )
+        
+        webhook_service.add_webhook(config)
+        
+        return {
+            "success": True,
+            "webhook": {
+                "url": str(config.url),
+                "events": config.events,
+                "active": config.active
+            }
+        }
+        
+    except Exception as e:
+        logger.error(f"Error adding webhook: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to add webhook"
+        )
+
+
+@router.delete("/webhooks")
+async def remove_webhook(
+    url: str = Query(..., description="Webhook URL to remove"),
+    current_user: dict = Depends(get_current_user)
+) -> Dict[str, bool]:
+    """Remove a webhook configuration."""
+    success = webhook_service.remove_webhook(url)
+    
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Webhook not found"
+        )
+        
+    return {"success": True}
+
+
+@router.post("/webhooks/test")
+async def test_webhook(
+    webhook: WebhookConfigRequest,
+    current_user: dict = Depends(get_current_user)
+) -> Dict[str, Any]:
+    """Test a webhook configuration."""
+    try:
+        config = WebhookConfig(
+            url=str(webhook.url),
+            secret=webhook.secret,
+            headers=webhook.headers
+        )
+        
+        delivery = await webhook_service.test_webhook(config)
+        
+        return {
+            "success": delivery.success,
+            "status_code": delivery.status_code,
+            "duration_ms": delivery.duration_ms,
+            "error": delivery.error
+        }
+        
+    except Exception as e:
+        logger.error(f"Error testing webhook: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to test webhook: {str(e)}"
+        )
+
+
+# Test endpoints
+@router.post("/test")
+async def send_test_notification(
+    request: TestNotificationRequest,
+    current_user: dict = Depends(get_current_user)
+) -> Dict[str, Any]:
+    """Send a test notification to the current user."""
+    try:
+        notification = await notification_service.send_notification(
+            user_id=current_user["id"],
+            type=request.type,
+            title=request.title,
+            message=request.message,
+            level=request.level,
+            channels=request.channels,
+            metadata={"test": True}
+        )
+        
+        return {
+            "success": True,
+            "notification_id": notification.id,
+            "channels_sent": notification.channels_sent
+        }
+        
+    except Exception as e:
+        logger.error(f"Error sending test notification: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to send test notification: {str(e)}"
+        )

src/models/notification_models.py

@@ -0,0 +1,233 @@
+"""Notification models for database persistence."""
+
+from datetime import datetime, timezone
+from typing import List, Optional, Dict, Any
+from enum import Enum
+from pydantic import BaseModel, Field, EmailStr
+from sqlalchemy import (
+    Column, String, Boolean, DateTime, JSON, Text,
+    Integer, ForeignKey, Table, Enum as SQLEnum
+)
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship
+
+Base = declarative_base()
+
+
+class NotificationChannel(str, Enum):
+    """Available notification channels."""
+    EMAIL = "email"
+    WEBHOOK = "webhook"
+    PUSH = "push"
+    SMS = "sms"
+    SLACK = "slack"
+
+
+class NotificationFrequency(str, Enum):
+    """Notification frequency preferences."""
+    IMMEDIATE = "immediate"
+    HOURLY = "hourly"
+    DAILY = "daily"
+    WEEKLY = "weekly"
+    MONTHLY = "monthly"
+    NEVER = "never"
+
+
+# Association table for user notification preferences
+user_notification_channels = Table(
+    'user_notification_channels',
+    Base.metadata,
+    Column('user_id', String, ForeignKey('users.id')),
+    Column('channel', SQLEnum(NotificationChannel)),
+    Column('notification_type', String),
+    Column('enabled', Boolean, default=True)
+)
+
+
+class NotificationPreferenceDB(Base):
+    """Notification preferences database model."""
+    __tablename__ = 'notification_preferences'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    user_id = Column(String, ForeignKey('users.id'), nullable=False)
+    
+    # Global preferences
+    enabled = Column(Boolean, default=True)
+    frequency = Column(SQLEnum(NotificationFrequency), default=NotificationFrequency.IMMEDIATE)
+    
+    # Channel-specific settings
+    email_enabled = Column(Boolean, default=True)
+    webhook_enabled = Column(Boolean, default=False)
+    push_enabled = Column(Boolean, default=False)
+    sms_enabled = Column(Boolean, default=False)
+    
+    # Type-specific preferences (JSON)
+    type_preferences = Column(JSON, default={})
+    
+    # Contact information
+    email_addresses = Column(JSON, default=[])  # List of emails
+    webhook_urls = Column(JSON, default=[])     # List of webhook configs
+    phone_numbers = Column(JSON, default=[])    # List of phone numbers
+    push_tokens = Column(JSON, default=[])      # List of push tokens
+    
+    # Time preferences
+    quiet_hours_start = Column(String)  # HH:MM format
+    quiet_hours_end = Column(String)    # HH:MM format
+    timezone = Column(String, default='America/Sao_Paulo')
+    
+    # Metadata
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+
+
+class NotificationPreference(BaseModel):
+    """Notification preferences Pydantic model."""
+    user_id: str
+    enabled: bool = True
+    frequency: NotificationFrequency = NotificationFrequency.IMMEDIATE
+    
+    # Channel settings
+    email_enabled: bool = True
+    webhook_enabled: bool = False
+    push_enabled: bool = False
+    sms_enabled: bool = False
+    
+    # Type-specific preferences
+    type_preferences: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
+    
+    # Contact information
+    email_addresses: List[EmailStr] = Field(default_factory=list)
+    webhook_urls: List[Dict[str, Any]] = Field(default_factory=list)
+    phone_numbers: List[str] = Field(default_factory=list)
+    push_tokens: List[str] = Field(default_factory=list)
+    
+    # Time preferences
+    quiet_hours_start: Optional[str] = None
+    quiet_hours_end: Optional[str] = None
+    timezone: str = "America/Sao_Paulo"
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "user_id": "user123",
+                "enabled": True,
+                "frequency": "immediate",
+                "email_enabled": True,
+                "webhook_enabled": True,
+                "type_preferences": {
+                    "anomaly_detected": {
+                        "enabled": True,
+                        "channels": ["email", "webhook"],
+                        "min_severity": "medium"
+                    },
+                    "investigation_complete": {
+                        "enabled": True,
+                        "channels": ["email"],
+                        "frequency": "daily"
+                    }
+                },
+                "email_addresses": ["[email protected]"],
+                "webhook_urls": [
+                    {
+                        "url": "https://example.com/webhook",
+                        "secret": "webhook_secret",
+                        "events": ["anomaly_detected"]
+                    }
+                ]
+            }
+        }
+
+
+class NotificationHistoryDB(Base):
+    """Notification history database model."""
+    __tablename__ = 'notification_history'
+    
+    id = Column(String, primary_key=True)
+    user_id = Column(String, ForeignKey('users.id'), nullable=False)
+    
+    # Notification details
+    type = Column(String, nullable=False)
+    level = Column(String, nullable=False)
+    title = Column(String, nullable=False)
+    message = Column(Text, nullable=False)
+    
+    # Delivery status
+    channels_requested = Column(JSON, default=[])
+    channels_delivered = Column(JSON, default=[])
+    delivery_status = Column(JSON, default={})  # Channel -> status mapping
+    
+    # Metadata
+    metadata = Column(JSON, default={})
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    read_at = Column(DateTime, nullable=True)
+    
+    # Error tracking
+    error_count = Column(Integer, default=0)
+    last_error = Column(Text, nullable=True)
+
+
+class NotificationHistory(BaseModel):
+    """Notification history Pydantic model."""
+    id: str
+    user_id: str
+    type: str
+    level: str
+    title: str
+    message: str
+    channels_requested: List[str] = Field(default_factory=list)
+    channels_delivered: List[str] = Field(default_factory=list)
+    delivery_status: Dict[str, str] = Field(default_factory=dict)
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+    created_at: datetime
+    read_at: Optional[datetime] = None
+    error_count: int = 0
+    last_error: Optional[str] = None
+
+
+class WebhookConfigDB(Base):
+    """Webhook configuration database model."""
+    __tablename__ = 'webhook_configs'
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    user_id = Column(String, ForeignKey('users.id'), nullable=False)
+    
+    # Webhook details
+    url = Column(String, nullable=False)
+    secret = Column(String, nullable=True)
+    description = Column(String, nullable=True)
+    
+    # Event filtering
+    events = Column(JSON, default=[])  # List of event types
+    active = Column(Boolean, default=True)
+    
+    # Headers and authentication
+    headers = Column(JSON, default={})
+    auth_type = Column(String, nullable=True)  # 'basic', 'bearer', 'custom'
+    auth_value = Column(String, nullable=True)
+    
+    # Retry configuration
+    max_retries = Column(Integer, default=3)
+    timeout_seconds = Column(Integer, default=30)
+    
+    # Metadata
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))
+    last_triggered_at = Column(DateTime, nullable=True)
+    success_count = Column(Integer, default=0)
+    failure_count = Column(Integer, default=0)
+
+
+class WebhookConfig(BaseModel):
+    """Webhook configuration Pydantic model."""
+    id: Optional[int] = None
+    user_id: str
+    url: str
+    secret: Optional[str] = None
+    description: Optional[str] = None
+    events: List[str] = Field(default_factory=list)
+    active: bool = True
+    headers: Dict[str, str] = Field(default_factory=dict)
+    auth_type: Optional[str] = None
+    auth_value: Optional[str] = None
+    max_retries: int = 3
+    timeout_seconds: int = 30

src/services/email_service.py

@@ -0,0 +1,395 @@
+"""Email service for sending notifications via SMTP.
+
+This service provides async email sending capabilities with support for:
+- HTML and plain text emails
+- Attachments
+- Multiple recipients (to, cc, bcc)
+- Email templates using Jinja2
+- Retry logic with exponential backoff
+- Connection pooling
+"""
+
+import asyncio
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.mime.base import MIMEBase
+from email import encoders
+import os
+from typing import List, Optional, Dict, Any, Union
+from pathlib import Path
+import aiosmtplib
+from email_validator import validate_email, EmailNotValidError
+from pydantic import BaseModel, EmailStr, Field, validator
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+import structlog
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+from src.core.config import settings
+from src.core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class EmailAttachment(BaseModel):
+    """Email attachment model."""
+    filename: str
+    content: Union[bytes, str]
+    content_type: str = "application/octet-stream"
+    
+    @validator("content")
+    def validate_content(cls, v):
+        """Ensure content is bytes."""
+        if isinstance(v, str):
+            return v.encode()
+        return v
+
+
+class EmailMessage(BaseModel):
+    """Email message model with validation."""
+    to: List[EmailStr]
+    subject: str
+    body: Optional[str] = None
+    html_body: Optional[str] = None
+    cc: Optional[List[EmailStr]] = None
+    bcc: Optional[List[EmailStr]] = None
+    reply_to: Optional[EmailStr] = None
+    attachments: Optional[List[EmailAttachment]] = None
+    headers: Optional[Dict[str, str]] = None
+    template: Optional[str] = None
+    template_data: Optional[Dict[str, Any]] = None
+    
+    @validator("to", "cc", "bcc", pre=True)
+    def validate_emails(cls, v):
+        """Validate email addresses."""
+        if v is None:
+            return v
+        if isinstance(v, str):
+            v = [v]
+        validated = []
+        for email in v:
+            try:
+                validated_email = validate_email(email)
+                validated.append(validated_email.email)
+            except EmailNotValidError as e:
+                logger.warning(f"Invalid email address: {email} - {e}")
+                continue
+        return validated
+    
+    @validator("body", always=True)
+    def validate_body(cls, v, values):
+        """Ensure at least one body type is provided."""
+        if not v and not values.get("html_body") and not values.get("template"):
+            raise ValueError("Either body, html_body, or template must be provided")
+        return v
+
+
+class SMTPConfig(BaseModel):
+    """SMTP configuration model."""
+    host: str = Field(default_factory=lambda: settings.smtp_host)
+    port: int = Field(default_factory=lambda: settings.smtp_port)
+    username: Optional[str] = Field(default_factory=lambda: settings.smtp_username)
+    password: Optional[str] = Field(default_factory=lambda: settings.smtp_password.get_secret_value() if settings.smtp_password else None)
+    use_tls: bool = Field(default_factory=lambda: settings.smtp_use_tls)
+    use_ssl: bool = Field(default_factory=lambda: settings.smtp_use_ssl)
+    timeout: int = Field(default=30)
+    from_email: EmailStr = Field(default_factory=lambda: settings.smtp_from_email)
+    from_name: str = Field(default_factory=lambda: settings.smtp_from_name)
+
+
+class EmailService:
+    """Service for sending emails via SMTP."""
+    
+    def __init__(self, config: Optional[SMTPConfig] = None):
+        """Initialize email service.
+        
+        Args:
+            config: SMTP configuration. If not provided, uses settings.
+        """
+        self.config = config or SMTPConfig()
+        self._template_env = self._setup_template_environment()
+        self._connection_lock = asyncio.Lock()
+        self._smtp_client: Optional[aiosmtplib.SMTP] = None
+        
+    def _setup_template_environment(self) -> Environment:
+        """Setup Jinja2 template environment."""
+        template_dir = Path(__file__).parent.parent / "templates" / "email"
+        template_dir.mkdir(parents=True, exist_ok=True)
+        
+        return Environment(
+            loader=FileSystemLoader(str(template_dir)),
+            autoescape=select_autoescape(["html", "xml"]),
+            enable_async=True
+        )
+    
+    async def _get_smtp_client(self) -> aiosmtplib.SMTP:
+        """Get or create SMTP client with connection pooling."""
+        async with self._connection_lock:
+            if self._smtp_client is None or not self._smtp_client.is_connected:
+                self._smtp_client = aiosmtplib.SMTP(
+                    hostname=self.config.host,
+                    port=self.config.port,
+                    timeout=self.config.timeout,
+                    use_tls=self.config.use_ssl
+                )
+                
+                await self._smtp_client.connect()
+                
+                if self.config.use_tls and not self.config.use_ssl:
+                    await self._smtp_client.starttls()
+                
+                if self.config.username and self.config.password:
+                    await self._smtp_client.login(
+                        self.config.username,
+                        self.config.password
+                    )
+                    
+            return self._smtp_client
+    
+    async def _render_template(
+        self,
+        template_name: str,
+        context: Dict[str, Any]
+    ) -> tuple[str, str]:
+        """Render email template.
+        
+        Args:
+            template_name: Name of the template file
+            context: Template context data
+            
+        Returns:
+            Tuple of (html_body, text_body)
+        """
+        # Add default context
+        default_context = {
+            "app_name": "Cidadão.AI",
+            "app_url": settings.app_url,
+            "support_email": settings.support_email,
+        }
+        context = {**default_context, **context}
+        
+        # Render HTML template
+        html_template = self._template_env.get_template(f"{template_name}.html")
+        html_body = await html_template.render_async(**context)
+        
+        # Try to render text template, fallback to HTML strip
+        try:
+            text_template = self._template_env.get_template(f"{template_name}.txt")
+            text_body = await text_template.render_async(**context)
+        except Exception:
+            # Simple HTML to text conversion
+            import re
+            text_body = re.sub(r"<[^>]+>", "", html_body)
+            text_body = re.sub(r"\s+", " ", text_body).strip()
+        
+        return html_body, text_body
+    
+    def _create_message(self, email: EmailMessage) -> MIMEMultipart:
+        """Create MIME message from EmailMessage."""
+        msg = MIMEMultipart("alternative")
+        
+        # Set headers
+        msg["Subject"] = email.subject
+        msg["From"] = f"{self.config.from_name} <{self.config.from_email}>"
+        msg["To"] = ", ".join(email.to)
+        
+        if email.cc:
+            msg["Cc"] = ", ".join(email.cc)
+        
+        if email.reply_to:
+            msg["Reply-To"] = email.reply_to
+        
+        # Add custom headers
+        if email.headers:
+            for key, value in email.headers.items():
+                msg[key] = value
+        
+        # Add text part
+        if email.body:
+            msg.attach(MIMEText(email.body, "plain"))
+        
+        # Add HTML part
+        if email.html_body:
+            msg.attach(MIMEText(email.html_body, "html"))
+        
+        # Add attachments
+        if email.attachments:
+            for attachment in email.attachments:
+                part = MIMEBase("application", "octet-stream")
+                part.set_payload(attachment.content)
+                encoders.encode_base64(part)
+                part.add_header(
+                    "Content-Disposition",
+                    f"attachment; filename={attachment.filename}"
+                )
+                msg.attach(part)
+        
+        return msg
+    
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=4, max=10)
+    )
+    async def send_email(self, email: EmailMessage) -> bool:
+        """Send an email message.
+        
+        Args:
+            email: Email message to send
+            
+        Returns:
+            True if email was sent successfully
+        """
+        try:
+            # Render template if specified
+            if email.template:
+                html_body, text_body = await self._render_template(
+                    email.template,
+                    email.template_data or {}
+                )
+                email.html_body = html_body
+                email.body = text_body
+            
+            # Create MIME message
+            msg = self._create_message(email)
+            
+            # Get SMTP client
+            smtp = await self._get_smtp_client()
+            
+            # Prepare recipients
+            recipients = email.to.copy()
+            if email.cc:
+                recipients.extend(email.cc)
+            if email.bcc:
+                recipients.extend(email.bcc)
+            
+            # Send email
+            await smtp.send_message(msg)
+            
+            logger.info(
+                "Email sent successfully",
+                subject=email.subject,
+                recipients=len(recipients),
+                has_attachments=bool(email.attachments)
+            )
+            
+            return True
+            
+        except Exception as e:
+            logger.error(
+                "Failed to send email",
+                subject=email.subject,
+                error=str(e),
+                exc_info=True
+            )
+            raise
+    
+    async def send_batch(
+        self,
+        emails: List[EmailMessage],
+        max_concurrent: int = 5
+    ) -> List[bool]:
+        """Send multiple emails concurrently.
+        
+        Args:
+            emails: List of email messages
+            max_concurrent: Maximum concurrent sends
+            
+        Returns:
+            List of success status for each email
+        """
+        semaphore = asyncio.Semaphore(max_concurrent)
+        
+        async def send_with_semaphore(email: EmailMessage) -> bool:
+            async with semaphore:
+                try:
+                    return await self.send_email(email)
+                except Exception:
+                    return False
+        
+        tasks = [send_with_semaphore(email) for email in emails]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        return [
+            result if isinstance(result, bool) else False
+            for result in results
+        ]
+    
+    async def close(self):
+        """Close SMTP connection."""
+        if self._smtp_client and self._smtp_client.is_connected:
+            await self._smtp_client.quit()
+            self._smtp_client = None
+
+
+# Singleton instance
+email_service = EmailService()
+
+
+# Convenience functions
+async def send_email(
+    to: Union[str, List[str]],
+    subject: str,
+    body: Optional[str] = None,
+    html_body: Optional[str] = None,
+    template: Optional[str] = None,
+    template_data: Optional[Dict[str, Any]] = None,
+    attachments: Optional[List[EmailAttachment]] = None,
+    **kwargs
+) -> bool:
+    """Send an email using the default email service.
+    
+    Args:
+        to: Recipient email address(es)
+        subject: Email subject
+        body: Plain text body
+        html_body: HTML body
+        template: Template name to render
+        template_data: Data for template rendering
+        attachments: List of attachments
+        **kwargs: Additional email fields (cc, bcc, reply_to, headers)
+        
+    Returns:
+        True if email was sent successfully
+    """
+    if isinstance(to, str):
+        to = [to]
+    
+    email = EmailMessage(
+        to=to,
+        subject=subject,
+        body=body,
+        html_body=html_body,
+        template=template,
+        template_data=template_data,
+        attachments=attachments,
+        **kwargs
+    )
+    
+    return await email_service.send_email(email)
+
+
+async def send_template_email(
+    to: Union[str, List[str]],
+    subject: str,
+    template: str,
+    template_data: Optional[Dict[str, Any]] = None,
+    **kwargs
+) -> bool:
+    """Send an email using a template.
+    
+    Args:
+        to: Recipient email address(es)
+        subject: Email subject
+        template: Template name
+        template_data: Template context data
+        **kwargs: Additional email fields
+        
+    Returns:
+        True if email was sent successfully
+    """
+    return await send_email(
+        to=to,
+        subject=subject,
+        template=template,
+        template_data=template_data,
+        **kwargs
+    )

src/services/webhook_service.py

@@ -0,0 +1,391 @@
+"""Webhook service for sending notifications to external endpoints.
+
+This service provides async webhook delivery with:
+- Retry logic with exponential backoff
+- Request signing for security
+- Batch webhook sending
+- Event filtering
+- Delivery status tracking
+"""
+
+import asyncio
+import hashlib
+import hmac
+from datetime import datetime, timezone
+from typing import List, Dict, Any, Optional, Union
+from enum import Enum
+import httpx
+from pydantic import BaseModel, HttpUrl, Field, validator
+import structlog
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+    retry_if_exception_type
+)
+
+from src.core.config import settings
+from src.core.logging import get_logger
+from src.core import json_utils
+
+logger = get_logger(__name__)
+
+
+class WebhookEvent(str, Enum):
+    """Webhook event types."""
+    INVESTIGATION_CREATED = "investigation.created"
+    INVESTIGATION_COMPLETED = "investigation.completed"
+    INVESTIGATION_FAILED = "investigation.failed"
+    
+    ANOMALY_DETECTED = "anomaly.detected"
+    ANOMALY_RESOLVED = "anomaly.resolved"
+    
+    AGENT_STARTED = "agent.started"
+    AGENT_COMPLETED = "agent.completed"
+    AGENT_FAILED = "agent.failed"
+    
+    REPORT_GENERATED = "report.generated"
+    EXPORT_COMPLETED = "export.completed"
+    
+    USER_REGISTERED = "user.registered"
+    USER_LOGIN = "user.login"
+    
+    SYSTEM_ALERT = "system.alert"
+    SYSTEM_ERROR = "system.error"
+
+
+class WebhookPayload(BaseModel):
+    """Webhook payload model."""
+    event: WebhookEvent
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    data: Dict[str, Any]
+    metadata: Optional[Dict[str, Any]] = None
+    
+    @validator("timestamp", pre=True)
+    def ensure_timezone(cls, v):
+        """Ensure timestamp has timezone."""
+        if isinstance(v, datetime) and v.tzinfo is None:
+            return v.replace(tzinfo=timezone.utc)
+        return v
+
+
+class WebhookConfig(BaseModel):
+    """Webhook configuration model."""
+    url: HttpUrl
+    secret: Optional[str] = None
+    events: Optional[List[WebhookEvent]] = None  # None means all events
+    headers: Optional[Dict[str, str]] = None
+    timeout: int = Field(default=30, ge=1, le=300)
+    max_retries: int = Field(default=3, ge=0, le=10)
+    active: bool = Field(default=True)
+    
+    def should_send_event(self, event: WebhookEvent) -> bool:
+        """Check if webhook should receive this event."""
+        if not self.active:
+            return False
+        if self.events is None:
+            return True
+        return event in self.events
+
+
+class WebhookDelivery(BaseModel):
+    """Webhook delivery result."""
+    webhook_url: str
+    event: WebhookEvent
+    timestamp: datetime
+    status_code: Optional[int] = None
+    response_body: Optional[str] = None
+    error: Optional[str] = None
+    attempts: int = 0
+    success: bool = False
+    duration_ms: Optional[float] = None
+
+
+class WebhookService:
+    """Service for managing and sending webhooks."""
+    
+    def __init__(self):
+        """Initialize webhook service."""
+        self._webhooks: List[WebhookConfig] = []
+        self._client = httpx.AsyncClient(
+            timeout=httpx.Timeout(30.0),
+            follow_redirects=False,
+            limits=httpx.Limits(max_connections=100, max_keepalive_connections=20)
+        )
+        self._delivery_history: List[WebhookDelivery] = []
+        self._max_history = 1000
+        
+    def add_webhook(self, webhook: WebhookConfig) -> None:
+        """Add a webhook configuration."""
+        self._webhooks.append(webhook)
+        logger.info(
+            "Webhook added",
+            url=str(webhook.url),
+            events=webhook.events,
+            active=webhook.active
+        )
+        
+    def remove_webhook(self, url: str) -> bool:
+        """Remove a webhook by URL."""
+        initial_count = len(self._webhooks)
+        self._webhooks = [w for w in self._webhooks if str(w.url) != url]
+        removed = len(self._webhooks) < initial_count
+        
+        if removed:
+            logger.info("Webhook removed", url=url)
+        
+        return removed
+        
+    def list_webhooks(self) -> List[WebhookConfig]:
+        """List all configured webhooks."""
+        return self._webhooks.copy()
+        
+    def _generate_signature(self, payload: bytes, secret: str) -> str:
+        """Generate HMAC signature for webhook payload."""
+        signature = hmac.new(
+            secret.encode(),
+            payload,
+            hashlib.sha256
+        ).hexdigest()
+        return f"sha256={signature}"
+        
+    def _prepare_request(
+        self,
+        webhook: WebhookConfig,
+        payload: WebhookPayload
+    ) -> tuple[Dict[str, str], bytes]:
+        """Prepare webhook request headers and body."""
+        # Serialize payload
+        body_data = {
+            "event": payload.event,
+            "timestamp": payload.timestamp.isoformat(),
+            "data": payload.data,
+        }
+        if payload.metadata:
+            body_data["metadata"] = payload.metadata
+            
+        body = json_utils.dumps(body_data).encode()
+        
+        # Prepare headers
+        headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "Cidadao.AI/1.0",
+            "X-Cidadao-Event": payload.event,
+            "X-Cidadao-Timestamp": payload.timestamp.isoformat(),
+        }
+        
+        # Add signature if secret is configured
+        if webhook.secret:
+            headers["X-Cidadao-Signature"] = self._generate_signature(body, webhook.secret)
+            
+        # Add custom headers
+        if webhook.headers:
+            headers.update(webhook.headers)
+            
+        return headers, body
+        
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=4, max=10),
+        retry=retry_if_exception_type((httpx.TimeoutException, httpx.ConnectError))
+    )
+    async def _send_webhook(
+        self,
+        webhook: WebhookConfig,
+        payload: WebhookPayload
+    ) -> WebhookDelivery:
+        """Send a single webhook with retry logic."""
+        delivery = WebhookDelivery(
+            webhook_url=str(webhook.url),
+            event=payload.event,
+            timestamp=datetime.now(timezone.utc)
+        )
+        
+        try:
+            # Prepare request
+            headers, body = self._prepare_request(webhook, payload)
+            
+            # Send request
+            start_time = asyncio.get_event_loop().time()
+            response = await self._client.post(
+                str(webhook.url),
+                headers=headers,
+                content=body,
+                timeout=webhook.timeout
+            )
+            end_time = asyncio.get_event_loop().time()
+            
+            # Update delivery info
+            delivery.status_code = response.status_code
+            delivery.response_body = response.text[:1000]  # Limit response size
+            delivery.success = 200 <= response.status_code < 300
+            delivery.duration_ms = (end_time - start_time) * 1000
+            delivery.attempts = 1  # Will be updated by retry decorator
+            
+            if not delivery.success:
+                logger.warning(
+                    "Webhook delivery failed",
+                    url=str(webhook.url),
+                    status_code=response.status_code,
+                    response=delivery.response_body
+                )
+                
+        except Exception as e:
+            delivery.error = str(e)
+            delivery.success = False
+            logger.error(
+                "Webhook delivery error",
+                url=str(webhook.url),
+                error=str(e),
+                exc_info=True
+            )
+            raise
+            
+        return delivery
+        
+    async def send_event(
+        self,
+        event: WebhookEvent,
+        data: Dict[str, Any],
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> List[WebhookDelivery]:
+        """Send an event to all configured webhooks.
+        
+        Args:
+            event: Event type
+            data: Event data
+            metadata: Optional metadata
+            
+        Returns:
+            List of delivery results
+        """
+        payload = WebhookPayload(
+            event=event,
+            data=data,
+            metadata=metadata
+        )
+        
+        # Filter webhooks for this event
+        webhooks_to_send = [
+            webhook for webhook in self._webhooks
+            if webhook.should_send_event(event)
+        ]
+        
+        if not webhooks_to_send:
+            logger.debug("No webhooks configured for event", event=event)
+            return []
+            
+        # Send webhooks concurrently
+        tasks = [
+            self._send_webhook(webhook, payload)
+            for webhook in webhooks_to_send
+        ]
+        
+        deliveries = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Process results
+        results = []
+        for delivery in deliveries:
+            if isinstance(delivery, Exception):
+                # Create failed delivery record
+                delivery = WebhookDelivery(
+                    webhook_url="unknown",
+                    event=event,
+                    timestamp=datetime.now(timezone.utc),
+                    error=str(delivery),
+                    success=False
+                )
+            results.append(delivery)
+            
+        # Store in history
+        self._store_deliveries(results)
+        
+        # Log summary
+        successful = sum(1 for d in results if d.success)
+        logger.info(
+            "Webhooks sent",
+            event=event,
+            total=len(results),
+            successful=successful,
+            failed=len(results) - successful
+        )
+        
+        return results
+        
+    def _store_deliveries(self, deliveries: List[WebhookDelivery]) -> None:
+        """Store delivery results in history."""
+        self._delivery_history.extend(deliveries)
+        
+        # Trim history if too large
+        if len(self._delivery_history) > self._max_history:
+            self._delivery_history = self._delivery_history[-self._max_history:]
+            
+    def get_delivery_history(
+        self,
+        event: Optional[WebhookEvent] = None,
+        url: Optional[str] = None,
+        success: Optional[bool] = None,
+        limit: int = 100
+    ) -> List[WebhookDelivery]:
+        """Get webhook delivery history with filtering."""
+        history = self._delivery_history.copy()
+        
+        # Apply filters
+        if event:
+            history = [d for d in history if d.event == event]
+        if url:
+            history = [d for d in history if d.webhook_url == url]
+        if success is not None:
+            history = [d for d in history if d.success == success]
+            
+        # Sort by timestamp (newest first) and limit
+        history.sort(key=lambda d: d.timestamp, reverse=True)
+        return history[:limit]
+        
+    async def test_webhook(self, webhook: WebhookConfig) -> WebhookDelivery:
+        """Test a webhook configuration."""
+        test_payload = WebhookPayload(
+            event=WebhookEvent.SYSTEM_ALERT,
+            data={
+                "type": "test",
+                "message": "This is a test webhook from Cidadão.AI",
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            },
+            metadata={"test": True}
+        )
+        
+        return await self._send_webhook(webhook, test_payload)
+        
+    async def close(self):
+        """Close the webhook service."""
+        await self._client.aclose()
+
+
+# Singleton instance
+webhook_service = WebhookService()
+
+
+# Convenience functions
+async def send_webhook_event(
+    event: WebhookEvent,
+    data: Dict[str, Any],
+    metadata: Optional[Dict[str, Any]] = None
+) -> List[WebhookDelivery]:
+    """Send a webhook event using the default service."""
+    return await webhook_service.send_event(event, data, metadata)
+
+
+async def register_webhook(
+    url: str,
+    events: Optional[List[WebhookEvent]] = None,
+    secret: Optional[str] = None,
+    **kwargs
+) -> None:
+    """Register a new webhook."""
+    config = WebhookConfig(
+        url=url,
+        events=events,
+        secret=secret,
+        **kwargs
+    )
+    webhook_service.add_webhook(config)

src/templates/email/anomaly_alert.html

@@ -0,0 +1,94 @@
+{% extends "base.html" %}
+
+{% block content %}
+<h2 style="color: #e74c3c;">⚠️ Alerta de Anomalia Detectada</h2>
+
+<div class="alert alert-danger">
+    <strong>ATENÇÃO:</strong> Uma anomalia {{ severity | default('significativa') }} foi detectada em nossa análise.
+</div>
+
+<div style="margin: 20px 0;">
+    <h3>Detalhes da Anomalia</h3>
+    <table style="width: 100%; border-collapse: collapse;">
+        <tr>
+            <td style="padding: 10px; border-bottom: 1px solid #ecf0f1;"><strong>Tipo:</strong></td>
+            <td style="padding: 10px; border-bottom: 1px solid #ecf0f1;">{{ anomaly_type }}</td>
+        </tr>
+        <tr>
+            <td style="padding: 10px; border-bottom: 1px solid #ecf0f1;"><strong>Severidade:</strong></td>
+            <td style="padding: 10px; border-bottom: 1px solid #ecf0f1;">
+                <span style="color: {% if severity == 'critical' %}#e74c3c{% elif severity == 'high' %}#f39c12{% elif severity == 'medium' %}#f1c40f{% else %}#3498db{% endif %};">
+                    {{ severity | upper }}
+                </span>
+            </td>
+        </tr>
+        <tr>
+            <td style="padding: 10px; border-bottom: 1px solid #ecf0f1;"><strong>Data de Detecção:</strong></td>
+            <td style="padding: 10px; border-bottom: 1px solid #ecf0f1;">{{ detection_date }}</td>
+        </tr>
+        <tr>
+            <td style="padding: 10px; border-bottom: 1px solid #ecf0f1;"><strong>Fonte de Dados:</strong></td>
+            <td style="padding: 10px; border-bottom: 1px solid #ecf0f1;">{{ data_source }}</td>
+        </tr>
+        {% if confidence_score %}
+        <tr>
+            <td style="padding: 10px; border-bottom: 1px solid #ecf0f1;"><strong>Confiança:</strong></td>
+            <td style="padding: 10px; border-bottom: 1px solid #ecf0f1;">{{ confidence_score }}%</td>
+        </tr>
+        {% endif %}
+    </table>
+</div>
+
+{% if description %}
+<div style="margin: 20px 0;">
+    <h3>Descrição</h3>
+    <p>{{ description }}</p>
+</div>
+{% endif %}
+
+{% if affected_entities %}
+<div style="margin: 20px 0;">
+    <h3>Entidades Afetadas</h3>
+    <ul>
+    {% for entity in affected_entities %}
+        <li>{{ entity }}</li>
+    {% endfor %}
+    </ul>
+</div>
+{% endif %}
+
+{% if potential_impact %}
+<div style="background-color: #fff3cd; padding: 15px; border-left: 4px solid #f39c12; margin: 20px 0;">
+    <h4 style="margin-top: 0;">Impacto Potencial</h4>
+    <p>{{ potential_impact }}</p>
+</div>
+{% endif %}
+
+{% if recommended_actions %}
+<div style="margin: 20px 0;">
+    <h3>Ações Recomendadas</h3>
+    <ol>
+    {% for action in recommended_actions %}
+        <li>{{ action }}</li>
+    {% endfor %}
+    </ol>
+</div>
+{% endif %}
+
+<p style="text-align: center; margin: 30px 0;">
+    <a href="{{ app_url }}/anomalies/{{ anomaly_id }}" class="button" style="background-color: #e74c3c;">
+        Investigar Anomalia
+    </a>
+</p>
+
+<hr style="margin: 30px 0; border: none; border-top: 1px solid #ecf0f1;">
+
+<p style="background-color: #f8f9fa; padding: 15px; border-radius: 5px;">
+    <strong>Nota:</strong> Este alerta foi gerado automaticamente pelo sistema de detecção de anomalias do {{ app_name }}. 
+    É importante revisar e validar estas informações antes de tomar qualquer ação.
+</p>
+
+<p style="color: #7f8c8d; font-size: 14px;">
+    Para ajustar seus alertas de anomalias, acesse as configurações de notificação em sua conta.
+</p>
+{% endblock %}

src/templates/email/base.html

@@ -0,0 +1,116 @@
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}{{ subject }}{% endblock %}</title>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+            line-height: 1.6;
+            color: #333;
+            background-color: #f4f4f4;
+            margin: 0;
+            padding: 0;
+        }
+        .container {
+            max-width: 600px;
+            margin: 0 auto;
+            background-color: #ffffff;
+            padding: 0;
+        }
+        .header {
+            background-color: #2c3e50;
+            color: #ffffff;
+            padding: 20px;
+            text-align: center;
+        }
+        .header h1 {
+            margin: 0;
+            font-size: 24px;
+        }
+        .content {
+            padding: 30px;
+        }
+        .button {
+            display: inline-block;
+            padding: 12px 24px;
+            background-color: #3498db;
+            color: #ffffff;
+            text-decoration: none;
+            border-radius: 5px;
+            margin: 10px 0;
+        }
+        .button:hover {
+            background-color: #2980b9;
+        }
+        .footer {
+            background-color: #ecf0f1;
+            padding: 20px;
+            text-align: center;
+            font-size: 14px;
+            color: #7f8c8d;
+        }
+        .footer a {
+            color: #3498db;
+            text-decoration: none;
+        }
+        .alert {
+            padding: 15px;
+            margin: 20px 0;
+            border-radius: 5px;
+        }
+        .alert-warning {
+            background-color: #f39c12;
+            color: #ffffff;
+        }
+        .alert-danger {
+            background-color: #e74c3c;
+            color: #ffffff;
+        }
+        .alert-success {
+            background-color: #27ae60;
+            color: #ffffff;
+        }
+        .alert-info {
+            background-color: #3498db;
+            color: #ffffff;
+        }
+        pre {
+            background-color: #f4f4f4;
+            padding: 10px;
+            border-radius: 5px;
+            overflow-x: auto;
+        }
+        code {
+            font-family: 'Courier New', monospace;
+            background-color: #f4f4f4;
+            padding: 2px 4px;
+            border-radius: 3px;
+        }
+    </style>
+    {% block extra_style %}{% endblock %}
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>{{ app_name }}</h1>
+        </div>
+        
+        <div class="content">
+            {% block content %}{% endblock %}
+        </div>
+        
+        <div class="footer">
+            <p>© 2025 {{ app_name }}. Todos os direitos reservados.</p>
+            <p>
+                <a href="{{ app_url }}">Visite nosso site</a> |
+                <a href="mailto:{{ support_email }}">Contato</a>
+            </p>
+            <p style="margin-top: 20px; font-size: 12px;">
+                Este é um e-mail automático. Por favor, não responda diretamente a este endereço.
+            </p>
+        </div>
+    </div>
+</body>
+</html>

src/templates/email/investigation_complete.html

@@ -0,0 +1,75 @@
+{% extends "base.html" %}
+
+{% block content %}
+<h2>Investigação Concluída</h2>
+
+<p>Olá,</p>
+
+<p>Sua investigação foi concluída com sucesso. Aqui está um resumo dos resultados:</p>
+
+<div style="background-color: #ecf0f1; padding: 20px; border-radius: 5px; margin: 20px 0;">
+    <h3>Resumo da Investigação</h3>
+    <ul>
+        <li><strong>ID da Investigação:</strong> {{ investigation_id }}</li>
+        <li><strong>Data de Início:</strong> {{ start_date }}</li>
+        <li><strong>Data de Conclusão:</strong> {{ end_date }}</li>
+        <li><strong>Duração:</strong> {{ duration }}</li>
+        <li><strong>Status:</strong> <span style="color: #27ae60;">Concluída</span></li>
+    </ul>
+</div>
+
+{% if summary %}
+<div style="margin: 20px 0;">
+    <h3>Resumo Executivo</h3>
+    <p>{{ summary }}</p>
+</div>
+{% endif %}
+
+{% if anomalies_count %}
+<div class="alert alert-warning">
+    <strong>Anomalias Detectadas:</strong> {{ anomalies_count }}
+    {% if critical_anomalies %}
+    <br><strong>Anomalias Críticas:</strong> {{ critical_anomalies }}
+    {% endif %}
+</div>
+{% endif %}
+
+{% if findings %}
+<div style="margin: 20px 0;">
+    <h3>Principais Descobertas</h3>
+    <ul>
+    {% for finding in findings %}
+        <li>{{ finding }}</li>
+    {% endfor %}
+    </ul>
+</div>
+{% endif %}
+
+{% if recommendations %}
+<div style="margin: 20px 0;">
+    <h3>Recomendações</h3>
+    <ol>
+    {% for recommendation in recommendations %}
+        <li>{{ recommendation }}</li>
+    {% endfor %}
+    </ol>
+</div>
+{% endif %}
+
+<p style="text-align: center; margin: 30px 0;">
+    <a href="{{ app_url }}/investigations/{{ investigation_id }}" class="button">Ver Relatório Completo</a>
+</p>
+
+{% if confidence_score %}
+<p style="text-align: center; color: #7f8c8d;">
+    <small>Confiança na Análise: {{ confidence_score }}%</small>
+</p>
+{% endif %}
+
+<hr style="margin: 30px 0; border: none; border-top: 1px solid #ecf0f1;">
+
+<p style="color: #7f8c8d; font-size: 14px;">
+    Esta investigação foi realizada pelos agentes de IA do {{ app_name }}. 
+    Para mais informações sobre nossa metodologia, visite nossa documentação.
+</p>
+{% endblock %}

src/templates/email/notification.html

@@ -0,0 +1,39 @@
+{% extends "base.html" %}
+
+{% block content %}
+<h2>{{ title }}</h2>
+
+{% if message %}
+<p>{{ message }}</p>
+{% endif %}
+
+{% if details %}
+<div class="details">
+    <h3>Detalhes:</h3>
+    <ul>
+    {% for key, value in details.items() %}
+        <li><strong>{{ key }}:</strong> {{ value }}</li>
+    {% endfor %}
+    </ul>
+</div>
+{% endif %}
+
+{% if action_url %}
+<p style="text-align: center; margin: 30px 0;">
+    <a href="{{ action_url }}" class="button">{{ action_text | default('Ver Detalhes') }}</a>
+</p>
+{% endif %}
+
+{% if severity %}
+<div class="alert alert-{{ severity }}">
+    <strong>Nível de Severidade:</strong> {{ severity | upper }}
+</div>
+{% endif %}
+
+<hr style="margin: 30px 0; border: none; border-top: 1px solid #ecf0f1;">
+
+<p style="color: #7f8c8d; font-size: 14px;">
+    Você está recebendo este e-mail porque está inscrito para receber notificações do {{ app_name }}.
+    Para ajustar suas preferências de notificação, acesse sua conta em nosso sistema.
+</p>
+{% endblock %}

src/templates/email/notification.txt

@@ -0,0 +1,28 @@
+{{ title }}
+{{ '=' * title|length }}
+
+{{ message }}
+
+{% if details %}
+Detalhes:
+{% for key, value in details.items() %}
+- {{ key }}: {{ value }}
+{% endfor %}
+{% endif %}
+
+{% if action_url %}
+{{ action_text | default('Ver Detalhes') }}: {{ action_url }}
+{% endif %}
+
+{% if severity %}
+Nível de Severidade: {{ severity | upper }}
+{% endif %}
+
+--
+{{ app_name }}
+{{ app_url }}
+
+Você está recebendo este e-mail porque está inscrito para receber notificações do {{ app_name }}.
+Para ajustar suas preferências de notificação, acesse sua conta em nosso sistema.
+
+Este é um e-mail automático. Por favor, não responda diretamente a este endereço.