Roles

backend/app/api/deps.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from fastapi import Depends, HTTPException, status
 from starlette.requests import Request
 from fastapi.security import OAuth2PasswordBearer
@@ -15,7 +16,48 @@ from app.models.tenant import Tenant
 settings = get_settings()
 
 # Esquema OAuth2 centralizado — auth.py importa desde aquí
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"/{settings.API_VERSION}/auth/login")
+# Soporta: 1) Authorization: Bearer header (Swagger/API clients)
+#           2) Cookie access_token HttpOnly (apps web)
+_bearer_scheme = OAuth2PasswordBearer(
+    tokenUrl=f"/{settings.API_VERSION}/auth/login",
+    auto_error=False,
+)
+
+
+async def oauth2_scheme(
+    request: Request,
+    bearer_token: Optional[str] = Depends(_bearer_scheme),
+) -> str:
+    """Extrae JWT desde header Authorization (prioridad) o cookie del frontend correcto.
+    
+    Usa el header X-App para seleccionar la cookie:
+      - X-App: internal  → solo 'internal_access_token'
+      - X-App: client    → solo 'client_access_token'
+      - sin header       → prueba ambas (compatibilidad con Swagger/CLI)
+    """
+    if bearer_token:
+        return bearer_token
+
+    app_hint = request.headers.get("X-App", "").lower()
+    if app_hint == "internal":
+        token = request.cookies.get("internal_access_token")
+    elif app_hint == "client":
+        token = request.cookies.get("client_access_token")
+    else:
+        # Fallback para Swagger, tests y clientes sin header
+        token = (
+            request.cookies.get("internal_access_token")
+            or request.cookies.get("client_access_token")
+        )
+
+    if not token:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Not authenticated",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return token
+
 
 async def get_current_user(
     request: Request,
@@ -47,9 +89,10 @@ async def get_current_user(
         raise HTTPException(status_code=400, detail="Inactive user")
 
     # Enforce that tenant header (if present) matches the authenticated user's tenant.
-    # Prevents cross-tenant header impersonation.
+    # Roles globales (is_global) pueden operar en cualquier tenant → omitir chequeo.
+    # Roles de cliente (is_client) deben coincidir con su propio tenant.
     request_tenant_id = getattr(getattr(request, "state", None), "tenant_id", None)
-    if request_tenant_id and str(user.tenant_id) != str(request_tenant_id):
+    if request_tenant_id and user.role.is_client and str(user.tenant_id) != str(request_tenant_id):
         raise HTTPException(
             status_code=status.HTTP_403_FORBIDDEN,
             detail="Tenant header does not match authenticated user",

backend/app/api/v1/endpoints/auth.py

@@ -4,7 +4,7 @@ Authentication Endpoints - ServiceManagerWeb
 Endpoints para autenticación y autorización
 """
 
-from fastapi import APIRouter, HTTPException, status, Depends, Request
+from fastapi import APIRouter, HTTPException, status, Depends, Request, Response
 from fastapi.security import OAuth2PasswordRequestForm
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
@@ -21,6 +21,15 @@ from app.services.audit_service import AuditService
 from app.services.token_service import TokenService
 from app.api.deps import oauth2_scheme, get_current_user
 from app.core.cache import cache, cache_key
+from app.core.limiter import limiter
+
+# Nombres de cookie por tipo de usuario
+CLIENT_ROLES = {"CLIENT_ADMIN", "CLIENT_USER"}
+
+
+def _cookie_name_for_role(role: str) -> str:
+    """Devuelve el nombre de cookie según el rol del usuario."""
+    return "client_access_token" if role in CLIENT_ROLES else "internal_access_token"
 from app.api.schemas.auth import (
     LoginRequest, LoginResponse, RefreshTokenRequest, TokenResponse,
     TwoFactorStatusResponse, TwoFactorSetupResponse,
@@ -38,9 +47,11 @@ settings = get_settings()
 # ===================================
 
 @router.post("/login", response_model=LoginResponse)
+@limiter.limit("10/minute")
 async def login(
     login_data: LoginRequest,
     request: Request,
+    response: Response,
     db: AsyncSession = Depends(get_db)
 ):
     """
@@ -247,7 +258,20 @@ async def login(
     # Best-effort: clear per-identity limiter on success.
     if ident_key:
         await cache.delete(ident_key)
-    
+
+    # Cookie diferenciada por rol para aislar sesiones entre frontends
+    cookie_name = _cookie_name_for_role(
+        user.role.value if hasattr(user.role, "value") else user.role
+    )
+    response.set_cookie(
+        key=cookie_name,
+        value=access_token,
+        httponly=True,
+        secure=settings.is_production(),
+        samesite="strict" if settings.is_production() else "lax",
+        max_age=settings.ACCESS_TOKEN_EXPIRE_MINUTES * 60,
+    )
+
     return LoginResponse(
         access_token=access_token,
         refresh_token=refresh_token,
@@ -330,6 +354,7 @@ async def refresh_token(
 
 @router.post("/logout")
 async def logout(
+    response: Response,
     token: str = Depends(oauth2_scheme),
     db: AsyncSession = Depends(get_db)
 ):
@@ -387,7 +412,10 @@ async def logout(
         logger.warning("Failed to log audit entry", error=str(e))
     
     logger.info("Logout successful", user_id=payload["sub"])
-    
+
+    # Borrar la cookie correcta según el rol del usuario
+    cookie_name = _cookie_name_for_role(payload.get("role", ""))
+    response.delete_cookie(key=cookie_name)
     return {"message": "Successfully logged out"}
 
 
@@ -681,7 +709,9 @@ _RESET_KEY_PREFIX = "pwd_reset:"
 
 
 @router.post("/forgot-password", status_code=status.HTTP_200_OK)
+@limiter.limit("5/minute")
 async def forgot_password(
+    request: Request,
     data: ForgotPasswordRequest,
     db: AsyncSession = Depends(get_db),
 ):
@@ -748,7 +778,9 @@ async def forgot_password(
 
 
 @router.post("/reset-password", status_code=status.HTTP_200_OK)
+@limiter.limit("5/minute")
 async def reset_password(
+    request: Request,
     data: ResetPasswordRequest,
     db: AsyncSession = Depends(get_db),
 ):

backend/app/api/v1/endpoints/reports.py

@@ -7,7 +7,7 @@ Accesible por ADMIN y SUPPORT_MANAGER.
 
 from fastapi import APIRouter, Depends, Query, HTTPException, status
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, func, and_, case, text
+from sqlalchemy import select, func, and_, case, text, literal_column
 from typing import Optional, List
 from datetime import datetime, timedelta, timezone
 import uuid
@@ -505,20 +505,23 @@ async def get_report_trends(
     tenant_filter = Ticket.tenant_id == current_user.tenant_id
 
     # Tickets creados por día
+    # literal_column("'day'") evita que SQLAlchemy genere múltiples parámetros
+    # ($1, $4, $5) para 'day', lo que confunde a PostgreSQL en el GROUP BY.
+    _day_lit = literal_column("'day'")
     created_rows = (await db.execute(
         select(
-            func.date_trunc("day", Ticket.created_at).label("day"),
+            func.date_trunc(_day_lit, Ticket.created_at).label("day"),
             func.count(Ticket.id).label("cnt"),
         )
         .where(and_(tenant_filter, Ticket.created_at >= period_start))
-        .group_by(func.date_trunc("day", Ticket.created_at))
+        .group_by(func.date_trunc(_day_lit, Ticket.created_at))
-        .order_by(func.date_trunc("day", Ticket.created_at))
+        .order_by(func.date_trunc(_day_lit, Ticket.created_at))
     )).all()
 
     # Tickets resueltos por día (según resolved_at)
     resolved_rows = (await db.execute(
         select(
-            func.date_trunc("day", Ticket.resolved_at).label("day"),
+            func.date_trunc(_day_lit, Ticket.resolved_at).label("day"),
             func.count(Ticket.id).label("cnt"),
         )
         .where(and_(
@@ -526,8 +529,8 @@ async def get_report_trends(
             Ticket.resolved_at >= period_start,
             Ticket.resolved_at.isnot(None),
         ))
-        .group_by(func.date_trunc("day", Ticket.resolved_at))
+        .group_by(func.date_trunc(_day_lit, Ticket.resolved_at))
-        .order_by(func.date_trunc("day", Ticket.resolved_at))
+        .order_by(func.date_trunc(_day_lit, Ticket.resolved_at))
     )).all()
 
     created_map: dict[str, int] = {r.day.strftime("%Y-%m-%d"): r.cnt for r in created_rows}

backend/app/api/v1/endpoints/tickets.py

@@ -11,7 +11,7 @@ import uuid
 from app.core.database import get_db
 from app.api.deps import get_current_user, get_current_tenant
 from app.models.ticket import Ticket, TicketStatus, TicketPriority
-from app.models.user import User
+from app.models.user import User, UserRole
 from app.models.tenant import Tenant
 from app.models.category import Category
 from app.models.system import System
@@ -28,92 +28,27 @@ from app.api.v1.helpers import (
     safe_audit_log, generate_next_ticket_number, calculate_sla_deadlines, ticket_to_dict
 )
 from app.services.audit_service import AuditService
+from app.services.ticket_service import TicketService, get_ticket_service
 
 router = APIRouter()
 
 @router.post("/", response_model=TicketResponse, status_code=status.HTTP_201_CREATED)
-async def create_ticket(ticket: TicketCreate, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
+async def create_ticket(
+    ticket: TicketCreate,
+    current_user: User = Depends(get_current_user),
+    ticket_service: TicketService = Depends(get_ticket_service),
+):
     """Crear un nuevo ticket"""
-    max_retries = 3
+    return await ticket_service.create_ticket(ticket, current_user.tenant_id, current_user.id)
-    last_error = None
-    
-    for attempt in range(max_retries):
-        try:
-            ticket_number = await generate_next_ticket_number(db, current_user.tenant_id)
-            category_uuid = uuid.UUID(ticket.category_id) if ticket.category_id else None
-            system_uuid = uuid.UUID(ticket.affected_system_id) if ticket.affected_system_id else None
-            
-            category = None
-            if category_uuid:
-                category = await db.get(Category, category_uuid)
-                if not category:
-                    raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f"La categoría con ID {ticket.category_id} no existe.")
-            
-            if system_uuid:
-                system = await db.get(System, system_uuid)
-                if not system:
-                    raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f"El sistema con ID {ticket.affected_system_id} no existe.")
-            
-            sla_response_due, sla_resolution_due = calculate_sla_deadlines(category)
-            assigned_to_user = category.auto_assign_to if category and category.auto_assign_to else None
-            
-            db_ticket = Ticket(
-                id=uuid.uuid4(), tenant_id=current_user.tenant_id, ticket_number=ticket_number,
-                subject=ticket.subject, description=ticket.description, category_id=category_uuid,
-                affected_system_id=system_uuid, priority=TicketPriority[ticket.priority.upper()],
-                created_by=current_user.id, assigned_to=assigned_to_user, status=TicketStatus.NEW,
-                sla_response_due=sla_response_due, sla_resolution_due=sla_resolution_due,
-                created_at=datetime.utcnow(), updated_at=datetime.utcnow()
-            )
-            
-            db.add(db_ticket)
-            await db.commit()
-            await db.refresh(db_ticket)
-            
-            await safe_audit_log(db=db, tenant_id=current_user.tenant_id, user_id=current_user.id,
-                action="ticket.create", resource_type="ticket", resource_id=db_ticket.id,
-                new_values={"ticket_number": db_ticket.ticket_number, "subject": db_ticket.subject,
-                           "priority": db_ticket.priority.value, "status": db_ticket.status.value})
-            
-            return {
-                "id": str(db_ticket.id), "ticket_number": db_ticket.ticket_number, "subject": db_ticket.subject,
-                "title": db_ticket.subject, "description": db_ticket.description, "status": db_ticket.status.value,
-                "priority": db_ticket.priority.value, "category_id": str(db_ticket.category_id) if db_ticket.category_id else None,
-                "affected_system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None,
-                "system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None,
-                "contact_email": ticket.contact_email,
-                "contact_phone": ticket.contact_phone,
-                "created_by": str(db_ticket.created_by), "assigned_to": str(db_ticket.assigned_to) if db_ticket.assigned_to else None,
-                "created_at": db_ticket.created_at, "updated_at": db_ticket.updated_at,
-                "sla_response_due": db_ticket.sla_response_due,
-                "sla_resolution_due": db_ticket.sla_resolution_due,
-                "first_response_at": db_ticket.first_response_at,
-                "resolved_at": db_ticket.resolved_at,
-            }
-            
-        except ValueError as e:
-            await db.rollback()
-            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f"Invalid UUID format: {str(e)}")
-        except HTTPException:
-            await db.rollback()
-            raise
-        except Exception as e:
-            await db.rollback()
-            last_error = e
-            if "duplicate key" in str(e).lower() and "ticket_number" in str(e).lower():
-                if attempt < max_retries - 1:
-                    continue
-            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f"Error creating ticket: {str(e)}")
-    
-    raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-        detail=f"No se pudo crear el ticket después de {max_retries} intentos: {str(last_error)}")
 
 @router.get("/", response_model=List[TicketResponse])
 async def get_tickets(skip: int = 0, limit: int = 100, status: Optional[str] = None, priority: Optional[str] = None,
     db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
     """Obtener tickets con filtros opcionales"""
     query = select(Ticket).where(Ticket.tenant_id == current_user.tenant_id)
-    if current_user.role in ["CLIENT_USER", "CLIENT_ADMIN"]:
+    # Solo CLIENT_USER ve únicamente sus propios tickets.
+    # CLIENT_ADMIN ve todos los del tenant.
+    if current_user.role == UserRole.CLIENT_USER:
         query = query.where(Ticket.created_by == current_user.id)
     
     query = apply_enum_filter(query, Ticket.status, status, TicketStatus, "status")
@@ -136,14 +71,14 @@ async def get_all_tickets_admin(skip: int = 0, limit: int = 100, status_filter:
     assigned_to_filter: Optional[str] = None, search: Optional[str] = None, date_from: Optional[str] = None,
     date_to: Optional[str] = None, db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
     """Obtener todos los tickets del tenant del administrador (ADMIN/SUPPORT_MANAGER)."""
-    if current_user.role not in ["ADMIN", "SUPPORT_MANAGER"]:
+    if current_user.role not in (UserRole.ADMIN, UserRole.SUPPORT_MANAGER):
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="No tienes permisos para acceder a esta función")
 
     query = select(Ticket, Tenant, User).join(Tenant, Ticket.tenant_id == Tenant.id).join(User, Ticket.created_by == User.id)
 
     # SUPPORT_MANAGER solo ve su propio tenant.
     # ADMIN ve todos los tenants (es el administrador de la plataforma).
-    if current_user.role == "SUPPORT_MANAGER":
+    if current_user.role == UserRole.SUPPORT_MANAGER:
         query = query.where(Ticket.tenant_id == current_user.tenant_id)
 
     query = apply_enum_filter(query, Ticket.status, status_filter, TicketStatus, "status")
@@ -201,7 +136,7 @@ async def get_ticket(ticket_id: str, db: AsyncSession = Depends(get_db), current
     """Obtener un ticket por ID"""
     ticket_uuid = validate_uuid_param(ticket_id, "ticket ID")
     query = select(Ticket).where(Ticket.id == ticket_uuid, Ticket.tenant_id == current_user.tenant_id)
-    if current_user.role in ["CLIENT_USER", "CLIENT_ADMIN"]:
+    if current_user.role.is_client:
         query = query.where(Ticket.created_by == current_user.id)
     
     query = query.options(selectinload(Ticket.category), selectinload(Ticket.affected_system), selectinload(Ticket.assigned_to_user))
@@ -218,7 +153,7 @@ async def update_ticket(ticket_id: str, ticket: TicketUpdate, db: AsyncSession =
     """Actualizar un ticket"""
     ticket_uuid = validate_uuid_param(ticket_id, "ticket ID")
     query = select(Ticket).where(Ticket.id == ticket_uuid, Ticket.tenant_id == current_user.tenant_id)
-    if current_user.role in ["CLIENT_USER", "CLIENT_ADMIN"]:
+    if current_user.role.is_client:
         query = query.where(Ticket.created_by == current_user.id)
     
     result = await db.execute(query)

backend/app/api/v1/endpoints/users.py

@@ -45,8 +45,12 @@ async def read_users(
     - role: filtrar por rol
     - is_active: filtrar por estado activo
     """
-    # ✅ CORREGIDO: Filtrar por tenant_id
+    # ADMIN global ve todos los tenants; el resto solo ve su propio tenant
-    query = select(User).where(User.tenant_id == current_user.tenant_id)
+    from app.models.user import UserRole as _UserRole
+    if current_user.role != _UserRole.ADMIN:
+        query = select(User).where(User.tenant_id == current_user.tenant_id)
+    else:
+        query = select(User)
     
     # Aplicar filtros opcionales
     if role:

backend/app/api/v1/helpers.py

@@ -68,11 +68,11 @@ async def generate_next_ticket_number(db: AsyncSession, tenant_id: uuid.UUID) ->
     last_ticket_number = result.scalar_one_or_none()
     
     if last_ticket_number:
-        last_number = int(last_ticket_number.split('-')[1])
+        last_number = int(last_ticket_number.split('-')[-1])
         next_number = last_number + 1
     else:
         next_number = 1
-    
+
     return f"TK-{next_number:06d}"
 
 

backend/app/core/config.py

@@ -5,7 +5,6 @@ Configuración centralizada usando Pydantic Settings v2
 """
 
 from functools import lru_cache
-from typing import List, Optional
 from pydantic_settings import BaseSettings
 from pydantic import field_validator, Field
 import os
@@ -60,8 +59,8 @@ class Settings(BaseSettings):
     # ===================================
     SMTP_HOST: str = Field(default="localhost")
     SMTP_PORT: int = Field(default=587)
-    SMTP_USER: Optional[str] = Field(default=None)
+    SMTP_USER: str | None = Field(default=None)
-    SMTP_PASSWORD: Optional[str] = Field(default=None)
+    SMTP_PASSWORD: str | None = Field(default=None)
     SMTP_USE_TLS: bool = Field(default=True)
     SMTP_USE_SSL: bool = Field(default=False)
     
@@ -79,7 +78,7 @@ class Settings(BaseSettings):
     UPLOAD_PATH: str = Field(default="/app/uploads")
     
     @property
-    def ALLOWED_FILE_EXTENSIONS(self) -> List[str]:
+    def ALLOWED_FILE_EXTENSIONS(self) -> list[str]:
         """Parse the comma-separated file extensions."""
         return [ext.strip().lower() for ext in self.ALLOWED_FILE_EXTENSIONS_STR.split(",")]
     
@@ -102,7 +101,7 @@ class Settings(BaseSettings):
     # ===================================
     LOG_LEVEL: str = Field(default="INFO")
     LOG_FORMAT: str = Field(default="json")
-    LOG_FILE: Optional[str] = Field(default=None)
+    LOG_FILE: str | None = Field(default=None)
     
     # ===================================
     # FRONTEND URLS

backend/app/core/limiter.py

@@ -0,0 +1,20 @@
+"""
+Rate Limiter - ServiceManagerWeb
+
+Configura slowapi con Redis como storage backend.
+Respeta settings.RATE_LIMIT_ENABLED: si está desactivado usa memoria
+y el limiter queda en modo noop (enabled=False).
+"""
+
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+from app.core.config import get_settings
+
+settings = get_settings()
+
+limiter = Limiter(
+    key_func=get_remote_address,
+    storage_uri=settings.REDIS_URL if settings.RATE_LIMIT_ENABLED else "memory://",
+    enabled=settings.RATE_LIMIT_ENABLED,
+)

backend/app/main.py

@@ -9,6 +9,9 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.middleware.gzip import GZipMiddleware
 from fastapi.responses import JSONResponse
 from contextlib import asynccontextmanager
+from slowapi import _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
+from slowapi.middleware import SlowAPIMiddleware
 import structlog
 import time
 import uuid
@@ -31,6 +34,7 @@ from app.api.v1.router import api_router
 from app.middleware.tenant import TenantMiddleware
 from app.middleware.correlation_id import CorrelationIDMiddleware
 from app.core.cache import cache
+from app.core.limiter import limiter
 
 settings = get_settings()
 setup_logging()
@@ -70,6 +74,11 @@ app = FastAPI(
     openapi_url=f"/{settings.API_VERSION}/openapi.json"
 )
 
+# SlowAPI rate limiting
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+app.add_middleware(SlowAPIMiddleware)
+
 # ===================================
 # MIDDLEWARE
 # ===================================
@@ -87,8 +96,14 @@ if settings.is_production():
         "X-Correlation-ID",
     ]
 else:
-    cors_allow_methods = ["*"]
+    cors_allow_methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
-    cors_allow_headers = ["*"]
+    cors_allow_headers = [
+        "Authorization",
+        "Content-Type",
+        "X-Tenant-ID",
+        "X-Tenant-Slug",
+        "X-Correlation-ID",
+    ]
 
 app.add_middleware(
     CORSMiddleware,

backend/app/middleware/tenant.py

@@ -42,6 +42,8 @@ class TenantMiddleware(BaseHTTPMiddleware):
         "/v1/auth/refresh",
         "/api/v1/auth/logout",
         "/v1/auth/logout",
+        "/api/v1/auth/me",
+        "/v1/auth/me",
         "/api/v1/auth/forgot-password",
         "/v1/auth/forgot-password",
         "/api/v1/auth/reset-password",

backend/app/models/roles.py

@@ -0,0 +1,63 @@
+"""
+Definición y helpers de roles para el sistema multi-tenant.
+
+Fuente única: UserRole en app.models.user.
+Este módulo expone conjuntos de roles y helpers de verificación
+para usarse en deps.py y en los endpoints.
+
+Roles globales (staff interno — alcance multi-tenant):
+    ADMIN           → control total sobre todos los tenants
+    SUPPORT_MANAGER → gestiona equipos y SLAs de todos los tenants
+    AGENT           → atiende tickets de cualquier tenant
+    AUDITOR         → auditoría de solo lectura en todos los tenants
+
+Roles de cliente (alcance limitado al propio tenant):
+    CLIENT_ADMIN    → administra organización: usuarios, configuración, tickets
+    CLIENT_USER     → crea y sigue sus propios tickets
+"""
+
+from app.models.user import UserRole
+
+# ── Conjuntos de roles ──────────────────────────────────────────────────────
+
+GLOBAL_ROLES: frozenset[UserRole] = frozenset({
+    UserRole.ADMIN,
+    UserRole.SUPPORT_MANAGER,
+    UserRole.AGENT,
+    UserRole.AUDITOR,
+})
+
+CLIENT_ROLES: frozenset[UserRole] = frozenset({
+    UserRole.CLIENT_ADMIN,
+    UserRole.CLIENT_USER,
+})
+
+# ── Permisos por rol ────────────────────────────────────────────────────────
+
+ROLE_PERMISSIONS: dict[UserRole, list[str]] = {
+    # Staff global
+    UserRole.ADMIN:           ["manage_all", "view_all", "audit_all"],
+    UserRole.SUPPORT_MANAGER: ["manage_teams", "view_all_tickets", "manage_sla"],
+    UserRole.AGENT:           ["view_all_tickets", "update_any_ticket"],
+    UserRole.AUDITOR:         ["view_all", "audit_all"],
+    # Clientes (acotados al tenant)
+    UserRole.CLIENT_ADMIN:    ["manage_tenant", "manage_tenant_users", "view_tenant_tickets"],
+    UserRole.CLIENT_USER:     ["create_ticket", "view_own_tickets"],
+}
+
+# ── Helpers ─────────────────────────────────────────────────────────────────
+
+def is_global_staff(role: UserRole) -> bool:
+    """Retorna True si el rol tiene alcance global (staff interno)."""
+    return role.is_global
+
+
+def is_client_role(role: UserRole) -> bool:
+    """Retorna True si el rol está acotado al tenant del usuario."""
+    return role.is_client
+
+
+def has_permission(role: UserRole, permission: str) -> bool:
+    """Verifica si un rol tiene un permiso específico."""
+    return permission in ROLE_PERMISSIONS.get(role, [])
+

backend/app/models/user.py

@@ -27,6 +27,24 @@ class UserRole(str, enum.Enum):
     CLIENT_ADMIN = "CLIENT_ADMIN"      # Admin de organización cliente
     CLIENT_USER = "CLIENT_USER"        # Usuario final cliente
 
+    @property
+    def is_global(self) -> bool:
+        """True si el rol tiene alcance global (staff interno cross-tenant)."""
+        return self in (
+            UserRole.ADMIN,
+            UserRole.SUPPORT_MANAGER,
+            UserRole.AGENT,
+            UserRole.AUDITOR,
+        )
+
+    @property
+    def is_client(self) -> bool:
+        """True si el rol está acotado al tenant del usuario."""
+        return self in (
+            UserRole.CLIENT_ADMIN,
+            UserRole.CLIENT_USER,
+        )
+
 
 class User(Base):
     """Modelo de Usuario."""
@@ -113,11 +131,8 @@ class User(Base):
     
     @property
     def is_client(self) -> bool:
-        """Check if user is a client."""
+        """Check if user is a client (rol acotado al propio tenant)."""
-        return self.role in [
+        return self.role.is_client
-            UserRole.CLIENT_ADMIN,
-            UserRole.CLIENT_USER
-        ]
     
     @property
     def can_manage_users(self) -> bool:
@@ -125,7 +140,7 @@ class User(Base):
         return self.role in [
             UserRole.ADMIN,
             UserRole.SUPPORT_MANAGER,
-            UserRole.CLIENT_ADMIN
+            UserRole.CLIENT_ADMIN,
         ]
     
     @property
@@ -134,7 +149,7 @@ class User(Base):
         return self.role in [
             UserRole.ADMIN,
             UserRole.SUPPORT_MANAGER,
-            UserRole.AGENT
+            UserRole.AGENT,
         ]
     
     @property

backend/app/services/ticket_service.py

@@ -0,0 +1,170 @@
+"""
+Ticket Service - ServiceManagerWeb
+
+Lógica de negocio para creación y gestión de tickets.
+Inyectable vía Depends() en los endpoints de FastAPI.
+"""
+
+import uuid
+from datetime import datetime
+
+from fastapi import Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database import get_db
+from app.models.ticket import Ticket, TicketStatus, TicketPriority
+from app.models.category import Category
+from app.models.system import System
+from app.api.schemas.ticket import TicketCreate
+from app.api.v1.helpers import (
+    generate_next_ticket_number,
+    calculate_sla_deadlines,
+    safe_audit_log,
+)
+
+
+class TicketService:
+    """Servicio de tickets: encapsula lógica de negocio fuera del router."""
+
+    def __init__(self, db: AsyncSession = Depends(get_db)):
+        self.db = db
+
+    async def create_ticket(
+        self,
+        ticket: TicketCreate,
+        tenant_id: uuid.UUID,
+        user_id: uuid.UUID,
+    ) -> dict:
+        """
+        Crea un ticket con validación multi-tenant, cálculo de SLA y auto-asignación.
+
+        Args:
+            ticket:    Datos del ticket a crear.
+            tenant_id: Tenant del usuario autenticado.
+            user_id:   ID del usuario que crea el ticket.
+
+        Returns:
+            dict compatible con TicketResponse.
+
+        Raises:
+            HTTPException 400: UUID inválido, categoría/sistema no encontrado o de otro tenant.
+            HTTPException 500: Fallo persistente tras max_retries.
+        """
+        max_retries = 3
+        last_error = None
+
+        for attempt in range(max_retries):
+            try:
+                ticket_number = await generate_next_ticket_number(self.db, tenant_id)
+                category_uuid = uuid.UUID(ticket.category_id) if ticket.category_id else None
+                system_uuid = uuid.UUID(ticket.affected_system_id) if ticket.affected_system_id else None
+
+                category = None
+                if category_uuid:
+                    category = await self.db.get(Category, category_uuid)
+                    if not category or category.tenant_id != tenant_id:
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"La categoría con ID {ticket.category_id} no existe.",
+                        )
+
+                if system_uuid:
+                    system = await self.db.get(System, system_uuid)
+                    if not system or system.tenant_id != tenant_id:
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"El sistema con ID {ticket.affected_system_id} no existe.",
+                        )
+
+                sla_response_due, sla_resolution_due = calculate_sla_deadlines(category)
+                assigned_to_user = category.auto_assign_to if category and category.auto_assign_to else None
+
+                db_ticket = Ticket(
+                    id=uuid.uuid4(),
+                    tenant_id=tenant_id,
+                    ticket_number=ticket_number,
+                    subject=ticket.subject,
+                    description=ticket.description,
+                    category_id=category_uuid,
+                    affected_system_id=system_uuid,
+                    priority=TicketPriority[ticket.priority.upper()],
+                    created_by=user_id,
+                    assigned_to=assigned_to_user,
+                    status=TicketStatus.NEW,
+                    sla_response_due=sla_response_due,
+                    sla_resolution_due=sla_resolution_due,
+                    created_at=datetime.utcnow(),
+                    updated_at=datetime.utcnow(),
+                )
+
+                self.db.add(db_ticket)
+                await self.db.commit()
+                await self.db.refresh(db_ticket)
+
+                await safe_audit_log(
+                    db=self.db,
+                    tenant_id=tenant_id,
+                    user_id=user_id,
+                    action="ticket.create",
+                    resource_type="ticket",
+                    resource_id=db_ticket.id,
+                    new_values={
+                        "ticket_number": db_ticket.ticket_number,
+                        "subject": db_ticket.subject,
+                        "priority": db_ticket.priority.value,
+                        "status": db_ticket.status.value,
+                    },
+                )
+
+                return {
+                    "id": str(db_ticket.id),
+                    "ticket_number": db_ticket.ticket_number,
+                    "subject": db_ticket.subject,
+                    "title": db_ticket.subject,
+                    "description": db_ticket.description,
+                    "status": db_ticket.status.value,
+                    "priority": db_ticket.priority.value,
+                    "category_id": str(db_ticket.category_id) if db_ticket.category_id else None,
+                    "affected_system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None,
+                    "system_id": str(db_ticket.affected_system_id) if db_ticket.affected_system_id else None,
+                    "contact_email": ticket.contact_email,
+                    "contact_phone": ticket.contact_phone,
+                    "created_by": str(db_ticket.created_by),
+                    "assigned_to": str(db_ticket.assigned_to) if db_ticket.assigned_to else None,
+                    "created_at": db_ticket.created_at,
+                    "updated_at": db_ticket.updated_at,
+                    "sla_response_due": db_ticket.sla_response_due,
+                    "sla_resolution_due": db_ticket.sla_resolution_due,
+                    "first_response_at": db_ticket.first_response_at,
+                    "resolved_at": db_ticket.resolved_at,
+                }
+
+            except ValueError as e:
+                await self.db.rollback()
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f"Invalid UUID format: {str(e)}",
+                )
+            except HTTPException:
+                await self.db.rollback()
+                raise
+            except Exception as e:
+                await self.db.rollback()
+                last_error = e
+                if "duplicate key" in str(e).lower() and "ticket_number" in str(e).lower():
+                    if attempt < max_retries - 1:
+                        continue
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f"Error creating ticket: {str(e)}",
+                )
+
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"No se pudo crear el ticket después de {max_retries} intentos: {str(last_error)}",
+        )
+
+
+def get_ticket_service(db: AsyncSession = Depends(get_db)) -> TicketService:
+    """Factory function para inyectar TicketService vía Depends()."""
+    return TicketService(db)

backend/app/tests/conftest.py

@@ -0,0 +1,373 @@
+"""
+Integration Test Fixtures - ServiceManagerWeb (Docker / PostgreSQL)
+
+backend/app/tests/conftest.py
+
+Usa la BD Docker existente (servicemanager).
+Los fixtures leen datos reales ya seedeados — no crean ni eliminan nada.
+Los tests que inserten datos propios quedan aislados por rollback.
+
+Tenant de referencia : aduanasoft
+Usuarios de referencia:
+    admin@aduanasoft.com       → ADMIN
+    manager@aduanasoft.com     → SUPPORT_MANAGER
+    agente@aduanasoft.com      → AGENT
+    auditor1@test.com          → AUDITOR  (tenant aduanasoft)
+    admin-cliente@empresa-demo → CLIENT_ADMIN
+    test_user@aduanasoft.com   → CLIENT_USER
+"""
+
+import os
+import asyncio
+import pytest
+from typing import AsyncGenerator, Generator
+
+# ============================================================
+# ENV VARS — antes de importar la app
+# ============================================================
+os.environ.setdefault("ENVIRONMENT", "testing")
+os.environ.setdefault("TESTING", "true")
+os.environ.setdefault("DEBUG", "false")
+os.environ.setdefault("SECRET_KEY", "integration-secret-key-32chars!!!!")
+os.environ.setdefault("JWT_SECRET_KEY", "integration-jwt-secret-32chars!!!!")
+os.environ.setdefault(
+    "DATABASE_URL",
+    "postgresql+asyncpg://servicemanager:servicemanager123@localhost:5432/servicemanager",
+)
+os.environ.setdefault("REDIS_URL", "redis://localhost:6379/14")
+os.environ.setdefault("CELERY_BROKER_URL", "redis://localhost:6379/14")
+os.environ.setdefault("CELERY_RESULT_BACKEND", "redis://localhost:6379/14")
+os.environ.setdefault("CORS_ORIGINS", "http://localhost:3000")
+os.environ.setdefault("ALLOWED_FILE_EXTENSIONS", "pdf,jpg,jpeg,png,doc,docx,txt")
+
+
+# ============================================================
+# EVENT LOOP  (session-scoped)
+# ============================================================
+
+@pytest.fixture(scope="session")
+def event_loop() -> Generator:
+    """Event loop compartido para toda la sesión de tests."""
+    policy = asyncio.get_event_loop_policy()
+    loop = policy.new_event_loop()
+    yield loop
+    loop.close()
+
+
+# ============================================================
+# ENGINE  (session-scoped — reutiliza el pool toda la sesión)
+# ============================================================
+
+@pytest.fixture(scope="session")
+async def engine():
+    """
+    Conecta al PostgreSQL Docker existente (servicemanager).
+    NO crea ni destruye el schema — la BD ya está lista.
+    """
+    from sqlalchemy.ext.asyncio import create_async_engine
+    import app.models  # noqa: F401 — registra todos los modelos
+
+    _engine = create_async_engine(os.environ["DATABASE_URL"], echo=False)
+    yield _engine
+    await _engine.dispose()
+
+
+# ============================================================
+# DB  (function-scoped — rollback para datos creados en el test)
+# ============================================================
+
+@pytest.fixture
+async def db(engine) -> AsyncGenerator:
+    """
+    Sesión con transacción por test.
+    Los datos seedeados son visibles (ya están committed).
+    Cualquier INSERT hecho en el test se revierte al finalizar.
+    """
+    from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+    factory = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+    async with factory() as session:
+        await session.begin()
+        yield session
+        await session.rollback()
+
+
+# ============================================================
+# TENANT  (function-scoped — lee el registro existente)
+# ============================================================
+
+@pytest.fixture
+async def tenant_a(db):
+    """Tenant 'aduanasoft' ya existente en la BD."""
+    from sqlalchemy import select
+    from app.models.tenant import Tenant
+
+    result = await db.execute(select(Tenant).where(Tenant.slug == "aduanasoft"))
+    return result.scalar_one()
+
+
+# ============================================================
+# USUARIOS  (function-scoped — leen registros existentes)
+# ============================================================
+
+@pytest.fixture
+async def admin_user(db, tenant_a):
+    """ADMIN: admin@aduanasoft.com (tenant aduanasoft)."""
+    from sqlalchemy import select
+    from app.models.user import User
+
+    result = await db.execute(
+        select(User)
+        .where(User.email == "admin@aduanasoft.com")
+        .where(User.tenant_id == tenant_a.id)
+    )
+    return result.scalar_one()
+
+
+@pytest.fixture
+async def manager_user(db, tenant_a):
+    """SUPPORT_MANAGER: manager@aduanasoft.com (tenant aduanasoft)."""
+    from sqlalchemy import select
+    from app.models.user import User
+
+    result = await db.execute(
+        select(User)
+        .where(User.email == "manager@aduanasoft.com")
+        .where(User.tenant_id == tenant_a.id)
+    )
+    return result.scalar_one()
+
+
+@pytest.fixture
+async def agent_user(db, tenant_a):
+    """AGENT: agente@aduanasoft.com (tenant aduanasoft)."""
+    from sqlalchemy import select
+    from app.models.user import User
+
+    result = await db.execute(
+        select(User)
+        .where(User.email == "agente@aduanasoft.com")
+        .where(User.tenant_id == tenant_a.id)
+    )
+    return result.scalar_one()
+
+
+@pytest.fixture
+async def user_tenant_a(db, tenant_a):
+    """CLIENT_USER: test_user@aduanasoft.com (tenant aduanasoft)."""
+    from sqlalchemy import select
+    from app.models.user import User
+
+    result = await db.execute(
+        select(User)
+        .where(User.email == "test_user@aduanasoft.com")
+        .where(User.tenant_id == tenant_a.id)
+    )
+    return result.scalar_one()
+
+
+# ============================================================
+# HTTP CLIENT  (function-scoped)
+# ============================================================
+
+@pytest.fixture
+async def client(db) -> AsyncGenerator:
+    """
+    httpx.AsyncClient contra la app FastAPI en memoria (sin red).
+    get_db queda sobreescrito para inyectar la sesión de test.
+    Los cambios del test se revierten al terminar (rollback en db).
+    """
+    import httpx
+    from httpx import ASGITransport
+    from app.main import app
+    from app.core.database import get_db
+
+    async def _override_get_db():
+        yield db
+
+    app.dependency_overrides[get_db] = _override_get_db
+
+    async with httpx.AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://test",
+    ) as ac:
+        yield ac
+
+    app.dependency_overrides.pop(get_db, None)
+
+
+# ============================================================
+# FIXTURES DE AISLAMIENTO MULTI-TENANT
+# ============================================================
+
+@pytest.fixture
+def make_token():
+    """Factory de JWT tokens para autenticar clientes HTTP en tests."""
+    from app.core.security import security
+
+    def _make(user):
+        return security.create_access_token(data={"sub": str(user.id)})
+
+    return _make
+
+
+@pytest.fixture
+async def app_with_db(db):
+    """
+    Override de get_db compartido para todos los HTTP clients de un mismo test.
+    Garantiza que todos los clients usen la misma sesión (y el mismo rollback).
+    """
+    from app.main import app as _app
+    from app.core.database import get_db
+
+    async def _override():
+        yield db
+
+    _app.dependency_overrides[get_db] = _override
+    yield _app
+    _app.dependency_overrides.pop(get_db, None)
+
+
+@pytest.fixture
+async def tenant_b(db):
+    """Tenant 'empresa-test' creado en la transacción del test (se revierte al final)."""
+    from app.models.tenant import Tenant
+
+    t = Tenant(name="Empresa Test", slug="empresa-test")
+    db.add(t)
+    await db.flush()
+    return t
+
+
+@pytest.fixture
+async def user_b(db, tenant_b):
+    """CLIENT_ADMIN en tenant_b — puede gestionar recursos de su tenant."""
+    from app.models.user import User, UserRole
+    from app.core.security import security
+
+    u = User(
+        tenant_id=tenant_b.id,
+        email="admin@empresa-test.com",
+        first_name="Admin",
+        last_name="Test",
+        password_hash=security.hash_password("Test1234!"),
+        role=UserRole.CLIENT_ADMIN,
+        is_active=True,
+        email_verified=True,
+    )
+    db.add(u)
+    await db.flush()
+    return u
+
+
+@pytest.fixture
+async def client_tenant_a(app_with_db, manager_user, make_token):
+    """HTTP client autenticado como SUPPORT_MANAGER de tenant_a (aduanasoft).
+    Usa manager_user en lugar de admin_user para mantener el aislamiento de
+    tenant en GET /users/ (el ADMIN global bypasa el filtro de tenant).
+    """
+    import httpx
+    from httpx import ASGITransport
+
+    token = make_token(manager_user)
+    async with httpx.AsyncClient(
+        transport=ASGITransport(app=app_with_db),
+        base_url="http://test",
+        headers={"Authorization": f"Bearer {token}"},
+    ) as ac:
+        yield ac
+
+
+@pytest.fixture
+async def client_tenant_b(app_with_db, user_b, make_token):
+    """HTTP client autenticado como CLIENT_ADMIN de tenant_b (empresa-test)."""
+    import httpx
+    from httpx import ASGITransport
+
+    token = make_token(user_b)
+    async with httpx.AsyncClient(
+        transport=ASGITransport(app=app_with_db),
+        base_url="http://test",
+        headers={"Authorization": f"Bearer {token}"},
+    ) as ac:
+        yield ac
+
+
+@pytest.fixture
+async def client_admin(app_with_db, admin_user, make_token):
+    """HTTP client autenticado como ADMIN global."""
+    import httpx
+    from httpx import ASGITransport
+
+    token = make_token(admin_user)
+    async with httpx.AsyncClient(
+        transport=ASGITransport(app=app_with_db),
+        base_url="http://test",
+        headers={"Authorization": f"Bearer {token}"},
+    ) as ac:
+        yield ac
+
+
+@pytest.fixture
+def create_ticket_tenant_a(client_tenant_a):
+    """Factory: crea un ticket en tenant_a vía HTTP y retorna el JSON de respuesta."""
+    async def _create(subject="Ticket Tenant A", priority="MEDIUM"):
+        resp = await client_tenant_a.post("/v1/tickets/", json={
+            "subject": subject,
+            "description": "Test de aislamiento tenant A",
+            "priority": priority,
+        })
+        assert resp.status_code in (200, 201), f"Error creando ticket A: {resp.text}"
+        return resp.json()
+
+    return _create
+
+
+@pytest.fixture
+def create_ticket_tenant_b(client_tenant_b):
+    """Factory: crea un ticket en tenant_b vía HTTP y retorna el JSON de respuesta."""
+    async def _create(subject="Ticket Tenant B", priority="MEDIUM"):
+        resp = await client_tenant_b.post("/v1/tickets/", json={
+            "subject": subject,
+            "description": "Test de aislamiento tenant B",
+            "priority": priority,
+        })
+        assert resp.status_code in (200, 201), f"Error creando ticket B: {resp.text}"
+        return resp.json()
+
+    return _create
+
+
+@pytest.fixture
+def create_user_tenant_a(client_tenant_a):
+    """Factory: crea un usuario en tenant_a vía HTTP y retorna el JSON de respuesta."""
+    async def _create(email="nuevo_user_a@test.com"):
+        resp = await client_tenant_a.post("/v1/users/", json={
+            "email": email,
+            "first_name": "Usuario",
+            "last_name": "TenantA",
+            "password": "Test1234!",
+            "role": "CLIENT_USER",
+        })
+        assert resp.status_code in (200, 201), f"Error creando user A: {resp.text}"
+        return resp.json()
+
+    return _create
+
+
+@pytest.fixture
+def create_user_tenant_b(client_tenant_b):
+    """Factory: crea un usuario en tenant_b vía HTTP y retorna el JSON de respuesta."""
+    async def _create(email="nuevo_user_b@test.com"):
+        resp = await client_tenant_b.post("/v1/users/", json={
+            "email": email,
+            "first_name": "Usuario",
+            "last_name": "TenantB",
+            "password": "Test1234!",
+            "role": "CLIENT_USER",
+        })
+        assert resp.status_code in (200, 201), f"Error creando user B: {resp.text}"
+        return resp.json()
+
+    return _create

backend/app/tests/test_smoke.py

@@ -0,0 +1,137 @@
+"""
+Smoke Tests - ServiceManagerWeb
+
+Verifican que el stack completo funciona:
+  - Conexión a BD Docker
+  - Fixtures de tenant y usuarios
+  - Login vía HTTP (httpx + FastAPI en memoria)
+  - Endpoint protegido con token
+"""
+
+import pytest
+
+
+# ============================================================
+# BD + FIXTURES
+# ============================================================
+
+@pytest.mark.asyncio
+async def test_db_connected(db):
+    """La sesión de BD está activa y responde."""
+    from sqlalchemy import text
+    result = await db.execute(text("SELECT 1"))
+    assert result.scalar() == 1
+
+
+@pytest.mark.asyncio
+async def test_tenant_a_existe(tenant_a):
+    """El tenant 'aduanasoft' existe y tiene datos válidos."""
+    assert tenant_a.slug == "aduanasoft"
+    assert tenant_a.name is not None
+
+
+@pytest.mark.asyncio
+async def test_admin_user_existe(admin_user):
+    """El usuario ADMIN existe y pertenece al tenant correcto."""
+    from app.models.user import UserRole
+    assert admin_user.email == "admin@aduanasoft.com"
+    assert admin_user.role == UserRole.ADMIN
+    assert admin_user.is_active is True
+
+
+@pytest.mark.asyncio
+async def test_manager_user_existe(manager_user):
+    """El usuario SUPPORT_MANAGER existe."""
+    from app.models.user import UserRole
+    assert manager_user.email == "manager@aduanasoft.com"
+    assert manager_user.role == UserRole.SUPPORT_MANAGER
+
+
+@pytest.mark.asyncio
+async def test_agent_user_existe(agent_user):
+    """El usuario AGENT existe."""
+    from app.models.user import UserRole
+    assert agent_user.email == "agente@aduanasoft.com"
+    assert agent_user.role == UserRole.AGENT
+
+
+@pytest.mark.asyncio
+async def test_client_user_existe(user_tenant_a):
+    """El CLIENT_USER existe."""
+    from app.models.user import UserRole
+    assert user_tenant_a.email == "test_user@aduanasoft.com"
+    assert user_tenant_a.role == UserRole.CLIENT_USER
+
+
+# ============================================================
+# HTTP — LOGIN
+# ============================================================
+
+@pytest.mark.asyncio
+async def test_login_admin_ok(client):
+    """Login con credenciales de admin devuelve access_token."""
+    response = await client.post(
+        "/v1/auth/login",
+        json={
+            "email": "admin@aduanasoft.com",
+            "password": "admin123",
+            "tenant_slug": "aduanasoft",
+        },
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert "access_token" in data
+    assert data["token_type"] == "bearer"
+
+
+@pytest.mark.asyncio
+async def test_login_credenciales_invalidas(client):
+    """Login con contraseña incorrecta devuelve 401."""
+    response = await client.post(
+        "/v1/auth/login",
+        json={
+            "email": "admin@aduanasoft.com",
+            "password": "wrongpassword",
+            "tenant_slug": "aduanasoft",
+        },
+    )
+    assert response.status_code == 401
+
+
+@pytest.mark.asyncio
+async def test_endpoint_sin_token_devuelve_401(client):
+    """Acceder a un endpoint protegido sin token devuelve 401."""
+    response = await client.get(
+        "/v1/users/me",
+        headers={"X-Tenant-Slug": "aduanasoft"},
+    )
+    assert response.status_code == 401
+
+
+@pytest.mark.asyncio
+async def test_login_y_me(client):
+    """Login exitoso → /users/me devuelve el usuario correcto."""
+    # Login
+    login = await client.post(
+        "/v1/auth/login",
+        json={
+            "email": "admin@aduanasoft.com",
+            "password": "admin123",
+            "tenant_slug": "aduanasoft",
+        },
+    )
+    assert login.status_code == 200
+    token = login.json()["access_token"]
+
+    # Endpoint protegido
+    me = await client.get(
+        "/v1/users/me",
+        headers={
+            "Authorization": f"Bearer {token}",
+            "X-Tenant-Slug": "aduanasoft",
+        },
+    )
+    assert me.status_code == 200
+    data = me.json()
+    assert data["email"] == "admin@aduanasoft.com"
+    assert data["role"] == "ADMIN"

backend/app/tests/test_tenant_isolation.py

@@ -0,0 +1,123 @@
+"""
+Pruebas de aislamiento multi-tenant para tickets y usuarios.
+Usa solo los fixtures definidos en conftest.py.
+
+Roles en juego:
+  client_tenant_a  → SUPPORT_MANAGER (aduanasoft) — restringido a su tenant
+  client_tenant_b  → CLIENT_ADMIN   (empresa-test) — restringido a su tenant
+  client_admin     → ADMIN global   (aduanasoft)   — acceso a todos los tenants
+"""
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_tenant_a_cannot_see_tenant_b_tickets(
+    client_tenant_a, create_ticket_tenant_b
+):
+    """
+    El usuario del tenant B crea un ticket.
+    El usuario del tenant A (SUPPORT_MANAGER) lista sus tickets.
+    El ticket de tenant B NO debe aparecer en la respuesta.
+    """
+    # El usuario del tenant B crea un ticket
+    ticket_b = await create_ticket_tenant_b()
+    ticket_b_id = ticket_b["id"]
+
+    # El usuario del tenant A lista sus tickets
+    response = await client_tenant_a.get("/v1/tickets/")
+    assert response.status_code == 200
+
+    ids_visibles = {t["id"] for t in response.json()}
+
+    # El ticket de tenant B no debe ser visible para tenant A
+    assert ticket_b_id not in ids_visibles, (
+        f"Fallo de aislamiento: ticket de tenant B ({ticket_b_id}) "
+        f"visible para usuario de tenant A"
+    )
+
+
+@pytest.mark.asyncio
+async def test_tenant_b_cannot_edit_tenant_a_ticket(
+    create_ticket_tenant_a, client_tenant_b
+):
+    """
+    El usuario del tenant A crea un ticket.
+    El usuario del tenant B intenta editar ese ticket vía PATCH.
+    Debe recibir 403 (prohibido) o 404 (no encontrado).
+    """
+    # El usuario del tenant A crea un ticket
+    ticket_a = await create_ticket_tenant_a()
+    ticket_a_id = ticket_a["id"]
+
+    # El usuario del tenant B intenta editar el ticket de tenant A
+    response = await client_tenant_b.patch(
+        f"/v1/tickets/{ticket_a_id}",
+        json={"status": "CLOSED"},
+    )
+
+    # Debe recibir 403 o 404 — nunca 200
+    assert response.status_code in (403, 404), (
+        f"Fallo de aislamiento: tenant B pudo editar ticket de tenant A "
+        f"(HTTP {response.status_code})"
+    )
+
+
+@pytest.mark.asyncio
+async def test_tenant_a_cannot_see_tenant_b_users(
+    client_tenant_a, create_user_tenant_b
+):
+    """
+    El usuario del tenant B crea un usuario nuevo.
+    El usuario del tenant A (SUPPORT_MANAGER) lista los usuarios.
+    El usuario de tenant B NO debe aparecer en la respuesta.
+    """
+    # El usuario del tenant B crea un usuario
+    user_b = await create_user_tenant_b()
+    user_b_id = user_b["id"]
+
+    # El usuario del tenant A lista los usuarios de su tenant
+    response = await client_tenant_a.get("/v1/users/")
+    assert response.status_code == 200
+
+    ids_visibles = {u["id"] for u in response.json()}
+
+    # El usuario de tenant B no debe ser visible para tenant A
+    assert user_b_id not in ids_visibles, (
+        f"Fallo de aislamiento: usuario de tenant B ({user_b_id}) "
+        f"visible para usuario de tenant A"
+    )
+
+
+@pytest.mark.asyncio
+async def test_admin_sees_all_tenant_data(
+    client_admin,
+    create_ticket_tenant_a,
+    create_ticket_tenant_b,
+    create_user_tenant_a,
+    create_user_tenant_b,
+):
+    """
+    El ADMIN global debe poder ver tickets y usuarios de TODOS los tenants.
+    - Tickets: vía /v1/tickets/admin/all (endpoint multi-tenant).
+    - Usuarios: vía /v1/users/ (ADMIN bypasa el filtro de tenant).
+    """
+    # Crear datos en ambos tenants
+    ticket_a = await create_ticket_tenant_a()
+    ticket_b = await create_ticket_tenant_b()
+    user_a = await create_user_tenant_a()
+    user_b = await create_user_tenant_b()
+
+    # El admin lista todos los tickets (endpoint multi-tenant)
+    resp_tickets = await client_admin.get("/v1/tickets/admin/all")
+    assert resp_tickets.status_code == 200
+    ids_tickets = {t["id"] for t in resp_tickets.json()}
+    assert ticket_a["id"] in ids_tickets, "El ADMIN no ve el ticket de tenant A"
+    assert ticket_b["id"] in ids_tickets, "El ADMIN no ve el ticket de tenant B"
+
+    # El admin lista todos los usuarios (ADMIN bypasa filtro de tenant)
+    resp_users = await client_admin.get("/v1/users/")
+    assert resp_users.status_code == 200
+    ids_users = {u["id"] for u in resp_users.json()}
+    assert user_a["id"] in ids_users, "El ADMIN no ve el usuario de tenant A"
+    assert user_b["id"] in ids_users, "El ADMIN no ve el usuario de tenant B"
+

backend/migrations/versions/b7c8d9e0f1a2_add_ticket_indexes.py

@@ -0,0 +1,43 @@
+"""add_ticket_indexes
+
+Revision ID: b7c8d9e0f1a2
+Revises: fix_client_timestamps
+Create Date: 2026-03-03 00:00:00.000000
+
+Agrega índices a la tabla tickets para optimizar queries frecuentes:
+  - idx_tickets_status            → filtros por estado
+  - idx_tickets_priority          → filtros por prioridad
+  - idx_tickets_assigned_to       → tickets por agente asignado
+  - idx_tickets_tenant_status     → compuesto multi-tenant (tenant_id, status)
+"""
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = 'b7c8d9e0f1a2'
+down_revision = 'fix_client_timestamps'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.execute(
+        "CREATE INDEX IF NOT EXISTS idx_tickets_status ON tickets (status)"
+    )
+    op.execute(
+        "CREATE INDEX IF NOT EXISTS idx_tickets_priority ON tickets (priority)"
+    )
+    op.execute(
+        "CREATE INDEX IF NOT EXISTS idx_tickets_assigned_to "
+        "ON tickets (assigned_to) WHERE assigned_to IS NOT NULL"
+    )
+    op.execute(
+        "CREATE INDEX IF NOT EXISTS idx_tickets_tenant_status "
+        "ON tickets (tenant_id, status)"
+    )
+
+
+def downgrade() -> None:
+    op.execute("DROP INDEX IF EXISTS idx_tickets_tenant_status")
+    op.execute("DROP INDEX IF EXISTS idx_tickets_assigned_to")
+    op.execute("DROP INDEX IF EXISTS idx_tickets_priority")
+    op.execute("DROP INDEX IF EXISTS idx_tickets_status")

backend/migrations/versions/c1d2e3f4a5b6_add_client_roles_to_user_role_enum.py

@@ -0,0 +1,35 @@
+"""Add CLIENT_MANAGER, CLIENT_AGENT, CLIENT_AUDITOR to user_role_enum
+
+Revision ID: c1d2e3f4a5b6
+Revises: b7c8d9e0f1a2
+Create Date: 2026-03-03 10:00:00.000000
+
+Agrega tres nuevos roles de cliente al enum PostgreSQL:
+  - CLIENT_MANAGER  → gestiona tickets y usuarios del tenant
+  - CLIENT_AGENT    → atiende tickets del tenant
+  - CLIENT_AUDITOR  → auditoría de solo lectura del tenant
+"""
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision = 'c1d2e3f4a5b6'
+down_revision = 'b7c8d9e0f1a2'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # PostgreSQL permite agregar valores a un enum con ADD VALUE.
+    # IF NOT EXISTS evita error si la migración se aplica dos veces.
+    op.execute("ALTER TYPE user_role_enum ADD VALUE IF NOT EXISTS 'CLIENT_MANAGER'")
+    op.execute("ALTER TYPE user_role_enum ADD VALUE IF NOT EXISTS 'CLIENT_AGENT'")
+    op.execute("ALTER TYPE user_role_enum ADD VALUE IF NOT EXISTS 'CLIENT_AUDITOR'")
+
+
+def downgrade() -> None:
+    # PostgreSQL no permite eliminar valores de un enum con ALTER TYPE DROP VALUE.
+    # Para revertir habría que recrear el tipo completo desde cero, lo que requiere
+    # actualizar todas las columnas que lo usan. Se documenta como no reversible
+    # automáticamente — usar con precaución.
+    pass

backend/migrations/versions/d2e3f4a5b6c7_remove_intermediate_client_roles.py

@@ -0,0 +1,92 @@
+"""Remove CLIENT_MANAGER, CLIENT_AGENT, CLIENT_AUDITOR from user_role_enum
+
+Revision ID: d2e3f4a5b6c7
+Revises: c1d2e3f4a5b6
+Create Date: 2026-03-03 14:00:00.000000
+
+Consolida 9 roles → 6 roles migrando datos primero y luego recreando
+el tipo enum de PostgreSQL (única forma de eliminar valores en PG).
+
+Mapeo de datos:
+  CLIENT_MANAGER  → CLIENT_ADMIN   (conserva nivel de gestión)
+  CLIENT_AGENT    → CLIENT_USER    (acceso básico de cliente)
+  CLIENT_AUDITOR  → CLIENT_USER    (acceso básico de cliente)
+
+ADVERTENCIA DOWNGRADE: La migración inversa restaura los valores del
+enum pero NO puede recuperar la distinción original entre CLIENT_AGENT
+y CLIENT_AUDITOR (ambos quedaron como CLIENT_USER). El downgrade es
+seguro a nivel de integridad de datos, pero irreversible en semántica.
+"""
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision = 'd2e3f4a5b6c7'
+down_revision = 'c1d2e3f4a5b6'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ── Paso 1: Migrar datos ANTES de modificar el tipo ────────────────────
+    # CLIENT_MANAGER → CLIENT_ADMIN (conserva acceso de gestión)
+    op.execute("UPDATE users SET role = 'CLIENT_ADMIN' WHERE role = 'CLIENT_MANAGER'")
+    # CLIENT_AGENT   → CLIENT_USER  (acceso básico de cliente)
+    op.execute("UPDATE users SET role = 'CLIENT_USER'  WHERE role = 'CLIENT_AGENT'")
+    # CLIENT_AUDITOR → CLIENT_USER  (acceso básico de cliente)
+    op.execute("UPDATE users SET role = 'CLIENT_USER'  WHERE role = 'CLIENT_AUDITOR'")
+
+    # ── Paso 2: Soltar la restricción de tipo para poder recrear el enum ───
+    # PostgreSQL no permite DROP VALUE en un enum; hay que recrear el tipo.
+    op.execute("ALTER TABLE users ALTER COLUMN role TYPE TEXT")
+
+    # ── Paso 3: Eliminar tipo actual y recrearlo solo con los 6 roles ──────
+    op.execute("DROP TYPE user_role_enum")
+    op.execute("""
+        CREATE TYPE user_role_enum AS ENUM (
+            'ADMIN',
+            'SUPPORT_MANAGER',
+            'AGENT',
+            'AUDITOR',
+            'CLIENT_ADMIN',
+            'CLIENT_USER'
+        )
+    """)
+
+    # ── Paso 4: Restaurar columna al tipo enum ──────────────────────────────
+    op.execute(
+        "ALTER TABLE users ALTER COLUMN role TYPE user_role_enum "
+        "USING role::user_role_enum"
+    )
+
+
+def downgrade() -> None:
+    # ── Paso 1: Soltar la restricción de tipo para recrear el enum ─────────
+    op.execute("ALTER TABLE users ALTER COLUMN role TYPE TEXT")
+
+    # ── Paso 2: Recrear enum con los 9 valores originales ──────────────────
+    op.execute("DROP TYPE user_role_enum")
+    op.execute("""
+        CREATE TYPE user_role_enum AS ENUM (
+            'ADMIN',
+            'SUPPORT_MANAGER',
+            'AGENT',
+            'AUDITOR',
+            'CLIENT_ADMIN',
+            'CLIENT_MANAGER',
+            'CLIENT_AGENT',
+            'CLIENT_AUDITOR',
+            'CLIENT_USER'
+        )
+    """)
+
+    # ── Paso 3: Restaurar columna al tipo enum ──────────────────────────────
+    op.execute(
+        "ALTER TABLE users ALTER COLUMN role TYPE user_role_enum "
+        "USING role::user_role_enum"
+    )
+
+    # ── Nota sobre pérdida de datos ─────────────────────────────────────────
+    # Los usuarios que eran CLIENT_MANAGER ahora son CLIENT_ADMIN.
+    # Los usuarios que eran CLIENT_AGENT o CLIENT_AUDITOR ahora son CLIENT_USER.
+    # No es posible restaurar la distinción original automáticamente.

backend/requirements.txt

@@ -31,6 +31,7 @@ pyotp==2.9.0             # TOTP/2FA support
 # ===================================
 celery==5.3.4
 redis==5.0.1
+slowapi==0.1.9          # Rate limiting middleware
 
 # ===================================
 # EMAIL

docker-compose.yml

@@ -32,7 +32,7 @@ services:
     container_name: servicemanager-redis
     restart: unless-stopped
     command: redis-server --appendonly yes
-    volumes:
+    volumes:                                                                                                                                                                                                                                                                                                                                                                
       - redis_data:/data
     ports:
       - "6379:6379"

frontend-client/src/app.d.ts

@@ -0,0 +1,11 @@
+import type { User } from '$lib/stores/auth';
+
+declare global {
+	namespace App {
+		interface Locals {
+			user: User | null;
+		}
+	}
+}
+
+export {};

frontend-client/src/app.html

@@ -2,7 +2,7 @@
 <html lang="es">
 	<head>
 		<meta charset="utf-8" />
-		<link rel="icon" href="%sveltekit.assets%/favicon.png" />
+		<link rel="icon" href="%sveltekit.assets%/favicon.png" type="image/png" />
 		<meta name="viewport" content="width=device-width, initial-scale=1" />
 		<meta name="theme-color" content="#3b82f6" />
 		

frontend-client/src/hooks.server.ts

@@ -0,0 +1,19 @@
+import type { Handle } from '@sveltejs/kit';
+
+export const handle: Handle = async ({ event, resolve }) => {
+	const cookie = event.request.headers.get('cookie') ?? '';
+	if (cookie) {
+		try {
+			const apiUrl = process.env.PUBLIC_API_URL ?? 'http://backend:8000';
+			const response = await fetch(`${apiUrl}/v1/auth/me`, {
+				headers: { cookie, 'X-App': 'client' }
+			});
+			event.locals.user = response.ok ? await response.json() : null;
+		} catch {
+			event.locals.user = null;
+		}
+	} else {
+		event.locals.user = null;
+	}
+	return resolve(event);
+};

frontend-client/src/lib/stores/app.ts

@@ -29,15 +29,17 @@ const initialState: AppState = {
 // API helper function
 async function apiCall(endpoint: string, options: RequestInit = {}) {
   const authState = get(auth);
-  
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'X-App': 'client',
+    ...(authState.user?.tenant_id ? { 'X-Tenant-ID': authState.user.tenant_id } : {}),
+    ...(options.headers as Record<string, string> ?? {})
+  };
+  if (authState.token) headers['Authorization'] = `Bearer ${authState.token}`;
   const response = await fetch(`/api/v1${endpoint}`, {
     ...options,
-    headers: {
+    credentials: 'include',
-      'Content-Type': 'application/json',
+    headers
-      'Authorization': `Bearer ${authState.token}`,
-      ...(authState.user?.tenant_id ? { 'X-Tenant-ID': authState.user.tenant_id } : {}),
-      ...options.headers
-    }
   });
 
   if (!response.ok) {

frontend-client/src/lib/stores/auth.ts

@@ -50,26 +50,26 @@ function createAuthStore() {
   return {
     subscribe,
 
-    // Initialize auth from localStorage
+    // Rehidrata sesión desde cookie HttpOnly (no toca localStorage)
-    init: () => {
+    init: async () => {
       if (typeof window !== 'undefined') {
-        const token = localStorage.getItem('auth_token');
+        try {
-        const user = localStorage.getItem('auth_user');
+          const response = await fetch('/api/v1/auth/me', {
-
+            credentials: 'include',
-        if (token && user) {
+            headers: { 'X-App': 'client' }
-          try {
+          });
-            const parsedUser = JSON.parse(user);
+          if (response.ok) {
+            const user = await response.json();
             set({
-              user: parsedUser,
+              user,
-              token,
+              token: null,
               isAuthenticated: true,
               isLoading: false
             });
-          } catch (error) {
-            console.error('Error parsing stored auth data:', error);
-            localStorage.removeItem('auth_token');
-            localStorage.removeItem('auth_user');
           }
+          // 401/400 es esperado cuando no hay sesión activa — no es un error
+        } catch (error) {
+          // Ignorar errores de red en init
         }
       }
     },
@@ -81,6 +81,7 @@ function createAuthStore() {
       try {
         const response = await fetch('/api/v1/auth/login', {
           method: 'POST',
+          credentials: 'include',
           headers: {
             'Content-Type': 'application/json',
           },
@@ -94,12 +95,6 @@ function createAuthStore() {
 
         const data: LoginResponse = await response.json();
 
-        // Store auth data
-        if (typeof window !== 'undefined') {
-          localStorage.setItem('auth_token', data.access_token);
-          localStorage.setItem('auth_user', JSON.stringify(data.user));
-        }
-
         set({
           user: data.user,
           token: data.access_token,
@@ -113,22 +108,29 @@ function createAuthStore() {
     },
 
     // Logout
-    logout: () => {
+    logout: async () => {
+      // Llamar al backend para que borre la cookie HttpOnly
+      try {
+        await fetch('/api/v1/auth/logout', {
+          method: 'POST',
+          credentials: 'include',
+          headers: { 'X-App': 'client' }
+        });
+      } catch { /* ignorar errores de red */ }
+      set(initialState);
       if (typeof window !== 'undefined') {
-        localStorage.removeItem('auth_token');
-        localStorage.removeItem('auth_user');
-        // Immediate redirect after cleanup
         window.location.href = '/login';
       }
-      set(initialState);
     },
 
     // Update user data
     updateUser: (user: User) => {
       update(state => ({ ...state, user }));
-      if (typeof window !== 'undefined') {
+    },
-        localStorage.setItem('auth_user', JSON.stringify(user));
+
-      }
+    // Set user from SSR pre-load (no fetch required)
+    setUser: (user: User) => {
+      set({ user, token: null, isAuthenticated: true, isLoading: false });
     },
 
     // Set loading state

frontend-client/src/lib/stores/tickets.ts

@@ -80,18 +80,22 @@ const initialState: TicketsState = {
 async function apiCall(endpoint: string, options: RequestInit = {}) {
   const authState = get(auth);
 
-  if (!authState.token || !authState.user) {
+  if (!authState.user) {
     throw new Error('Not authenticated');
   }
 
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'X-App': 'client',
+    ...(options.headers as Record<string, string>)
+  };
+  if (authState.token) headers['Authorization'] = `Bearer ${authState.token}`;
+  if (authState.user.tenant_id) headers['X-Tenant-ID'] = authState.user.tenant_id;
+
   const response = await fetch(`/api/v1${endpoint}`, {
     ...options,
-    headers: {
+    credentials: 'include',
-      'Content-Type': 'application/json',
+    headers
-      'Authorization': `Bearer ${authState.token}`,
-      'X-Tenant-ID': authState.user.tenant_id,
-      ...options.headers
-    }
   });
 
   if (!response.ok) {
@@ -259,16 +263,18 @@ function createTicketsStore() {
 
         const authState = get(auth);
 
-        if (!authState.token || !authState.user) {
+        if (!authState.user) {
           throw new Error('Not authenticated');
         }
 
+        const uploadHeaders: Record<string, string> = { 'X-App': 'client' };
+        if (authState.token) uploadHeaders['Authorization'] = `Bearer ${authState.token}`;
+        if (authState.user.tenant_id) uploadHeaders['X-Tenant-ID'] = authState.user.tenant_id;
+
         const response = await fetch(`/api/v1/tickets/${ticketId}/attachments`, {
           method: 'POST',
-          headers: {
+          credentials: 'include',
-            'Authorization': `Bearer ${authState.token}`,
+          headers: uploadHeaders,
-            'X-Tenant-ID': authState.user.tenant_id
-          },
           body: formData
         });
 
@@ -338,16 +344,18 @@ function createTicketsStore() {
     downloadAttachment: async (ticketId: string, attachmentId: string, filename: string) => {
       const authState = get(auth);
 
-      if (!authState.token || !authState.user) {
+      if (!authState.user) {
         throw new Error('Not authenticated');
       }
 
+      const dlHeaders: Record<string, string> = { 'X-App': 'client' };
+      if (authState.token) dlHeaders['Authorization'] = `Bearer ${authState.token}`;
+      if (authState.user.tenant_id) dlHeaders['X-Tenant-ID'] = authState.user.tenant_id;
+
       const response = await fetch(`/api/v1/tickets/${ticketId}/attachments/${attachmentId}/download`, {
         method: 'GET',
-        headers: {
+        credentials: 'include',
-          'Authorization': `Bearer ${authState.token}`,
+        headers: dlHeaders
-          'X-Tenant-ID': authState.user.tenant_id
-        }
       });
 
       if (!response.ok) {

frontend-client/src/lib/utils/api.ts

@@ -0,0 +1,126 @@
+/**
+ * Cliente HTTP centralizado para frontend-client.
+ * Usa cookies HttpOnly (client_access_token) como fuente primaria de auth,
+ * con Bearer token como complemento cuando está disponible en memoria.
+ */
+import { auth } from '$lib/stores/auth';
+import { get } from 'svelte/store';
+
+const API_BASE = '/api/v1';
+
+interface RequestOptions extends RequestInit {
+  params?: Record<string, string>;
+}
+
+async function request<T>(endpoint: string, options: RequestOptions = {}): Promise<T> {
+  const { params, ...init } = options;
+
+  let url = `${API_BASE}${endpoint}`;
+  if (params) {
+    const filteredParams = Object.entries(params)
+      .filter(([, value]) => value !== undefined && value !== null && value !== '')
+      .reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {});
+
+    if (Object.keys(filteredParams).length > 0) {
+      url += `?${new URLSearchParams(filteredParams).toString()}`;
+    }
+  }
+
+  const authState = get(auth);
+  const headers = new Headers(init.headers);
+
+  // Bearer header cuando el token está en memoria (sesión activa sin reload)
+  if (authState.token) {
+    headers.set('Authorization', `Bearer ${authState.token}`);
+  }
+  if (authState.user?.tenant_id && !headers.has('X-Tenant-ID')) {
+    headers.set('X-Tenant-ID', authState.user.tenant_id);
+  }
+  if (!headers.has('Content-Type')) {
+    headers.set('Content-Type', 'application/json');
+  }
+  // Identifica este frontend para que el backend use client_access_token
+  headers.set('X-App', 'client');
+
+  const response = await fetch(url, {
+    ...init,
+    credentials: 'include',
+    headers
+  });
+
+  if (response.status === 401) {
+    if (typeof window !== 'undefined') {
+      window.location.href = '/login';
+    }
+    throw new Error('Unauthorized');
+  }
+
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(errorData.detail || `API error: ${response.statusText}`);
+  }
+
+  if (response.status === 204) {
+    return {} as T;
+  }
+
+  return response.json();
+}
+
+async function downloadFile(endpoint: string, filename: string): Promise<void> {
+  const authState = get(auth);
+  const headers = new Headers();
+
+  if (authState.token) {
+    headers.set('Authorization', `Bearer ${authState.token}`);
+  }
+  if (authState.user?.tenant_id) {
+    headers.set('X-Tenant-ID', authState.user.tenant_id);
+  }
+  headers.set('X-App', 'client');
+
+  const response = await fetch(`${API_BASE}${endpoint}`, {
+    method: 'GET',
+    credentials: 'include',
+    headers
+  });
+
+  if (response.status === 401) {
+    if (typeof window !== 'undefined') window.location.href = '/login';
+    throw new Error('Unauthorized');
+  }
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(errorData.detail || `Download error: ${response.statusText}`);
+  }
+
+  const blob = await response.blob();
+  const url = window.URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  window.URL.revokeObjectURL(url);
+}
+
+export const api = {
+  get: <T>(endpoint: string, params?: Record<string, string>) =>
+    request<T>(endpoint, { method: 'GET', params }),
+
+  post: <T>(endpoint: string, body?: any) =>
+    request<T>(endpoint, { method: 'POST', body: body !== undefined ? JSON.stringify(body) : undefined }),
+
+  put: <T>(endpoint: string, body?: any) =>
+    request<T>(endpoint, { method: 'PUT', body: body !== undefined ? JSON.stringify(body) : undefined }),
+
+  patch: <T>(endpoint: string, body?: any) =>
+    request<T>(endpoint, { method: 'PATCH', body: body !== undefined ? JSON.stringify(body) : undefined }),
+
+  delete: <T>(endpoint: string) =>
+    request<T>(endpoint, { method: 'DELETE' }),
+
+  downloadFile: (endpoint: string, filename: string) =>
+    downloadFile(endpoint, filename)
+};

frontend-client/src/routes/+layout.server.ts

@@ -0,0 +1,7 @@
+import type { LayoutServerLoad } from './$types';
+
+export const load: LayoutServerLoad = ({ locals }) => {
+	return {
+		user: locals.user ?? null
+	};
+};

frontend-client/src/routes/+layout.svelte

@@ -9,10 +9,14 @@
   import { browser } from '$app/environment';
   import '../app.css';
 
+  export let data;
+
   let mounted = false;
 
   onMount(() => {
-    auth.init();
+    if (data.user && !$auth.isAuthenticated) {
+      auth.setUser(data.user);
+    }
     mounted = true;
   });
 
@@ -27,6 +31,12 @@
 </script>
 
 <div class="min-h-screen bg-gray-50 font-sans">
+  {#if !mounted}
+    <!-- Esperando inicialización de sesión -->
+    <div class="flex items-center justify-center min-h-screen bg-gray-50">
+      <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600"></div>
+    </div>
+  {:else}
   {#if showHeader}
     <Header />
   {/if}
@@ -39,6 +49,7 @@
   <footer class="py-4 text-center border-t border-gray-200 bg-white">
     <p class="text-xs text-gray-400">ServiceManagerWeb v1.9.0 · © 2026 Aduanasoft</p>
   </footer>
+  {/if}
   
   <!-- Toast notifications -->
   {#each $toast.toasts as toastMessage (toastMessage.id)}

frontend-client/src/routes/organization/+page.svelte

@@ -38,11 +38,14 @@
   async function loadProfile() {
     isLoading = true;
     try {
+      const headers: Record<string, string> = {
+        'X-App': 'client',
+        'X-Tenant-ID': $auth.user?.tenant_id ?? ''
+      };
+      if ($auth.token) headers['Authorization'] = `Bearer ${$auth.token}`;
       const response = await fetch('/api/v1/client-profile/', {
-        headers: {
+        credentials: 'include',
-          Authorization: `Bearer ${$auth.token}`,
+        headers
-          'X-Tenant-ID': $auth.user?.tenant_id ?? ''
-        }
       });
       if (!response.ok) throw new Error((await response.json()).detail);
       profile = await response.json();
@@ -62,13 +65,16 @@
   async function saveProfile() {
     isSaving = true;
     try {
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        'X-App': 'client',
+        'X-Tenant-ID': $auth.user?.tenant_id ?? ''
+      };
+      if ($auth.token) headers['Authorization'] = `Bearer ${$auth.token}`;
       const response = await fetch('/api/v1/client-profile/', {
         method: 'PUT',
-        headers: {
+        credentials: 'include',
-          'Content-Type': 'application/json',
+        headers,
-          Authorization: `Bearer ${$auth.token}`,
-          'X-Tenant-ID': $auth.user?.tenant_id ?? ''
-        },
         body: JSON.stringify(form)
       });
       if (!response.ok) throw new Error((await response.json()).detail);

frontend-client/src/routes/profile/+page.svelte

@@ -34,7 +34,11 @@
     try {
       const response = await fetch('/api/v1/auth/2fa/setup', {
         method: 'POST',
-        headers: { Authorization: `Bearer ${$auth.token}` }
+        credentials: 'include',
+        headers: {
+          'X-App': 'client',
+          ...($auth.token ? { Authorization: `Bearer ${$auth.token}` } : {})
+        }
       });
       if (!response.ok) throw new Error((await response.json()).detail);
       const data = await response.json();
@@ -57,7 +61,12 @@
     try {
       const response = await fetch('/api/v1/auth/2fa/enable', {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${$auth.token}` },
+        credentials: 'include',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-App': 'client',
+          ...($auth.token ? { Authorization: `Bearer ${$auth.token}` } : {})
+        },
         body: JSON.stringify({ totp_code: totpSetupCode })
       });
       if (!response.ok) throw new Error((await response.json()).detail);
@@ -84,7 +93,12 @@
     try {
       const response = await fetch('/api/v1/auth/2fa/disable', {
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${$auth.token}` },
+        credentials: 'include',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-App': 'client',
+          ...($auth.token ? { Authorization: `Bearer ${$auth.token}` } : {})
+        },
         body: JSON.stringify({ totp_code: disableTotpCode })
       });
       if (!response.ok) throw new Error((await response.json()).detail);
@@ -157,16 +171,20 @@
 
   async function loadBusinessProfile() {
     try {
-      if (!$auth.token || !$auth.user) {
+      if (!$auth.user) {
         console.warn('Usuario no autenticado');
         return;
       }
 
+      const _lpHeaders: Record<string, string> = {
+        'X-App': 'client',
+        'X-Tenant-ID': $auth.user.tenant_id
+      };
+      if ($auth.token) _lpHeaders['Authorization'] = `Bearer ${$auth.token}`;
+
       const response = await fetch('/api/v1/client-profile/', {
-        headers: {
+        credentials: 'include',
-          Authorization: `Bearer ${$auth.token}`,
+        headers: _lpHeaders
-          'X-Tenant-ID': $auth.user.tenant_id
-        }
       });
 
       if (response.ok) {
@@ -267,9 +285,11 @@
     try {
       const response = await fetch('/api/v1/auth/profile', {
         method: 'PATCH',
+        credentials: 'include',
         headers: {
           'Content-Type': 'application/json',
-          Authorization: `Bearer ${$auth.token}`
+          'X-App': 'client',
+          ...($auth.token ? { Authorization: `Bearer ${$auth.token}` } : {})
         },
         body: JSON.stringify({
           first_name: firstName.trim(),
@@ -300,9 +320,11 @@
     try {
       const response = await fetch('/api/v1/auth/change-password', {
         method: 'POST',
+        credentials: 'include',
         headers: {
           'Content-Type': 'application/json',
-          Authorization: `Bearer ${$auth.token}`
+          'X-App': 'client',
+          ...($auth.token ? { Authorization: `Bearer ${$auth.token}` } : {})
         },
         body: JSON.stringify({
           current_password: currentPassword,
@@ -349,13 +371,16 @@
         profileData.credit_limit = parseFloat(profileData.credit_limit);
       }
 
+      const _bpHeaders: Record<string, string> = {
+        'Content-Type': 'application/json',
+        'X-App': 'client',
+        'X-Tenant-ID': $auth.user?.tenant_id ?? ''
+      };
+      if ($auth.token) _bpHeaders['Authorization'] = `Bearer ${$auth.token}`;
       const response = await fetch('/api/v1/client-profile/', {
         method: 'POST',
-        headers: {
+        credentials: 'include',
-          'Content-Type': 'application/json',
+        headers: _bpHeaders,
-          Authorization: `Bearer ${$auth.token}`,
-          'X-Tenant-ID': $auth.user.tenant_id
-        },
         body: JSON.stringify(profileData)
       });
 

frontend-internal/src/app.d.ts

@@ -0,0 +1,11 @@
+import type { InternalUser } from '$lib/stores/auth';
+
+declare global {
+	namespace App {
+		interface Locals {
+			user: InternalUser | null;
+		}
+	}
+}
+
+export {};

frontend-internal/src/app.html

@@ -4,7 +4,7 @@
     <meta charset="utf-8" />
     <meta name="description" content="ServiceManager - Mesa de Ayuda Empresarial - Portal Interno" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <link rel="icon" href="%sveltekit.assets%/favicon.ico" />
+    <link rel="icon" href="%sveltekit.assets%/favicon.png" type="image/png" />
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">

frontend-internal/src/hooks.server.ts

@@ -0,0 +1,19 @@
+import type { Handle } from '@sveltejs/kit';
+
+export const handle: Handle = async ({ event, resolve }) => {
+	const cookie = event.request.headers.get('cookie') ?? '';
+	if (cookie) {
+		try {
+			const apiUrl = process.env.PUBLIC_API_URL ?? 'http://backend:8000';
+			const response = await fetch(`${apiUrl}/v1/auth/me`, {
+				headers: { cookie, 'X-App': 'internal' }
+			});
+			event.locals.user = response.ok ? await response.json() : null;
+		} catch {
+			event.locals.user = null;
+		}
+	} else {
+		event.locals.user = null;
+	}
+	return resolve(event);
+};

frontend-internal/src/lib/stores/auth.ts

@@ -60,32 +60,34 @@ const initialState: AuthState = {
 function createAuthStore() {
   const { subscribe, set, update } = writable<AuthState>(initialState);
 
+  // Track current state for uso interno (evita dependencias circulares)
+  let _state = initialState;
+  subscribe(s => { _state = s; });
+
   return {
     subscribe,
     
-    // Initialize auth from localStorage
+    // Rehidrata sesión desde cookie HttpOnly (no toca localStorage)
-    init: () => {
+    init: async () => {
       if (typeof window !== 'undefined') {
-        const token = localStorage.getItem('internal_auth_token');
+        try {
-        const refreshToken = localStorage.getItem('internal_auth_refresh_token');
+          const response = await fetch('/api/v1/auth/me', {
-        const user = localStorage.getItem('internal_auth_user');
+            credentials: 'include',
-        
+            headers: { 'X-App': 'internal' }
-        if (token && user) {
+          });
-          try {
+          if (response.ok) {
-            const parsedUser = JSON.parse(user);
+            const user = await response.json();
             set({
-              user: parsedUser,
+              user,
-              token,
+              token: null,
-              refreshToken: refreshToken || null,
+              refreshToken: null,
               isAuthenticated: true,
               isLoading: false
             });
-          } catch (error) {
-            console.error('Error parsing stored auth data:', error);
-            localStorage.removeItem('internal_auth_token');
-            localStorage.removeItem('internal_auth_refresh_token');
-            localStorage.removeItem('internal_auth_user');
           }
+          // 401/400 es esperado cuando no hay sesión activa — no es un error
+        } catch (error) {
+          // Ignorar errores de red en init
         }
       }
     },
@@ -97,6 +99,7 @@ function createAuthStore() {
       try {
         const response = await fetch('/api/v1/auth/login', {
           method: 'POST',
+          credentials: 'include',
           headers: {
             'Content-Type': 'application/json',
           },
@@ -109,15 +112,6 @@ function createAuthStore() {
         }
 
         const data: LoginResponse = await response.json();
-        
-        // Store auth data
-        if (typeof window !== 'undefined') {
-          localStorage.setItem('internal_auth_token', data.access_token);
-          if (data.refresh_token) {
-              localStorage.setItem('internal_auth_refresh_token', data.refresh_token);
-          }
-          localStorage.setItem('internal_auth_user', JSON.stringify(data.user));
-        }
 
         set({
           user: data.user,
@@ -134,21 +128,18 @@ function createAuthStore() {
 
     // Refresh Session
     refreshSession: async (): Promise<void> => {
-        // Need to get current state to access refresh token, logic simplified
+        const currentRefreshToken = _state.refreshToken;
-        let currentRefreshToken: string | null = null;
-        if (typeof window !== 'undefined') {
-            currentRefreshToken = localStorage.getItem('internal_auth_refresh_token');
-        }
 
         if (!currentRefreshToken) {
             throw new Error("No refresh token available");
         }
 
-        update (state => ({ ...state, isLoading: true }));
+        update(state => ({ ...state, isLoading: true }));
 
         try {
             const response = await fetch('/api/v1/auth/refresh', {
                 method: 'POST',
+                credentials: 'include',
                 headers: {
                     'Content-Type': 'application/json',
                 },
@@ -166,11 +157,6 @@ function createAuthStore() {
 
             const data: TokenResponse = await response.json();
 
-            // Update token in storage and state
-            if (typeof window !== 'undefined') {
-                localStorage.setItem('internal_auth_token', data.access_token);
-            }
-
             update(state => ({
                 ...state,
                 token: data.access_token,
@@ -184,25 +170,29 @@ function createAuthStore() {
     },
 
     // Logout
-    logout: () => {
+    logout: async () => {
-      if (typeof window !== 'undefined') {
+      // Llamar al backend para que borre la cookie HttpOnly
-        localStorage.removeItem('internal_auth_token');
+      try {
-        localStorage.removeItem('internal_auth_refresh_token');
+        await fetch('/api/v1/auth/logout', {
-        localStorage.removeItem('internal_auth_user');
+          method: 'POST',
-      }
+          credentials: 'include',
+          headers: { 'X-App': 'internal' }
+        });
+      } catch { /* ignorar errores de red */ }
       set(initialState);
-      // Optional: Redirect to login
       if (typeof window !== 'undefined') {
-          window.location.href = '/login';
+        window.location.href = '/login';
       }
     },
 
     // Update user data
     updateUser: (user: InternalUser) => {
       update(state => ({ ...state, user }));
-      if (typeof window !== 'undefined') {
+    },
-        localStorage.setItem('internal_auth_user', JSON.stringify(user));
+
-      }
+    // Set user from SSR pre-load (no fetch required)
+    setUser: (user: InternalUser) => {
+      set({ user, token: null, refreshToken: null, isAuthenticated: true, isLoading: false });
     },
 
     // Set loading state

frontend-internal/src/lib/utils/api.ts

@@ -24,16 +24,8 @@ async function request<T>(endpoint: string, options: RequestOptions = {}): Promi
   }
 
   const authState = get(auth);
-  const token = authState.token || (typeof window !== 'undefined' ? localStorage.getItem('internal_auth_token') : null);
+  const token = authState.token;
-
+  const tenantId = authState.user?.tenant_id ?? null;
-  // Resolve tenant_id from store or from the persisted user object in localStorage
-  let tenantId = authState.user?.tenant_id ?? null;
-  if (!tenantId && typeof window !== 'undefined') {
-    try {
-      const stored = localStorage.getItem('internal_auth_user');
-      if (stored) tenantId = JSON.parse(stored)?.tenant_id ?? null;
-    } catch { /* ignore */ }
-  }
 
   const headers = new Headers(init.headers);
   if (token) {
@@ -45,17 +37,18 @@ async function request<T>(endpoint: string, options: RequestOptions = {}): Promi
   if (!headers.has('Content-Type')) {
     headers.set('Content-Type', 'application/json');
   }
+  // Identifica este frontend para que el backend use la cookie correcta
+  headers.set('X-App', 'internal');
 
   const response = await fetch(url, {
     ...init,
+    credentials: 'include',
     headers
   });
 
   if (response.status === 401) {
     // Token expired or invalid
     if (typeof window !== 'undefined') {
-      localStorage.removeItem('internal_auth_token');
-      localStorage.removeItem('internal_auth_user');
       window.location.href = '/login';
     }
     throw new Error('Unauthorized');
@@ -76,15 +69,8 @@ async function request<T>(endpoint: string, options: RequestOptions = {}): Promi
 
 async function downloadFile(endpoint: string, filename: string): Promise<void> {
   const authState = get(auth);
-  const token = authState.token || (typeof window !== 'undefined' ? localStorage.getItem('internal_auth_token') : null);
+  const token = authState.token;
-
+  const tenantId = authState.user?.tenant_id ?? null;
-  let tenantId = authState.user?.tenant_id ?? null;
-  if (!tenantId && typeof window !== 'undefined') {
-    try {
-      const stored = localStorage.getItem('internal_auth_user');
-      if (stored) tenantId = JSON.parse(stored)?.tenant_id ?? null;
-    } catch { /* ignore */ }
-  }
 
   const headers = new Headers();
   if (token) {
@@ -93,16 +79,16 @@ async function downloadFile(endpoint: string, filename: string): Promise<void> {
   if (tenantId) {
     headers.set('X-Tenant-ID', tenantId);
   }
+  headers.set('X-App', 'internal');
 
   const response = await fetch(`${API_BASE}${endpoint}`, {
     method: 'GET',
+    credentials: 'include',
     headers
   });
 
   if (response.status === 401) {
     if (typeof window !== 'undefined') {
-      localStorage.removeItem('internal_auth_token');
-      localStorage.removeItem('internal_auth_user');
       window.location.href = '/login';
     }
     throw new Error('Unauthorized');

frontend-internal/src/routes/+layout.server.ts

@@ -0,0 +1,7 @@
+import type { LayoutServerLoad } from './$types';
+
+export const load: LayoutServerLoad = ({ locals }) => {
+	return {
+		user: locals.user ?? null
+	};
+};

frontend-internal/src/routes/+layout.svelte

@@ -10,11 +10,15 @@
   import { browser } from '$app/environment';
   import '../app.css';
 
+  export let data;
+
   let sidebarOpen = false;
   let mounted = false;
 
   onMount(() => {
-    auth.init();
+    if (data.user && !$auth.isAuthenticated) {
+      auth.setUser(data.user);
+    }
     mounted = true;
   });
 
@@ -29,7 +33,12 @@
 </script>
 
 <div class="min-h-screen bg-gray-50">
-  {#if $auth.isAuthenticated}
+  {#if !mounted}
+    <!-- Esperando inicialización de sesión -->
+    <div class="flex items-center justify-center min-h-screen bg-gray-50">
+      <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600"></div>
+    </div>
+  {:else if $auth.isAuthenticated}
     <!-- Internal Layout with Sidebar -->
     <div class="flex h-screen overflow-hidden">
       <!-- Sidebar -->

frontend-internal/src/routes/test-report/+page.svelte

@@ -1,492 +0,0 @@
-<script lang="ts">
-  import { onMount } from 'svelte';
-  import { auth } from '$lib/stores/auth.js';
-  import { goto } from '$app/navigation';
-
-  onMount(() => {
-    if (!$auth.isAuthenticated) goto('/login');
-  });
-
-  // ─── Types ──────────────────────────────────────────────────────────────────
-  interface EndpointDef {
-    id: string;
-    label: string;
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-    path: string;
-    description: string;
-  }
-
-  interface EndpointResult {
-    status: number | null;
-    ok: boolean | null;
-    ms: number | null;
-    error: string | null;
-    preview: string | null;
-    tested: boolean;
-    loading: boolean;
-  }
-
-  interface PageDef {
-    label: string;
-    href: string;
-    description: string;
-    roles: string[];
-  }
-
-  // ─── Backend Endpoints ───────────────────────────────────────────────────────
-  const GROUPS: { name: string; color: string; endpoints: EndpointDef[] }[] = [
-    {
-      name: 'Auth',
-      color: 'bg-purple-100 text-purple-800',
-      endpoints: [
-        { id: 'auth-me',          label: 'Perfil actual',          method: 'GET',  path: '/auth/me',                description: 'Información del usuario autenticado' },
-        { id: 'auth-refresh',     label: 'Refrescar token',        method: 'POST', path: '/auth/refresh',           description: 'Renovar access token (POST)' },
-      ]
-    },
-    {
-      name: 'Health',
-      color: 'bg-green-100 text-green-800',
-      endpoints: [
-        { id: 'health',          label: 'Health Check',           method: 'GET',  path: '/health',                 description: 'Estado general del sistema' },
-        { id: 'health-details',  label: 'Health Detallado',       method: 'GET',  path: '/health/detailed',        description: 'Estado con detalle de dependencias' },
-      ]
-    },
-    {
-      name: 'Tenants',
-      color: 'bg-blue-100 text-blue-800',
-      endpoints: [
-        { id: 'tenants-list',    label: 'Listar Tenants',         method: 'GET',  path: '/tenants/',               description: 'Todos los tenants registrados' },
-        { id: 'tenant-stats',    label: 'Stats Tenant',           method: 'GET',  path: '/tenants/stats',          description: 'Estadísticas globales de tenants' },
-      ]
-    },
-    {
-      name: 'Users',
-      color: 'bg-indigo-100 text-indigo-800',
-      endpoints: [
-        { id: 'users-list',      label: 'Listar Usuarios',        method: 'GET',  path: '/users/',                 description: 'Todos los usuarios del sistema' },
-      ]
-    },
-    {
-      name: 'Tickets',
-      color: 'bg-orange-100 text-orange-800',
-      endpoints: [
-        { id: 'tickets-list',    label: 'Listar Tickets',         method: 'GET',  path: '/tickets/',               description: 'Tickets con paginación' },
-        { id: 'tickets-stats',   label: 'Stats Tickets',          method: 'GET',  path: '/tickets/stats',          description: 'Estadísticas de tickets' },
-        { id: 'tickets-comments',label: 'Comentarios recientes',  method: 'GET',  path: '/tickets/comments/recent',description: 'Últimos comentarios' },
-      ]
-    },
-    {
-      name: 'Categories',
-      color: 'bg-amber-100 text-amber-800',
-      endpoints: [
-        { id: 'cats-list',       label: 'Listar Categorías',      method: 'GET',  path: '/categories/',            description: 'Categorías de tickets' },
-      ]
-    },
-    {
-      name: 'Systems',
-      color: 'bg-gray-100 text-gray-800',
-      endpoints: [
-        { id: 'sys-list',        label: 'Listar Sistemas',        method: 'GET',  path: '/systems/',               description: 'Sistemas soportados' },
-      ]
-    },
-    {
-      name: 'SLA',
-      color: 'bg-teal-100 text-teal-800',
-      endpoints: [
-        { id: 'sla-dashboard',   label: 'Dashboard SLA',          method: 'GET',  path: '/sla/dashboard',          description: 'Panel SLA principal' },
-        { id: 'sla-compliance',  label: 'SLA Compliance',         method: 'GET',  path: '/sla/compliance',         description: 'Métricas de cumplimiento SLA' },
-        { id: 'sla-at-risk',     label: 'Tickets en Riesgo',      method: 'GET',  path: '/sla/at-risk',            description: 'Tickets próximos a violar SLA' },
-        { id: 'sla-violations',  label: 'Violaciones SLA',        method: 'GET',  path: '/sla/violations',         description: 'Tickets que violaron SLA' },
-      ]
-    },
-    {
-      name: 'Reports',
-      color: 'bg-pink-100 text-pink-800',
-      endpoints: [
-        { id: 'rep-summary',     label: 'Resumen General',        method: 'GET',  path: '/reports/summary',        description: 'Resumen ejecutivo de reportes' },
-        { id: 'rep-agents',      label: 'Por Agente',             method: 'GET',  path: '/reports/agents',         description: 'Rendimiento por agente' },
-        { id: 'rep-categories',  label: 'Por Categoría',          method: 'GET',  path: '/reports/categories',     description: 'Distribución por categoría' },
-        { id: 'rep-trends',      label: 'Tendencias',             method: 'GET',  path: '/reports/trends',         description: 'Tendencias temporales' },
-      ]
-    },
-    {
-      name: 'Audit',
-      color: 'bg-red-100 text-red-800',
-      endpoints: [
-        { id: 'audit-logs',      label: 'Logs de Auditoría',      method: 'GET',  path: '/audit/logs',             description: 'Bitácora de acciones' },
-        { id: 'audit-stats',     label: 'Stats Auditoría',        method: 'GET',  path: '/audit/stats',            description: 'Estadísticas de auditoría' },
-        { id: 'audit-security',  label: 'Análisis Seguridad',     method: 'GET',  path: '/audit/security/analysis',description: 'Análisis de amenazas de seguridad' },
-        { id: 'audit-users',     label: 'Actividad Usuarios',     method: 'GET',  path: '/audit/users',            description: 'Actividad por usuario' },
-      ]
-    },
-    {
-      name: 'Client Profile',
-      color: 'bg-cyan-100 text-cyan-800',
-      endpoints: [
-        { id: 'client-profile',  label: 'Perfil Cliente',         method: 'GET',  path: '/client/profile',         description: 'Perfil organización cliente' },
-        { id: 'client-tickets',  label: 'Tickets Cliente',        method: 'GET',  path: '/client/tickets',         description: 'Tickets del cliente' },
-      ]
-    },
-  ];
-
-  // ─── Frontend Pages ──────────────────────────────────────────────────────────
-  const FRONTEND_PAGES: PageDef[] = [
-    { label: 'Dashboard',          href: '/',               description: 'Panel principal de administración',           roles: ['todos'] },
-    { label: 'Tickets',            href: '/tickets',        description: 'Gestión y listado de tickets',                roles: ['ADMIN', 'SUPPORT_MANAGER', 'AGENT'] },
-    { label: 'Clientes (Tenants)', href: '/tenants',        description: 'Administración de organizaciones cliente',     roles: ['ADMIN', 'SUPPORT_MANAGER'] },
-    { label: 'Usuarios',           href: '/users',          description: 'Gestión de usuarios internos',               roles: ['ADMIN', 'SUPPORT_MANAGER'] },
-    { label: 'Categorías',         href: '/categories',     description: 'Categorías y SLA por área',                  roles: ['ADMIN', 'SUPPORT_MANAGER'] },
-    { label: 'Sistemas',           href: '/systems',        description: 'Catálogo de sistemas soportados',            roles: ['ADMIN', 'SUPPORT_MANAGER'] },
-    { label: 'SLA Dashboard',      href: '/sla',            description: 'Monitoreo de SLAs y cumplimiento',           roles: ['ADMIN', 'SUPPORT_MANAGER'] },
-    { label: 'SLA En Riesgo',      href: '/sla/at-risk',   description: 'Tickets próximos a violar SLA',              roles: ['ADMIN', 'SUPPORT_MANAGER'] },
-    { label: 'SLA Violaciones',    href: '/sla/violations', description: 'Historial de violaciones SLA',               roles: ['ADMIN', 'SUPPORT_MANAGER'] },
-    { label: 'Reportes',           href: '/reports',        description: 'Reportes estadísticos e informes',           roles: ['ADMIN', 'SUPPORT_MANAGER'] },
-    { label: 'Auditoría',          href: '/audit',          description: 'Bitácora de acciones del sistema',           roles: ['ADMIN', 'AUDITOR'] },
-    { label: 'Seguridad',          href: '/audit/security', description: 'Análisis de amenazas y eventos de seguridad',roles: ['ADMIN'] },
-    { label: 'Perfil',             href: '/profile',        description: 'Perfil y configuración de seguridad',        roles: ['todos'] },
-    { label: 'Rate Limits',        href: '/rate-limits',    description: 'Estado de rate limiting por IP',             roles: ['ADMIN'] },
-    { label: 'Reporte Endpoints',  href: '/test-report',   description: 'Esta misma página',                          roles: ['ADMIN'] },
-  ];
-
-  // ─── State ───────────────────────────────────────────────────────────────────
-  let results: Record<string, EndpointResult> = {};
-  let isTesting = false;
-  let testingId: string | null = null;
-  let totalOk = 0;
-  let totalFail = 0;
-  let activeTab: 'endpoints' | 'pages' = 'endpoints';
-
-  // Init results
-  for (const group of GROUPS) {
-    for (const ep of group.endpoints) {
-      results[ep.id] = { status: null, ok: null, ms: null, error: null, preview: null, tested: false, loading: false };
-    }
-  }
-
-  function getToken(): string | null {
-    return (typeof window !== 'undefined')
-      ? localStorage.getItem('internal_auth_token')
-      : null;
-  }
-
-  function getTenantId(): string | null {
-    if (typeof window === 'undefined') return null;
-    try {
-      const stored = localStorage.getItem('internal_auth_user');
-      if (stored) return JSON.parse(stored)?.tenant_id ?? null;
-    } catch { /* ignore */ }
-    return null;
-  }
-
-  async function testEndpoint(ep: EndpointDef) {
-    results[ep.id] = { ...results[ep.id], loading: true, tested: false };
-    results = results; // trigger reactivity
-
-    const token = getToken();
-    const tenantId = getTenantId();
-    const headers: Record<string, string> = { 'Content-Type': 'application/json' };
-    if (token) headers['Authorization'] = `Bearer ${token}`;
-    if (tenantId) headers['X-Tenant-ID'] = tenantId;
-
-    const url = `/api/v1${ep.path}`;
-    const t0 = performance.now();
-
-    try {
-      let fetchOptions: RequestInit = { method: ep.method, headers };
-      // For non-GET we don't send a body to avoid validation errors
-      const res = await fetch(url, fetchOptions);
-      const ms = Math.round(performance.now() - t0);
-      let preview: string | null = null;
-      try {
-        const text = await res.text();
-        const obj = JSON.parse(text);
-        preview = JSON.stringify(obj, null, 2).slice(0, 500);
-        if (JSON.stringify(obj, null, 2).length > 500) preview += '\n...';
-      } catch { /* ignore */ }
-
-      results[ep.id] = { status: res.status, ok: res.ok, ms, error: null, preview, tested: true, loading: false };
-    } catch (e: any) {
-      const ms = Math.round(performance.now() - t0);
-      results[ep.id] = { status: null, ok: false, ms, error: e.message ?? 'Network error', preview: null, tested: true, loading: false };
-    }
-
-    results = results;
-    recalcCounters();
-  }
-
-  async function testAll() {
-    isTesting = true;
-    totalOk = 0;
-    totalFail = 0;
-    for (const group of GROUPS) {
-      for (const ep of group.endpoints) {
-        testingId = ep.id;
-        await testEndpoint(ep);
-      }
-    }
-    testingId = null;
-    isTesting = false;
-  }
-
-  function recalcCounters() {
-    totalOk = Object.values(results).filter(r => r.tested && r.ok).length;
-    totalFail = Object.values(results).filter(r => r.tested && !r.ok).length;
-  }
-
-  function statusBadge(r: EndpointResult): { text: string; cls: string } {
-    if (r.loading) return { text: 'Probando...', cls: 'bg-gray-100 text-gray-600 animate-pulse' };
-    if (!r.tested) return { text: 'Sin probar', cls: 'bg-gray-100 text-gray-400' };
-    if (r.ok) return { text: `${r.status} OK`, cls: 'bg-green-100 text-green-700' };
-    return { text: r.status ? `${r.status} Error` : 'Fallo red', cls: 'bg-red-100 text-red-700' };
-  }
-
-  function methodBadge(method: string): string {
-    const map: Record<string, string> = {
-      GET:    'bg-blue-100 text-blue-700',
-      POST:   'bg-green-100 text-green-700',
-      PUT:    'bg-yellow-100 text-yellow-700',
-      DELETE: 'bg-red-100 text-red-700',
-      PATCH:  'bg-purple-100 text-purple-700',
-    };
-    return map[method] ?? 'bg-gray-100 text-gray-700';
-  }
-
-  let expandedIds = new Set<string>();
-  function toggleExpand(id: string) {
-    if (expandedIds.has(id)) expandedIds.delete(id);
-    else expandedIds.add(id);
-    expandedIds = new Set(expandedIds);
-  }
-
-  const testedCount = () => Object.values(results).filter(r => r.tested).length;
-  const totalEndpoints = GROUPS.reduce((acc, g) => acc + g.endpoints.length, 0);
-</script>
-
-<svelte:head>
-  <title>Reporte de Endpoints - ServiceManager</title>
-</svelte:head>
-
-<div class="px-4 py-8 mx-auto max-w-7xl sm:px-6 lg:px-8">
-  <!-- Header -->
-  <div class="md:flex md:items-center md:justify-between mb-6">
-    <div>
-      <h2 class="text-2xl font-bold text-gray-900">Reporte de Endpoints & Páginas</h2>
-      <p class="mt-1 text-sm text-gray-500">
-        Diagnóstico de conectividad de todos los endpoints del backend y páginas del frontend.
-      </p>
-    </div>
-    <div class="mt-4 flex gap-2 md:mt-0">
-      <button
-        on:click={testAll}
-        disabled={isTesting}
-        class="inline-flex items-center gap-2 px-4 py-2 bg-blue-600 text-white text-sm font-medium rounded-md hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed shadow-sm"
-      >
-        {#if isTesting}
-          <svg class="animate-spin h-4 w-4" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
-            <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4" />
-            <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z" />
-          </svg>
-          Probando endpoints...
-        {:else}
-          <svg class="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 10V3L4 14h7v7l9-11h-7z" />
-          </svg>
-          Probar Todo
-        {/if}
-      </button>
-    </div>
-  </div>
-
-  <!-- Summary Bar -->
-  {#if testedCount() > 0}
-    <div class="mb-6 grid grid-cols-3 gap-4">
-      <div class="bg-white rounded-lg border p-4 text-center">
-        <div class="text-2xl font-bold text-gray-800">{testedCount()}/{totalEndpoints}</div>
-        <div class="text-xs text-gray-500 mt-1">Endpoints probados</div>
-      </div>
-      <div class="bg-green-50 rounded-lg border border-green-200 p-4 text-center">
-        <div class="text-2xl font-bold text-green-700">{totalOk}</div>
-        <div class="text-xs text-green-600 mt-1">OK / Exitosos</div>
-      </div>
-      <div class="bg-red-50 rounded-lg border border-red-200 p-4 text-center">
-        <div class="text-2xl font-bold text-red-700">{totalFail}</div>
-        <div class="text-xs text-red-600 mt-1">Errores / Fallidos</div>
-      </div>
-    </div>
-  {/if}
-
-  <!-- Tabs -->
-  <div class="flex border-b border-gray-200 mb-6">
-    <button
-      on:click={() => activeTab = 'endpoints'}
-      class="px-4 py-2 text-sm font-medium border-b-2 -mb-px transition-colors {activeTab === 'endpoints' ? 'border-blue-600 text-blue-600' : 'border-transparent text-gray-500 hover:text-gray-700'}"
-    >
-      Endpoints Backend ({totalEndpoints})
-    </button>
-    <button
-      on:click={() => activeTab = 'pages'}
-      class="px-4 py-2 text-sm font-medium border-b-2 -mb-px transition-colors {activeTab === 'pages' ? 'border-blue-600 text-blue-600' : 'border-transparent text-gray-500 hover:text-gray-700'}"
-    >
-      Páginas Frontend ({FRONTEND_PAGES.length})
-    </button>
-  </div>
-
-  <!-- ─── Endpoints Tab ─────────────────────────────────────────────────────── -->
-  {#if activeTab === 'endpoints'}
-    <div class="space-y-6">
-      {#each GROUPS as group}
-        <div class="bg-white rounded-lg shadow-sm border border-gray-200 overflow-hidden">
-          <!-- Group header -->
-          <div class="flex items-center justify-between px-5 py-3 bg-gray-50 border-b border-gray-200">
-            <div class="flex items-center gap-2">
-              <span class="text-xs font-semibold uppercase tracking-wider px-2 py-0.5 rounded-full {group.color}">
-                {group.name}
-              </span>
-              <span class="text-xs text-gray-400">{group.endpoints.length} endpoint{group.endpoints.length !== 1 ? 's' : ''}</span>
-            </div>
-            <div class="flex gap-1 items-center">
-              {#each group.endpoints as ep}
-                {#if results[ep.id].tested}
-                  <span class="w-2 h-2 rounded-full {results[ep.id].ok ? 'bg-green-400' : 'bg-red-400'}" title={ep.label}></span>
-                {/if}
-              {/each}
-            </div>
-          </div>
-
-          <!-- Endpoints list -->
-          <div class="divide-y divide-gray-100">
-            {#each group.endpoints as ep}
-              {@const r = results[ep.id]}
-              {@const badge = statusBadge(r)}
-              <div class="px-5 py-3">
-                <div class="flex items-center gap-3 flex-wrap">
-                  <!-- Method badge -->
-                  <span class="text-xs font-bold px-2 py-0.5 rounded font-mono {methodBadge(ep.method)}">
-                    {ep.method}
-                  </span>
-                  <!-- Path -->
-                  <code class="text-xs text-gray-700 bg-gray-50 px-2 py-0.5 rounded border border-gray-200 font-mono flex-shrink-0">
-                    /api/v1{ep.path}
-                  </code>
-                  <!-- Label -->
-                  <span class="text-sm text-gray-700 flex-1 min-w-0 truncate">{ep.label}</span>
-
-                  <!-- Status + timing -->
-                  <div class="flex items-center gap-2 ml-auto flex-shrink-0">
-                    {#if r.ms !== null && r.tested}
-                      <span class="text-xs text-gray-400">{r.ms}ms</span>
-                    {/if}
-                    <span class="text-xs font-medium px-2 py-0.5 rounded-full {badge.cls}">{badge.text}</span>
-                    <!-- Test individual -->
-                    <button
-                      on:click={() => testEndpoint(ep)}
-                      disabled={r.loading || isTesting}
-                      class="ml-1 text-xs px-2 py-1 rounded border border-gray-200 hover:border-blue-300 hover:text-blue-600 text-gray-500 disabled:opacity-40 disabled:cursor-not-allowed transition-colors"
-                    >
-                      {r.loading ? '...' : 'Probar'}
-                    </button>
-                    <!-- Expand preview -->
-                    {#if r.tested && r.preview}
-                      <button
-                        on:click={() => toggleExpand(ep.id)}
-                        class="text-xs px-2 py-1 rounded border border-gray-200 hover:border-blue-300 hover:text-blue-600 text-gray-500 transition-colors"
-                      >
-                        {expandedIds.has(ep.id) ? 'Ocultar' : 'Ver respuesta'}
-                      </button>
-                    {/if}
-                  </div>
-                </div>
-
-                <!-- Description -->
-                <p class="mt-0.5 text-xs text-gray-400 ml-0.5">{ep.description}</p>
-
-                <!-- Error message -->
-                {#if r.tested && r.error}
-                  <div class="mt-2 text-xs text-red-600 bg-red-50 rounded px-2 py-1.5 font-mono">{r.error}</div>
-                {/if}
-
-                <!-- Response preview -->
-                {#if expandedIds.has(ep.id) && r.preview}
-                  <pre class="mt-2 text-xs text-gray-700 bg-gray-50 border border-gray-200 rounded p-3 overflow-x-auto whitespace-pre-wrap break-words max-h-48">{r.preview}</pre>
-                {/if}
-              </div>
-            {/each}
-          </div>
-        </div>
-      {/each}
-    </div>
-  {/if}
-
-  <!-- ─── Frontend Pages Tab ─────────────────────────────────────────────────── -->
-  {#if activeTab === 'pages'}
-    <div class="bg-white rounded-lg shadow-sm border border-gray-200 overflow-hidden">
-      <table class="min-w-full divide-y divide-gray-200">
-        <thead class="bg-gray-50">
-          <tr>
-            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Página</th>
-            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Ruta</th>
-            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Descripción</th>
-            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Roles</th>
-            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">Acción</th>
-          </tr>
-        </thead>
-        <tbody class="bg-white divide-y divide-gray-100">
-          {#each FRONTEND_PAGES as pg}
-            <tr class="hover:bg-gray-50 transition-colors">
-              <td class="px-6 py-3">
-                <span class="text-sm font-medium text-gray-900">{pg.label}</span>
-              </td>
-              <td class="px-6 py-3">
-                <code class="text-xs bg-gray-100 text-gray-700 px-2 py-0.5 rounded font-mono">{pg.href}</code>
-              </td>
-              <td class="px-6 py-3">
-                <span class="text-xs text-gray-500">{pg.description}</span>
-              </td>
-              <td class="px-6 py-3">
-                <div class="flex flex-wrap gap-1">
-                  {#each pg.roles as role}
-                    <span class="text-xs px-1.5 py-0.5 rounded-full bg-blue-50 text-blue-600 font-medium">{role}</span>
-                  {/each}
-                </div>
-              </td>
-              <td class="px-6 py-3">
-                <a
-                  href={pg.href}
-                  target="_blank"
-                  rel="noopener noreferrer"
-                  class="text-xs text-blue-600 hover:text-blue-800 underline font-medium"
-                >
-                  Abrir ↗
-                </a>
-              </td>
-            </tr>
-          {/each}
-        </tbody>
-      </table>
-
-      <!-- Notes -->
-      <div class="px-6 py-4 bg-gray-50 border-t border-gray-200">
-        <p class="text-xs text-gray-500">
-          <strong>Nota:</strong> Las páginas se abren en una nueva pestaña para verificar su renderizado.
-          Asegúrate de estar autenticado antes de acceder a rutas protegidas.
-        </p>
-        <div class="mt-3 grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-2">
-          {#each FRONTEND_PAGES as pg}
-            <a
-              href={pg.href}
-              target="_blank"
-              rel="noopener noreferrer"
-              class="flex items-center gap-2 px-3 py-2 rounded-lg border border-gray-200 hover:border-blue-300 hover:bg-blue-50 text-xs text-gray-700 hover:text-blue-700 transition-all group"
-            >
-              <svg class="w-3.5 h-3.5 text-gray-400 group-hover:text-blue-500 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 6H6a2 2 0 00-2 2v10a2 2 0 002 2h10a2 2 0 002-2v-4M14 4h6m0 0v6m0-6L10 14" />
-              </svg>
-              <span class="truncate font-medium">{pg.label}</span>
-              <code class="ml-auto text-gray-400 text-xs flex-shrink-0">{pg.href}</code>
-            </a>
-          {/each}
-        </div>
-      </div>
-    </div>
-  {/if}
-</div>

workers/app/core/database.py

@@ -7,11 +7,42 @@ Async database session management para Celery workers
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 from sqlalchemy import DateTime, func
+from sqlalchemy import types as sa_types
+from sqlalchemy.types import TypeDecorator, CHAR
+from sqlalchemy.dialects.postgresql import UUID as PG_UUID
 from contextlib import asynccontextmanager
 from typing import AsyncGenerator
 import uuid
 from datetime import datetime
 
+
+class GUID(TypeDecorator):
+    """UUID portable: UUID nativo en Postgres, CHAR(36) en otros dialectos (SQLite para tests)."""
+
+    impl = CHAR
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        if dialect.name == "postgresql":
+            return dialect.type_descriptor(PG_UUID(as_uuid=True))
+        return dialect.type_descriptor(CHAR(36))
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return None
+        if dialect.name == "postgresql":
+            return value
+        if isinstance(value, uuid.UUID):
+            return str(value)
+        return str(uuid.UUID(str(value)))
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+        if not isinstance(value, uuid.UUID):
+            return uuid.UUID(str(value))
+        return value
+
 from app.core.config import get_settings
 
 settings = get_settings()