feat(crm): formularios Clientes/Prospectos y Proveedores por catálogo — T2026-07-081/082

Frontend de los catálogos de referencia en BD:
- Store crm-catalogs + cliente API; selects poblados desde /v1/crm/catalogs
  (fiscal: régimen, uso CFDI, forma/método de pago SAT, moneda ISO; comercial;
  país/estado/tipo de domicilio/área). Muestran la descripción, no la clave.
- "Otro → especificar" (medio de contacto y clasificación), observaciones
  generales, y datos de auditoría (ID, fechas, usuarios) en la vista de edición.
- Botón "Editar" explícito en los listados.
- Pantalla de administración de catálogos (insertar/editar/borrar): globales
  solo activar/desactivar; los de la empresa con alta/edición/borrado.
- addresses.country ampliado a 3 (país ISO alfa-3) + migración con down().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

backend/alembic/versions/e6f7a8b9c0d1_crm_catalog_items.py

@@ -0,0 +1,90 @@
+"""crm catalog_items (catálogos de referencia) + columnas nuevas accounts/suppliers
+
+Revision ID: e6f7a8b9c0d1
+Revises: d5e6f7a8b9c0
+Create Date: 2026-07-22 00:00:00.000000
+
+Soporta T2026-07-081 (Clientes/Prospectos) y T2026-07-082 (Proveedores):
+catálogos de referencia SAT/ISO + propios del cliente, y campos faltantes
+(observaciones comerciales, "otro" de medio de contacto y de clasificación).
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "e6f7a8b9c0d1"
+down_revision: Union[str, None] = "d5e6f7a8b9c0"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+SCHEMA = "crm"
+
+
+def upgrade() -> None:
+    # ----- crm.catalog_items -----
+    op.create_table(
+        "catalog_items",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("catalog", sa.String(length=60), nullable=False),
+        sa.Column("code", sa.String(length=64), nullable=False),
+        sa.Column("label", sa.String(length=255), nullable=False),
+        sa.Column("parent_catalog", sa.String(length=60), nullable=True),
+        sa.Column("parent_code", sa.String(length=64), nullable=True),
+        # NULL = catálogo global (Aduanasoft); con valor = catálogo del tenant.
+        sa.Column("tenant_id", sa.Integer(), nullable=True),
+        sa.Column("sort_order", sa.Integer(), nullable=False, server_default=sa.text("0")),
+        sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+        sa.Column("is_system", sa.Boolean(), nullable=False, server_default=sa.text("false")),
+        sa.Column("extra", sa.JSON(), nullable=True),
+        sa.Column("created_by", sa.String(length=64), nullable=True),
+        sa.Column("updated_by", sa.String(length=64), nullable=True),
+        sa.Column("created_at", sa.DateTime(), nullable=False, server_default=sa.text("now()")),
+        sa.Column("updated_at", sa.DateTime(), nullable=False, server_default=sa.text("now()")),
+        sa.PrimaryKeyConstraint("id"),
+        schema=SCHEMA,
+    )
+    op.create_index("ix_crm_catalog_items_id", "catalog_items", ["id"], schema=SCHEMA)
+    op.create_index("ix_crm_catalog_items_catalog", "catalog_items", ["catalog"], schema=SCHEMA)
+    op.create_index("ix_crm_catalog_items_tenant_id", "catalog_items", ["tenant_id"], schema=SCHEMA)
+    op.create_index(
+        "ix_crm_catalog_items_lookup", "catalog_items", ["catalog", "tenant_id", "is_active"], schema=SCHEMA
+    )
+    # Unicidad de clave por catálogo: global (tenant NULL) y por tenant, separadas.
+    op.create_index(
+        "uq_crm_catalog_items_global",
+        "catalog_items",
+        ["catalog", "code"],
+        unique=True,
+        schema=SCHEMA,
+        postgresql_where=sa.text("tenant_id IS NULL"),
+    )
+    op.create_index(
+        "uq_crm_catalog_items_tenant",
+        "catalog_items",
+        ["catalog", "code", "tenant_id"],
+        unique=True,
+        schema=SCHEMA,
+        postgresql_where=sa.text("tenant_id IS NOT NULL"),
+    )
+
+    # ----- columnas nuevas -----
+    # Clientes/Prospectos: observaciones comerciales + "otro" del medio de contacto.
+    op.add_column("accounts", sa.Column("commercial_observations", sa.Text(), nullable=True), schema=SCHEMA)
+    op.add_column("accounts", sa.Column("preferred_contact_other", sa.String(length=120), nullable=True), schema=SCHEMA)
+    # Proveedores: "otro" de la clasificación múltiple.
+    op.add_column("suppliers", sa.Column("classification_other", sa.String(length=120), nullable=True), schema=SCHEMA)
+
+
+def downgrade() -> None:
+    op.drop_column("suppliers", "classification_other", schema=SCHEMA)
+    op.drop_column("accounts", "preferred_contact_other", schema=SCHEMA)
+    op.drop_column("accounts", "commercial_observations", schema=SCHEMA)
+
+    op.drop_index("uq_crm_catalog_items_tenant", table_name="catalog_items", schema=SCHEMA)
+    op.drop_index("uq_crm_catalog_items_global", table_name="catalog_items", schema=SCHEMA)
+    op.drop_index("ix_crm_catalog_items_lookup", table_name="catalog_items", schema=SCHEMA)
+    op.drop_index("ix_crm_catalog_items_tenant_id", table_name="catalog_items", schema=SCHEMA)
+    op.drop_index("ix_crm_catalog_items_catalog", table_name="catalog_items", schema=SCHEMA)
+    op.drop_index("ix_crm_catalog_items_id", table_name="catalog_items", schema=SCHEMA)
+    op.drop_table("catalog_items", schema=SCHEMA)

backend/alembic/versions/e7f8a9b0c1d2_widen_address_country.py

@@ -0,0 +1,44 @@
+"""ampliar crm.addresses.country a 3 (país ISO alfa-3 del catálogo)
+
+Revision ID: e7f8a9b0c1d2
+Revises: e6f7a8b9c0d1
+Create Date: 2026-07-22 00:30:00.000000
+
+El catálogo de País usa códigos ISO 3166 alfa-3 (MEX, USA, …). La columna
+addresses.country era String(2); se amplía a String(3) para almacenarlos.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "e7f8a9b0c1d2"
+down_revision: Union[str, None] = "e6f7a8b9c0d1"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+SCHEMA = "crm"
+
+
+def upgrade() -> None:
+    op.alter_column(
+        "addresses", "country",
+        type_=sa.String(length=3),
+        existing_type=sa.String(length=2),
+        existing_nullable=True,
+        server_default=sa.text("'MEX'"),
+        schema=SCHEMA,
+    )
+
+
+def downgrade() -> None:
+    # Trunca a 2 chars por si hay códigos alfa-3 guardados (rollback de dev).
+    op.execute("UPDATE crm.addresses SET country = left(country, 2) WHERE length(country) > 2")
+    op.alter_column(
+        "addresses", "country",
+        type_=sa.String(length=2),
+        existing_type=sa.String(length=3),
+        existing_nullable=True,
+        server_default=sa.text("'MX'"),
+        schema=SCHEMA,
+    )

backend/api/v1/modules/core/auth/dto.py

@@ -36,6 +36,12 @@ class TokenResponseDTO(BaseModel):
     tenant: Optional["TenantInfoDTO"] = None
     tenant_id: Optional[int] = None
     tenant_slug: Optional[str] = None
+    # Sesión local del CRM (patrón SIWEB) — presente solo con SESSION_STORE_ENABLED.
+    # Es un JWT propio (HS256) que la app usa como bearer para el backend del CRM y
+    # que sobrevive aunque el refresh del token KC contra el Hub falle. El access_token
+    # de arriba sigue siendo el de Keycloak (para llamadas al Hub).
+    session_token: Optional[str] = None
+    session_id: Optional[str] = None
 
     class Config:
         json_schema_extra = {
@@ -52,6 +58,12 @@ class RefreshTokenRequestDTO(BaseModel):
     """DTO para solicitud de refresh token"""
 
     refresh_token: str = Field(..., description="Refresh token")
+    # Sesión local actual del CRM (patrón SIWEB). Si se envía, el backend preserva el
+    # inicio de sesión (cap absoluto) y puede re-emitirla como fallback cuando el
+    # refresh del token KC contra el Hub falla ("Token is not active" del relay).
+    session_token: Optional[str] = Field(None, description="Sesión local actual del CRM (opcional)")
+    # session_id opaco de la sesión en valkey (guarda los tokens KC fuera del browser).
+    session_id: Optional[str] = Field(None, description="ID de sesión en valkey (opcional)")
 
 
 class UserInfoResponseDTO(BaseModel):

backend/api/v1/modules/core/auth/routes.py

@@ -24,6 +24,12 @@ from .dto import (
 )
 from .service import AuthService
 
+import logging
+from typing import Optional
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/auth", tags=["Authentication"])
 security = HTTPBearer()
 
@@ -402,10 +408,16 @@ async def dev_login():
 @router.get("/my-companies")
 async def get_my_companies(
     current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
 ):
     """
     Retorna las compañías accesibles para el usuario actual.
-    STUB: implementa con tu modelo de compañías.
+
+    Modelo del CRM: una compañía por tenant (1:1) — el ``company_id`` coincide con
+    el ``tenant_id``. Cada agente de carga (tenant) opera como una empresa. Se
+    garantiza el vínculo usuario↔tenant↔company; los permisos de la empresa se
+    resuelven en ``/permissions/me`` (bootstrap de super_admin al primer usuario).
+
     En dev-local retorna una compañía ficticia para que el dashboard funcione.
     """
     from core.config import settings
@@ -415,8 +427,239 @@ async def get_my_companies(
             "id": settings.DEV_LOCAL_AUTH_COMPANY_ID,
             "name": "Empresa Dev Local",
             "tenant_id": settings.DEV_LOCAL_AUTH_TENANT_ID,
+            "rfc": None,
+            "logo": None,
             "is_active": True,
         }]
 
-    # Implementa aquí la consulta real a tu tabla de compañías.
+    from core.security import (
+        resolve_effective_tenant_id_from_user,
+        _ensure_user_tenant_for_company,
+    )
+    from api.v1.modules.core.tenants.models import Tenant
+    from sqlalchemy import text
+
+    user_id = current_user.get("sub") or current_user.get("id")
+    tenant_id = resolve_effective_tenant_id_from_user(current_user)
+
+    # 1) Usuario CON tenant en el token (flujo normal): autocrea una compañía por
+    #    defecto en el primer acceso y AUTO-LIGA al usuario a TODAS las compañías de
+    #    su tenant. Así cualquier usuario del mismo tenant (misma organización del
+    #    Workspace) entra y ve la(s) compañía(s) sin gestión manual. El ROL no se
+    #    asigna aquí: es solo membresía; los permisos se otorgan aparte (un admin
+    #    asigna el rol; el primer usuario recibe super_admin vía /permissions/me).
+    if tenant_id:
+        tenant_id = int(tenant_id)
+        company_ids = [
+            int(r[0])
+            for r in db.execute(
+                text("SELECT id FROM a76.company WHERE tenant_id = :tid ORDER BY id"),
+                {"tid": tenant_id},
+            ).fetchall()
+        ]
+        if not company_ids:
+            tenant = db.query(Tenant).filter(Tenant.id == tenant_id).first()
+            default_name = (
+                (tenant.name if tenant else None)
+                or current_user.get("tenant_slug")
+                or "Mi empresa"
+            )
+            created = db.execute(
+                text("INSERT INTO a76.company (tenant_id, name) VALUES (:tid, :name) RETURNING id"),
+                {"tid": tenant_id, "name": default_name},
+            ).fetchone()
+            db.execute(text("SELECT setval('a76.company_id_seq', (SELECT MAX(id) FROM a76.company))"))
+            db.commit()
+            company_ids = [int(created[0])]
+            logger.info("Compañía por defecto creada para tenant=%s: id=%s", tenant_id, created[0])
+
+        # Auto-ligado por tenant (solo membresía, sin rol).
+        if user_id:
+            for cid in company_ids:
+                try:
+                    _ensure_user_tenant_for_company(db, str(user_id), tenant_id, cid)
+                except Exception as exc:
+                    logger.warning("auto-ligado de compañía %s falló (no bloquea): %s", cid, exc)
+
+    # 2) Compañías por MEMBRESÍA (user_tenants ∪ user_company_roles) → funciona
+    #    también para hub_admin sin tenant en el token: verá las compañías que creó
+    #    o a las que fue asignado. La membresía la determina el CRM, no el Hub.
+    if not user_id:
+        return []
+    rows = db.execute(
+        text(
+            """
+            SELECT c.id, c.name, c.rfc, c.logo, c.tenant_id, t.name, t.slug
+            FROM a76.company c
+            LEFT JOIN core.tenants t ON t.id = c.tenant_id
+            WHERE c.id IN (
+                SELECT company_id FROM core.user_tenants
+                    WHERE keycloak_user_id = :uid AND is_active AND company_id IS NOT NULL
+                UNION
+                SELECT company_id FROM core.user_company_roles
+                    WHERE user_id = :uid AND is_active
+            )
+            ORDER BY c.id
+            """
+        ),
+        {"uid": str(user_id)},
+    ).fetchall()
+
+    return [
+        {
+            "id": int(r[0]),
+            "name": r[1] or "Empresa",
+            "tenant_id": int(r[4]),
+            "tenant_name": r[5],
+            "tenant_slug": r[6],
+            "rfc": r[2],
+            "logo": r[3],
+            "is_active": True,
+        }
+        for r in rows
+    ]
+
+
+class _CreateCompanyDTO(BaseModel):
+    name: str
+    tenant_id: int
+    rfc: Optional[str] = None
+
+
+async def _sync_tenants_from_hub(request: Request, db: Session) -> None:
+    """
+    Auto-sync Workspace→CRM: trae los tenants del Workspace (Hub GET /hub/tenants) y
+    los da de alta/actualiza en core.tenants con su MISMO ID del Workspace. Así los
+    tenants creados en el Workspace aparecen solos en el CRM para asignarles compañías.
+    Best-effort: usa el token KC de la sesión (valkey); si no está fresco o el Hub no
+    responde, no bloquea (se devuelven los tenants ya sincronizados).
+    """
+    import httpx
+    from sqlalchemy import text as _text
+    from core.config import settings
+    from core import session_store
+    from api.v1.modules.core.tenants.models import Tenant, TenantType
+
+    sid = request.cookies.get("crm_sid") if request else None
+    kc_token = None
+    if sid:
+        sess = session_store.get_session(sid)
+        kc_token = (sess or {}).get("access_token")
+    if not kc_token:
+        return
+
+    try:
+        async with httpx.AsyncClient(timeout=8.0) as client:
+            r = await client.get(
+                f"{settings.HUB_URL}api/v1/hub/tenants",
+                headers={"Authorization": f"Bearer {kc_token}"},
+            )
+        if r.status_code != 200:
+            logger.info("sync-tenants: Hub devolvió %s — sin sincronizar", r.status_code)
+            return
+        payload = r.json()
+        items = payload.get("tenants", []) if isinstance(payload, dict) else (payload or [])
+        for t in items:
+            tid = t.get("id")
+            if tid is None:
+                continue
+            name = t.get("name") or t.get("display_name") or t.get("slug")
+            slug = t.get("slug") or f"tenant-{tid}"
+            existing = db.query(Tenant).filter(Tenant.id == int(tid)).first()
+            if existing:
+                if name and existing.name != name:
+                    existing.name = name
+            else:
+                db.add(Tenant(
+                    id=int(tid), name=name or slug, slug=slug,
+                    keycloak_realm=slug, type=TenantType.SHARED, is_active=True,
+                ))
+        db.commit()
+        db.execute(_text("SELECT setval('core.tenants_id_seq', (SELECT MAX(id) FROM core.tenants))"))
+        db.commit()
+    except Exception as exc:
+        logger.warning("sync-tenants desde Hub falló (no bloquea): %s", exc)
+        try:
+            db.rollback()
+        except Exception:
+            pass
+
+
+@router.get("/assignable-tenants")
+async def assignable_tenants(
+    request: Request,
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """
+    Tenants disponibles para asignar una compañía. El tenant lo crea el Workspace;
+    aquí solo se elige. hub_admin ve TODOS (auto-sincronizados del Hub); un usuario
+    con tenant ve el suyo.
+    """
+    from api.v1.modules.core.tenants.models import Tenant
+    from core.security import resolve_effective_tenant_id_from_user, is_hub_admin
+
+    if is_hub_admin(current_user):
+        # Sincroniza automáticamente los tenants del Workspace antes de listar.
+        await _sync_tenants_from_hub(request, db)
+        rows = db.query(Tenant).filter(Tenant.is_active == True).order_by(Tenant.id).all()  # noqa: E712
+        return [{"id": t.id, "name": t.name, "slug": t.slug} for t in rows]
+
+    tid = resolve_effective_tenant_id_from_user(current_user)
+    if tid:
+        t = db.query(Tenant).filter(Tenant.id == int(tid), Tenant.is_active == True).first()  # noqa: E712
+        return [{"id": t.id, "name": t.name, "slug": t.slug}] if t else []
     return []
+
+
+@router.post("/companies", status_code=201)
+async def create_company(
+    data: _CreateCompanyDTO,
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """
+    Da de alta una compañía (a76.company) bajo un tenant del Workspace y asigna al
+    usuario como miembro. hub_admin puede crear en cualquier tenant; un usuario con
+    tenant solo en el suyo. El rol super_admin se otorga al seleccionarla (/permissions/me).
+    """
+    from sqlalchemy import text as _text
+    from api.v1.modules.core.tenants.models import Tenant
+    from core.security import (
+        resolve_effective_tenant_id_from_user,
+        is_hub_admin,
+        _ensure_user_tenant_for_company,
+    )
+
+    name = (data.name or "").strip()
+    if len(name) < 2:
+        raise HTTPException(status_code=422, detail="El nombre de la compañía es obligatorio.")
+
+    tid = int(data.tenant_id)
+    tenant = db.query(Tenant).filter(Tenant.id == tid, Tenant.is_active == True).first()  # noqa: E712
+    if not tenant:
+        raise HTTPException(status_code=404, detail="Tenant no encontrado.")
+
+    # Autorización: hub_admin (atestado por el Hub) puede crear en cualquier tenant;
+    # un usuario ligado a un tenant, solo en el suyo.
+    if not is_hub_admin(current_user):
+        own = resolve_effective_tenant_id_from_user(current_user)
+        if own is None or int(own) != tid:
+            raise HTTPException(status_code=403, detail="No puedes crear compañías en ese tenant.")
+
+    created = db.execute(
+        _text("INSERT INTO a76.company (tenant_id, name, rfc) VALUES (:t, :n, :r) RETURNING id"),
+        {"t": tid, "n": name, "r": (data.rfc or None)},
+    ).fetchone()
+    db.execute(_text("SELECT setval('a76.company_id_seq', (SELECT MAX(id) FROM a76.company))"))
+    db.commit()
+    cid = int(created[0])
+
+    user_id = current_user.get("sub") or current_user.get("id")
+    if user_id:
+        try:
+            _ensure_user_tenant_for_company(db, str(user_id), tid, cid)
+        except Exception as exc:
+            logger.warning("create_company: no se pudo asegurar membresía (no bloquea): %s", exc)
+
+    return {"id": cid, "name": name, "tenant_id": tid, "rfc": data.rfc, "logo": None, "is_active": True}

backend/api/v1/modules/core/auth/service.py

@@ -213,55 +213,160 @@ class AuthService:
             logger.error(f"Unexpected login error: {str(e)}")
             raise HTTPException(status_code=500, detail="Authentication error")
 
+    def _decode_local_session(self, session_token: Optional[str]) -> Optional[Dict[str, Any]]:
+        """
+        Decodifica una sesión local del CRM (HS256) verificando la firma pero
+        SIN exigir exp — para poder re-emitirla en el refresh. Retorna los claims
+        o None si la firma no valida o no es una sesión local del CRM.
+        """
+        if not session_token:
+            return None
+        try:
+            claims = jwt.decode(
+                session_token,
+                settings.SECRET_KEY,
+                algorithms=["HS256"],
+                options={"verify_exp": False},
+            )
+        except JWTError:
+            return None
+        if not claims.get("crm_session") or claims.get("source") != "local":
+            return None
+        return claims
+
+    def _session_claims_from_kc(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Construye los claims de la sesión local a partir del token KC (decode)."""
+        kc_claims = self._decode_kc_user_from_token(data.get("access_token", ""))
+        claims: Dict[str, Any] = dict(kc_claims)
+        # tenant_id/tenant_slug explícitos del Hub tienen precedencia sobre el token
+        if data.get("tenant_id") is not None:
+            claims["tenant_id"] = data.get("tenant_id")
+        if data.get("tenant_slug") is not None:
+            claims["tenant_slug"] = data.get("tenant_slug")
+        return claims
+
+    async def _session_claims(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Claims AUTORITATIVOS para la sesión local: se prefiere /auth/me del Hub (trae
+        is_hub_admin, roles, etc. que el token KC crudo no incluye). Si el Hub no
+        responde, se cae al decode del token KC. Así la sesión local sabe si el
+        usuario es hub_admin sin volver a consultar al Hub en cada request.
+        """
+        from core.security import verify_token
+
+        claims: Dict[str, Any] = {}
+        try:
+            info = await verify_token(data.get("access_token", ""))
+            if isinstance(info, dict):
+                claims = dict(info)
+        except Exception as exc:
+            logger.warning("session_claims: /auth/me no disponible, uso decode KC: %s", exc)
+
+        if not claims:
+            return self._session_claims_from_kc(data)
+
+        # tenant_id/tenant_slug explícitos del Hub tienen precedencia.
+        if data.get("tenant_id") is not None:
+            claims["tenant_id"] = data.get("tenant_id")
+        if data.get("tenant_slug") is not None:
+            claims["tenant_slug"] = data.get("tenant_slug")
+        return claims
+
     async def refresh_token(self, refresh_data: RefreshTokenRequestDTO) -> TokenResponseDTO:
         """
-        Refresca el access token usando el Hub
+        Refresca la sesión.
+
+        - Intenta el refresh del token KC contra el Hub (comportamiento histórico).
+        - Con SESSION_STORE_ENABLED, además emite/actualiza la sesión local del CRM
+          (patrón SIWEB) que la app usa como bearer y que dura por inactividad, de
+          modo que el refresh KC solo se intenta al expirar esa sesión (no cada ~60s).
+        - Si el Hub RECHAZA el refresh se devuelve 401 y la sesión termina: se
+          RESPETA la revocación central de Keycloak (sin re-emisión de fallback).
         """
+        from datetime import datetime, timezone
+
+        session_enabled = bool(getattr(settings, "SESSION_STORE_ENABLED", False))
+        prev_claims = self._decode_local_session(refresh_data.session_token) if session_enabled else None
+        prev_sst = prev_claims.get("sst") if prev_claims else None
+        prev_session_id = refresh_data.session_id if session_enabled else None
+
+        # Fuente del refresh KC: valkey (sesión) tiene precedencia sobre lo que
+        # mande el cliente (puede estar desactualizado). Fail-silent.
+        kc_refresh = refresh_data.refresh_token
+        if session_enabled and prev_session_id:
+            from core import session_store
+
+            sess = session_store.get_session(prev_session_id)
+            if sess and sess.get("refresh_token"):
+                kc_refresh = sess["refresh_token"]
+
+        # ── Intento de refresh del token KC contra el Hub ────────────────────────
+        kc_ok = False
+        data: Optional[Dict[str, Any]] = None
         try:
             async with httpx.AsyncClient(timeout=10.0) as client:
                 response = await client.post(
                     f"{settings.HUB_URL}api/v1/auth/refresh",
-                    json=refresh_data.model_dump()
+                    json={"refresh_token": kc_refresh},
                 )
-
-            if response.status_code == 200:
+            kc_ok = response.status_code == 200
+            if kc_ok:
                 data = response.json()
-                from core.workspace_profile_sync import sync_workspace_profile_for_user
-                from core.workspace_profile_client import WorkspaceProfileClient
+            else:
+                logger.warning("Hub rechazó el refresh (status %s)", response.status_code)
+        except Exception as exc:
+            logger.warning("Hub inalcanzable en refresh: %s", exc)
+            kc_ok = False
 
-                workspace_profile = None
-                try:
-                    workspace_profile = await WorkspaceProfileClient().get_me(
-                        data.get("access_token", "")
-                    )
-                except Exception as exc:
-                    logger.warning(
-                        "workspace_profile_sync_failed",
-                        extra={
-                            "event": "workspace_profile_sync_failed",
-                            "phase": "refresh",
-                            "error": str(exc),
-                        },
-                    )
-                    workspace_profile = None
+        # ── Camino feliz: el Hub renovó el token KC ──────────────────────────────
+        if kc_ok and data is not None:
+            from core.workspace_profile_sync import sync_workspace_profile_for_user
+            from core.workspace_profile_client import WorkspaceProfileClient
 
-                await sync_workspace_profile_for_user(
-                    self.db,
-                    access_token=data.get("access_token"),
-                    keycloak_user_id=(workspace_profile or {}).get("sub")
-                    or data.get("sub")
-                    or data.get("user_id"),
-                    tenant_id=data.get("tenant_id"),
-                    workspace_profile=workspace_profile,
-                    force=True,
+            workspace_profile = None
+            try:
+                workspace_profile = await WorkspaceProfileClient().get_me(data.get("access_token", ""))
+            except Exception as exc:
+                logger.warning(
+                    "workspace_profile_sync_failed",
+                    extra={"event": "workspace_profile_sync_failed", "phase": "refresh", "error": str(exc)},
                 )
-                return TokenResponseDTO(**data)
-            
-            raise HTTPException(status_code=401, detail="Invalid or expired refresh token")
+                workspace_profile = None
 
-        except Exception as e:
-            logger.error(f"Token refresh error: {str(e)}")
-            raise HTTPException(status_code=500, detail="Token refresh error")
+            await sync_workspace_profile_for_user(
+                self.db,
+                access_token=data.get("access_token"),
+                keycloak_user_id=(workspace_profile or {}).get("sub") or data.get("sub") or data.get("user_id"),
+                tenant_id=data.get("tenant_id"),
+                workspace_profile=workspace_profile,
+                force=True,
+            )
+
+            resp = TokenResponseDTO(**data)
+
+            if session_enabled:
+                from core import local_session, session_store
+
+                start = int(prev_sst) if prev_sst else int(datetime.now(timezone.utc).timestamp())
+                claims = await self._session_claims(data)
+                new_access = data.get("access_token", "")
+                new_refresh = data.get("refresh_token", "")
+                # Reutiliza la sesión de valkey si ya existía; si no, la crea.
+                if prev_session_id and session_store.get_session(prev_session_id):
+                    session_store.update_session_tokens(prev_session_id, new_access, new_refresh)
+                    resp.session_id = prev_session_id
+                else:
+                    resp.session_id = session_store.create_session(new_access, new_refresh, start)
+                resp.session_token = local_session.mint_session_token(claims, session_start=start)
+
+            return resp
+
+        # El Hub rechazó el refresh: la sesión termina y se RESPETA la revocación
+        # central de Keycloak (no hay re-emisión local de fallback). El usuario
+        # re-entra por el App Launcher. La sesión local de larga duración evita el
+        # bucle: el refresh solo se intenta al expirar la sesión local por
+        # inactividad (idle), no cada ~60s como con el token KC crudo.
+        raise HTTPException(status_code=401, detail="Invalid or expired refresh token")
 
     async def get_user_info(self, access_token: str) -> UserInfoResponseDTO:
         """

backend/api/v1/modules/core/invites/routes.py

@@ -37,13 +37,33 @@ async def create_invite(
         required_permissions=["user.create"],
     )
 
+    # tenant_slug: del token si viene; si el usuario es hub_admin (sin tenant en el
+    # token), se resuelve desde la compañía destino (a76.company → core.tenants).
     tenant_slug: str = current_user.get("tenant_slug") or ""
+    if not tenant_slug:
+        from sqlalchemy import text as _text
+        row = db.execute(
+            _text(
+                "SELECT t.slug FROM a76.company c "
+                "JOIN core.tenants t ON t.id = c.tenant_id WHERE c.id = :c"
+            ),
+            {"c": data.company_id},
+        ).first()
+        if row and row[0]:
+            tenant_slug = row[0]
+
     created_by: str = current_user.get("sub") or ""
 
+    # El invite se crea en el Hub: se necesita el token KC (la sesión local no la
+    # acepta el Hub). Se toma de la sesión (valkey) y se refresca si hace falta.
+    from core.hub_token import get_hub_access_token
+
+    kc_token = await get_hub_access_token(request)
+
     service = InviteService(db)
     return await service.create_invite(
         data=data,
         created_by=created_by,
         tenant_slug=tenant_slug,
-        user_access_token=credentials.credentials,
+        user_access_token=kc_token or credentials.credentials,
     )

backend/api/v1/modules/core/users/routes.py

@@ -53,12 +53,17 @@ async def get_user_statistics(
     """
     tenant_id = validate_access_to_resource(db, company_id, current_user, required_permissions=["user.view"])
     service = UserService(db, tenant_id, company_id, is_hub_admin=is_hub_admin(current_user))
+    from core.hub_token import get_hub_access_token
+
     auth_header = request.headers.get("Authorization") or ""
     token = (
         auth_header[7:].strip()
         if auth_header.lower().startswith("bearer ")
         else auth_header.strip()
     )
+    kc_token = await get_hub_access_token(request)
+    if kc_token:
+        token = kc_token
     hub_tid = resolve_hub_tenant_id_for_api(
         tenant_id, request.headers.get("X-Tenant-Override")
     )
@@ -84,12 +89,19 @@ async def list_users(
     """
     tenant_id = validate_access_to_resource(db, company_id, current_user, required_permissions=["user.view"])
     service = UserService(db, tenant_id, company_id, is_hub_admin=is_hub_admin(current_user))
+    # El Bearer de la app puede ser la sesión local (SIWEB), que el Hub no acepta.
+    # Para listar usuarios del tenant se usa el token KC de la sesión (valkey), refrescado.
+    from core.hub_token import get_hub_access_token
+
     auth_header = request.headers.get("Authorization") or ""
     token = (
         auth_header[7:].strip()
         if auth_header.lower().startswith("bearer ")
         else auth_header.strip()
     )
+    kc_token = await get_hub_access_token(request)
+    if kc_token:
+        token = kc_token
     hub_tid = resolve_hub_tenant_id_for_api(
         tenant_id, request.headers.get("X-Tenant-Override")
     )

backend/api/v1/modules/crm/accounts/dto.py

@@ -18,10 +18,12 @@ class AccountBase(BaseModel):
     # Comercial
     commercial_classification: str | None = Field(None, max_length=20)
     preferred_contact_method: str | None = Field(None, max_length=20)
+    preferred_contact_other: str | None = Field(None, max_length=120)
     language: str | None = Field(None, max_length=40)
     email: EmailStr | None = None
     phone: str | None = Field(None, max_length=40)
     website: str | None = Field(None, max_length=255)
+    commercial_observations: str | None = None  # observaciones generales
     # Fiscal
     tax_regime: str | None = Field(None, max_length=120)
     cfdi_use: str | None = Field(None, max_length=60)
@@ -59,10 +61,12 @@ class AccountUpdate(BaseModel):
     status: str | None = Field(None, max_length=20)
     commercial_classification: str | None = Field(None, max_length=20)
     preferred_contact_method: str | None = Field(None, max_length=20)
+    preferred_contact_other: str | None = Field(None, max_length=120)
     language: str | None = Field(None, max_length=40)
     email: EmailStr | None = None
     phone: str | None = Field(None, max_length=40)
     website: str | None = Field(None, max_length=255)
+    commercial_observations: str | None = None
     tax_regime: str | None = Field(None, max_length=120)
     cfdi_use: str | None = Field(None, max_length=60)
     payment_method: str | None = Field(None, max_length=60)

backend/api/v1/modules/crm/accounts/models.py

@@ -39,12 +39,15 @@ class Account(Base, TenantScopedMixin, TimestampMixin):
     # ----- Información comercial -----
     # Clasificación: importador | exportador | ambos
     commercial_classification: Mapped[str | None] = mapped_column(String(20), nullable=True)
-    # Medio de contacto preferido: llamada | correo | videollamada | whatsapp | otro
+    # Medio de contacto preferido: llamada | correo | videoconferencia | whatsapp | otro
     preferred_contact_method: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    # Texto libre cuando el medio de contacto es "otro"
+    preferred_contact_other: Mapped[str | None] = mapped_column(String(120), nullable=True)
     language: Mapped[str | None] = mapped_column(String(40), nullable=True)
     email: Mapped[str | None] = mapped_column(String(255), nullable=True)
     phone: Mapped[str | None] = mapped_column(String(40), nullable=True)
     website: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    commercial_observations: Mapped[str | None] = mapped_column(Text, nullable=True)  # observaciones generales
 
     # ----- Información fiscal -----
     tax_regime: Mapped[str | None] = mapped_column(String(120), nullable=True)  # régimen fiscal

backend/api/v1/modules/crm/addresses/models.py

@@ -29,7 +29,8 @@ class Address(Base, TenantScopedMixin, TimestampMixin):
     neighborhood: Mapped[str | None] = mapped_column(String(120), nullable=True)  # colonia
     postal_code: Mapped[str | None] = mapped_column(String(10), nullable=True)  # código postal
     city: Mapped[str | None] = mapped_column(String(120), nullable=True)  # municipio
-    state: Mapped[str | None] = mapped_column(String(120), nullable=True)  # estado
-    country: Mapped[str | None] = mapped_column(String(2), nullable=True, server_default=text("'MX'"))
+    state: Mapped[str | None] = mapped_column(String(120), nullable=True)  # estado (código catálogo)
+    # País como código ISO 3166 alfa-3 del catálogo (p. ej. MEX). Ampliado de 2→3.
+    country: Mapped[str | None] = mapped_column(String(3), nullable=True, server_default=text("'MEX'"))
     reference_notes: Mapped[str | None] = mapped_column(Text, nullable=True)  # referencias
     is_primary: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))

backend/api/v1/modules/crm/catalogs/dto.py

@@ -0,0 +1,45 @@
+"""Schemas (DTOs) de los catálogos de referencia del CRM."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class CatalogItemBase(BaseModel):
+    code: str = Field(..., max_length=64)
+    label: str = Field(..., max_length=255)
+    parent_catalog: str | None = Field(None, max_length=60)
+    parent_code: str | None = Field(None, max_length=64)
+    sort_order: int = 0
+    is_active: bool = True
+
+
+class CatalogItemCreate(CatalogItemBase):
+    pass
+
+
+class CatalogItemUpdate(BaseModel):
+    """PATCH: todos los campos opcionales."""
+
+    code: str | None = Field(None, max_length=64)
+    label: str | None = Field(None, max_length=255)
+    parent_code: str | None = Field(None, max_length=64)
+    sort_order: int | None = None
+    is_active: bool | None = None
+
+
+class CatalogItemResponse(CatalogItemBase):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    catalog: str
+    tenant_id: int | None
+    is_system: bool
+
+
+class CatalogMeta(BaseModel):
+    """Metadata de un catálogo para la pantalla de administración."""
+
+    catalog: str
+    label: str
+    scope: str  # 'global' | 'tenant'
+    is_system: bool
+    count: int

backend/api/v1/modules/crm/catalogs/models.py

@@ -0,0 +1,54 @@
+"""Modelo de catálogos de referencia del CRM (T2026-07-081/082).
+
+Un único modelo genérico ``CatalogItem`` respalda todos los catálogos
+(SAT/ISO y los propios del cliente). Cada fila pertenece a un catálogo
+(``catalog``) e identifica una opción por ``code`` (clave) + ``label``
+(descripción que se visualiza).
+
+Alcance:
+- ``tenant_id IS NULL`` → catálogo GLOBAL (Aduanasoft), compartido por todos.
+- ``tenant_id`` con valor → catálogo del CLIENTE (ese tenant lo administra).
+
+Los catálogos dependientes (p. ej. Estado depende de País) usan
+``parent_catalog`` + ``parent_code`` para filtrarse.
+"""
+
+from datetime import datetime
+
+from sqlalchemy import JSON, Boolean, DateTime, Integer, String, text
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.sql import func
+
+from core.database import Base
+
+
+class CatalogItem(Base):
+    __tablename__ = "catalog_items"
+    __table_args__ = {"schema": "crm"}
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+
+    catalog: Mapped[str] = mapped_column(String(60), nullable=False, index=True)
+    code: Mapped[str] = mapped_column(String(64), nullable=False)
+    label: Mapped[str] = mapped_column(String(255), nullable=False)
+
+    # Dependencia (Estado→País, Municipio→Estado, …)
+    parent_catalog: Mapped[str | None] = mapped_column(String(60), nullable=True)
+    parent_code: Mapped[str | None] = mapped_column(String(64), nullable=True)
+
+    # NULL = global (Aduanasoft); con valor = catálogo propio del tenant (cliente).
+    tenant_id: Mapped[int | None] = mapped_column(Integer, nullable=True, index=True)
+
+    sort_order: Mapped[int] = mapped_column(Integer, nullable=False, server_default=text("0"))
+    is_active: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("true"))
+    # Catálogos base SAT/ISO: no se pueden borrar (solo activar/desactivar).
+    is_system: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+
+    extra: Mapped[dict | None] = mapped_column(JSON, nullable=True)
+
+    created_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    updated_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime, nullable=False, server_default=func.now(), onupdate=func.now()
+    )

backend/api/v1/modules/crm/catalogs/routes.py

@@ -1,6 +1,10 @@
-"""Endpoints de catálogos de referencia y participantes del proceso (R-T-01, R-T-10)."""
+"""Endpoints de catálogos de referencia y participantes del proceso (R-T-01, R-T-10).
 
-from fastapi import APIRouter, Depends, Query
+Incluye el CRUD de catálogos de referencia (T2026-07-081/082): SAT/ISO globales
+(Aduanasoft) y catálogos propios de cada cliente (tenant).
+"""
+
+from fastapi import APIRouter, Depends, Query, status
 from sqlalchemy.orm import Session
 
 from core.database import get_core_db
@@ -8,7 +12,9 @@ from core.security import get_current_user
 
 from ..accounts.models import Account
 from ..suppliers.models import Supplier
+from . import service as catalog_service
 from .data import INCOTERMS, PARTICIPANT_ROLES
+from .dto import CatalogItemCreate, CatalogItemResponse, CatalogItemUpdate, CatalogMeta
 
 router = APIRouter()
 
@@ -31,6 +37,76 @@ def list_participant_roles(
     return PARTICIPANT_ROLES
 
 
+# ----------------------------------------------------------------------------
+# Catálogos de referencia (CRUD) — T2026-07-081/082
+# ----------------------------------------------------------------------------
+
+
+@router.get("/catalogs", response_model=list[CatalogMeta])
+def list_catalog_meta(
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Lista los catálogos disponibles (global + del tenant) con su conteo."""
+    return catalog_service.list_meta(db, current_user["tenant_id"])
+
+
+@router.get("/catalogs/{catalog}", response_model=list[CatalogItemResponse])
+def list_catalog_items(
+    catalog: str,
+    company_id: int = Query(..., description="Company ID"),
+    parent_code: str | None = Query(None, description="Filtra dependientes (ej. Estado por País)"),
+    include_inactive: bool = Query(False),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Opciones de un catálogo (global + del tenant), activas y ordenadas."""
+    return catalog_service.list_items(
+        db, catalog, current_user["tenant_id"], parent_code=parent_code, include_inactive=include_inactive
+    )
+
+
+@router.post(
+    "/catalogs/{catalog}", response_model=CatalogItemResponse, status_code=status.HTTP_201_CREATED
+)
+def create_catalog_item(
+    catalog: str,
+    data: CatalogItemCreate,
+    company_id: int = Query(..., description="Company ID"),
+    scope: str | None = Query("tenant", description="'tenant' (cliente) o 'global' (Aduanasoft, hub_admin)"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Inserta una opción en un catálogo."""
+    return catalog_service.create_item(db, catalog, data, current_user, scope=scope)
+
+
+@router.patch("/catalogs/{catalog}/{item_id}", response_model=CatalogItemResponse)
+def update_catalog_item(
+    catalog: str,
+    item_id: int,
+    data: CatalogItemUpdate,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Edita una opción de catálogo."""
+    return catalog_service.update_item(db, catalog, item_id, data, current_user)
+
+
+@router.delete("/catalogs/{catalog}/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_catalog_item(
+    catalog: str,
+    item_id: int,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Borra una opción de catálogo (los catálogos base del sistema no se borran)."""
+    catalog_service.delete_item(db, catalog, item_id, current_user)
+
+
 @router.get("/participants")
 def list_participants(
     company_id: int = Query(..., description="Company ID"),

backend/api/v1/modules/crm/catalogs/seed.py

@@ -0,0 +1,68 @@
+"""Siembra de catálogos globales (Aduanasoft) del CRM.
+
+Idempotente: inserta solo las claves que aún no existen (tenant_id NULL). Se
+puede correr múltiples veces sin duplicar. Para ejecutarlo en un entorno:
+
+    docker compose exec backend python -m api.v1.modules.crm.catalogs.seed
+"""
+
+import logging
+
+from sqlalchemy.orm import Session
+
+from .models import CatalogItem
+from .seed_data import GLOBAL_CATALOGS
+
+logger = logging.getLogger(__name__)
+
+
+def seed_global_catalogs(db: Session) -> dict:
+    """Inserta los catálogos globales que falten. Devuelve un resumen {catalog: nuevos}."""
+    summary: dict[str, int] = {}
+    for catalog, meta in GLOBAL_CATALOGS.items():
+        is_system = bool(meta.get("is_system", False))
+        existing = {
+            row.code
+            for row in db.query(CatalogItem.code).filter(
+                CatalogItem.catalog == catalog, CatalogItem.tenant_id.is_(None)
+            )
+        }
+        added = 0
+        for order, item in enumerate(meta["items"]):
+            if item["code"] in existing:
+                continue
+            db.add(
+                CatalogItem(
+                    catalog=catalog,
+                    code=item["code"],
+                    label=item["label"],
+                    parent_catalog=item.get("parent_catalog"),
+                    parent_code=item.get("parent_code"),
+                    tenant_id=None,
+                    sort_order=order,
+                    is_active=True,
+                    is_system=is_system,
+                )
+            )
+            added += 1
+        if added:
+            summary[catalog] = added
+    db.commit()
+    total = sum(summary.values())
+    logger.info("seed_global_catalogs: %s nuevas filas en %s catálogos", total, len(summary))
+    return summary
+
+
+def _run() -> None:
+    from core.database import CoreSessionLocal
+
+    db = CoreSessionLocal()
+    try:
+        result = seed_global_catalogs(db)
+        print("Catálogos sembrados (nuevos):", result or "0 (ya estaban todos)")
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    _run()

backend/api/v1/modules/crm/catalogs/seed_data.py

@@ -0,0 +1,561 @@
+"""Datos semilla de los catálogos de referencia del CRM (T2026-07-081/082).
+
+Generado de CATALOGOS CRM.xlsx (SAT/ISO) + catálogos estándar. Globales
+(Aduanasoft) se siembran con tenant_id NULL; los catálogos "cliente" los llena
+cada tenant desde la administración (aquí solo su metadata).
+"""
+
+GLOBAL_CATALOGS = {'tipo_registro': {'label': 'Tipo de registro',
+                   'is_system': True,
+                   'items': [{'code': 'cliente', 'label': 'Cliente'},
+                             {'code': 'prospecto', 'label': 'Prospecto'}]},
+ 'tipo_persona': {'label': 'Tipo de persona',
+                  'is_system': True,
+                  'items': [{'code': 'fisica', 'label': 'Persona física'},
+                            {'code': 'moral', 'label': 'Persona moral'}]},
+ 'estatus': {'label': 'Estatus',
+             'is_system': True,
+             'items': [{'code': 'active', 'label': 'Activo'}, {'code': 'inactive', 'label': 'Inactivo'}]},
+ 'giro': {'label': 'Giro o industria',
+          'is_system': False,
+          'items': [{'code': 'importadora', 'label': 'Importadora'},
+                    {'code': 'exportadora', 'label': 'Exportadora'},
+                    {'code': 'manufactura', 'label': 'Manufactura'},
+                    {'code': 'comercializadora', 'label': 'Comercializadora'},
+                    {'code': 'logistica', 'label': 'Logística y transporte'},
+                    {'code': 'agencia_aduanal', 'label': 'Agencia aduanal'},
+                    {'code': 'maquiladora', 'label': 'Maquiladora / IMMEX'},
+                    {'code': 'servicios', 'label': 'Servicios'},
+                    {'code': 'otro', 'label': 'Otro'}]},
+ 'clasificacion_cliente': {'label': 'Clasificación del cliente',
+                           'is_system': False,
+                           'items': [{'code': 'importador', 'label': 'Importador'},
+                                     {'code': 'exportador', 'label': 'Exportador'},
+                                     {'code': 'importador_exportador', 'label': 'Importador/Exportador'}]},
+ 'medio_contacto': {'label': 'Medio de contacto preferido',
+                    'is_system': False,
+                    'items': [{'code': 'llamada', 'label': 'Llamada telefónica'},
+                              {'code': 'correo', 'label': 'Correo electrónico'},
+                              {'code': 'videoconferencia', 'label': 'Videoconferencia'},
+                              {'code': 'whatsapp', 'label': 'WhatsApp'},
+                              {'code': 'otro', 'label': 'Otro'}]},
+ 'idioma': {'label': 'Idioma',
+            'is_system': False,
+            'items': [{'code': 'es', 'label': 'Español'},
+                      {'code': 'en', 'label': 'Inglés'},
+                      {'code': 'zh', 'label': 'Chino (mandarín)'},
+                      {'code': 'pt', 'label': 'Portugués'},
+                      {'code': 'fr', 'label': 'Francés'},
+                      {'code': 'de', 'label': 'Alemán'},
+                      {'code': 'ja', 'label': 'Japonés'},
+                      {'code': 'ko', 'label': 'Coreano'},
+                      {'code': 'it', 'label': 'Italiano'},
+                      {'code': 'otro', 'label': 'Otro'}]},
+ 'regimen_fiscal': {'label': 'Régimen fiscal',
+                    'is_system': False,
+                    'items': [{'code': 'fisica', 'label': 'Persona física'},
+                              {'code': 'moral', 'label': 'Persona moral'}]},
+ 'uso_cfdi': {'label': 'Uso de CFDI (SAT)',
+              'is_system': True,
+              'items': [{'code': 'G01', 'label': 'Adquisición de mercancías'},
+                        {'code': 'G02', 'label': 'Devoluciones, descuentos o bonificaciones'},
+                        {'code': 'G03', 'label': 'Gastos en general'},
+                        {'code': 'I01', 'label': 'Construcciones'},
+                        {'code': 'I02', 'label': 'Mobiliario y equipo de oficina por inversiones'},
+                        {'code': 'I03', 'label': 'Equipo de transporte'},
+                        {'code': 'I04', 'label': 'Equipo de cómputo y accesorios'},
+                        {'code': 'I05', 'label': 'Dados, troqueles, moldes, matrices y herramental'},
+                        {'code': 'I06', 'label': 'Comunicaciones telefónicas'},
+                        {'code': 'I07', 'label': 'Comunicaciones satelitales'},
+                        {'code': 'I08', 'label': 'Otra maquinaria y equipo'},
+                        {'code': 'D01', 'label': 'Honorarios médicos, dentales y gastos hospitalarios'},
+                        {'code': 'D02', 'label': 'Gastos médicos por incapacidad o discapacidad'},
+                        {'code': 'D03', 'label': 'Gastos funerales'},
+                        {'code': 'D04', 'label': 'Donativos'},
+                        {'code': 'D05', 'label': 'Intereses por créditos hipotecarios'},
+                        {'code': 'D06', 'label': 'Aportaciones voluntarias al SAR'},
+                        {'code': 'D07', 'label': 'Primas por seguros de gastos médicos'},
+                        {'code': 'D08', 'label': 'Gastos de transportación escolar obligatoria'},
+                        {'code': 'D09', 'label': 'Depósitos en cuentas para el ahorro'},
+                        {'code': 'D10', 'label': 'Pagos por servicios educativos (colegiaturas)'},
+                        {'code': 'S01', 'label': 'Sin efectos fiscales'},
+                        {'code': 'CP01', 'label': 'Pagos'},
+                        {'code': 'CN01', 'label': 'Nómina'},
+                        {'code': 'P01', 'label': 'Por definir'}]},
+ 'forma_pago': {'label': 'Forma de pago (SAT)',
+                'is_system': True,
+                'items': [{'code': '1', 'label': 'Efectivo'},
+                          {'code': '2', 'label': 'Cheque nominativo'},
+                          {'code': '3', 'label': 'Transferencia electrónica de fondos'},
+                          {'code': '4', 'label': 'Tarjeta de crédito'},
+                          {'code': '5', 'label': 'Monedero electrónico'},
+                          {'code': '6', 'label': 'Dinero electrónico'},
+                          {'code': '8', 'label': 'Vales de despensa'},
+                          {'code': '12', 'label': 'Dación en pago'},
+                          {'code': '13', 'label': 'Pago por subrogación'},
+                          {'code': '14', 'label': 'Pago por consignación'},
+                          {'code': '15', 'label': 'Condonación'},
+                          {'code': '17', 'label': 'Compensación'},
+                          {'code': '23', 'label': 'Novación'},
+                          {'code': '24', 'label': 'Confusión'},
+                          {'code': '25', 'label': 'Remisión de deuda'},
+                          {'code': '26', 'label': 'Prescripción o caducidad'},
+                          {'code': '27', 'label': 'A satisfacción del acreedor'},
+                          {'code': '28', 'label': 'Tarjeta de débito'},
+                          {'code': '29', 'label': 'Tarjeta de servicios'},
+                          {'code': '30', 'label': 'Aplicación de anticipos'},
+                          {'code': '31', 'label': 'Intermediario pagos'},
+                          {'code': '99', 'label': 'Por definir'}]},
+ 'metodo_pago': {'label': 'Método de pago (SAT)',
+                 'is_system': True,
+                 'items': [{'code': 'PPD', 'label': 'Pago en parcialidades o diferido'},
+                           {'code': 'PUE', 'label': 'Pago en una sola exhibición'}]},
+ 'moneda': {'label': 'Moneda (ISO 4217)',
+            'is_system': True,
+            'items': [{'code': 'CRC', 'label': 'Colón costarricense'},
+                      {'code': 'CUC', 'label': 'Peso Convertible'},
+                      {'code': 'CUP', 'label': 'Peso Cubano'},
+                      {'code': 'CVE', 'label': 'Cabo Verde Escudo'},
+                      {'code': 'CZK', 'label': 'Corona checa'},
+                      {'code': 'DJF', 'label': 'Franco de Djibouti'},
+                      {'code': 'DKK', 'label': 'Corona danesa'},
+                      {'code': 'DOP', 'label': 'Peso Dominicano'},
+                      {'code': 'DZD', 'label': 'Dinar argelino'},
+                      {'code': 'EGP', 'label': 'Libra egipcia'},
+                      {'code': 'ERN', 'label': 'Nakfa'},
+                      {'code': 'ETB', 'label': 'Birr etíope'},
+                      {'code': 'EUR', 'label': 'Euro'},
+                      {'code': 'FJD', 'label': 'Dólar de Fiji'},
+                      {'code': 'FKP', 'label': 'Libra malvinense'},
+                      {'code': 'GBP', 'label': 'Libra Esterlina'},
+                      {'code': 'GEL', 'label': 'Lari'},
+                      {'code': 'GHS', 'label': 'Cedi de Ghana'},
+                      {'code': 'GIP', 'label': 'Libra de Gibraltar'},
+                      {'code': 'GMD', 'label': 'Dalasi'},
+                      {'code': 'GNF', 'label': 'Franco guineano'},
+                      {'code': 'GTQ', 'label': 'Quetzal'},
+                      {'code': 'GYD', 'label': 'Dólar guyanés'},
+                      {'code': 'HKD', 'label': 'Dolar De Hong Kong'},
+                      {'code': 'HNL', 'label': 'Lempira'},
+                      {'code': 'HRK', 'label': 'Kuna'},
+                      {'code': 'HTG', 'label': 'Gourde'},
+                      {'code': 'HUF', 'label': 'Florín'},
+                      {'code': 'IDR', 'label': 'Rupia'},
+                      {'code': 'ILS', 'label': 'Nuevo Shekel Israelí'},
+                      {'code': 'INR', 'label': 'Rupia india'},
+                      {'code': 'IQD', 'label': 'Dinar iraquí'},
+                      {'code': 'IRR', 'label': 'Rial iraní'},
+                      {'code': 'ISK', 'label': 'Corona islandesa'},
+                      {'code': 'JMD', 'label': 'Dólar Jamaiquino'},
+                      {'code': 'JOD', 'label': 'Dinar jordano'},
+                      {'code': 'JPY', 'label': 'Yen'},
+                      {'code': 'KES', 'label': 'Chelín keniano'},
+                      {'code': 'KGS', 'label': 'Som'},
+                      {'code': 'KHR', 'label': 'Riel'},
+                      {'code': 'KMF', 'label': 'Franco Comoro'},
+                      {'code': 'KPW', 'label': 'Corea del Norte ganó'},
+                      {'code': 'KRW', 'label': 'Won'},
+                      {'code': 'KWD', 'label': 'Dinar kuwaití'},
+                      {'code': 'KYD', 'label': 'Dólar de las Islas Caimán'},
+                      {'code': 'KZT', 'label': 'Tenge'},
+                      {'code': 'LAK', 'label': 'Kip'},
+                      {'code': 'LBP', 'label': 'Libra libanesa'},
+                      {'code': 'LKR', 'label': 'Rupia de Sri Lanka'},
+                      {'code': 'LRD', 'label': 'Dólar liberiano'},
+                      {'code': 'LSL', 'label': 'Loti'},
+                      {'code': 'LYD', 'label': 'Dinar libio'},
+                      {'code': 'MAD', 'label': 'Dirham marroquí'},
+                      {'code': 'MDL', 'label': 'Leu moldavo'},
+                      {'code': 'MGA', 'label': 'Ariary malgache'},
+                      {'code': 'MKD', 'label': 'Denar'},
+                      {'code': 'MMK', 'label': 'Kyat'},
+                      {'code': 'MNT', 'label': 'Tugrik'},
+                      {'code': 'MOP', 'label': 'Pataca'},
+                      {'code': 'MRO', 'label': 'Ouguiya'},
+                      {'code': 'MUR', 'label': 'Rupia de Mauricio'},
+                      {'code': 'MVR', 'label': 'Rupia'},
+                      {'code': 'MWK', 'label': 'Kwacha'},
+                      {'code': 'MXN', 'label': 'Peso Mexicano'},
+                      {'code': 'MXV', 'label': 'México Unidad de Inversión (UDI)'},
+                      {'code': 'MYR', 'label': 'Ringgit malayo'},
+                      {'code': 'MZN', 'label': 'Mozambique Metical'},
+                      {'code': 'NAD', 'label': 'Dólar de Namibia'},
+                      {'code': 'NGN', 'label': 'Naira'},
+                      {'code': 'NIO', 'label': 'Córdoba Oro'},
+                      {'code': 'NOK', 'label': 'Corona noruega'},
+                      {'code': 'NPR', 'label': 'Rupia nepalí'},
+                      {'code': 'NZD', 'label': 'Dólar de Nueva Zelanda'},
+                      {'code': 'OMR', 'label': 'Rial omaní'},
+                      {'code': 'PAB', 'label': 'Balboa'},
+                      {'code': 'PEN', 'label': 'Nuevo Sol'},
+                      {'code': 'PGK', 'label': 'Kina'},
+                      {'code': 'PHP', 'label': 'Peso filipino'},
+                      {'code': 'PKR', 'label': 'Rupia de Pakistán'},
+                      {'code': 'PLN', 'label': 'Zloty'},
+                      {'code': 'PYG', 'label': 'Guaraní'},
+                      {'code': 'QAR', 'label': 'Qatar Rial'},
+                      {'code': 'RON', 'label': 'Leu rumano'},
+                      {'code': 'RSD', 'label': 'Dinar serbio'},
+                      {'code': 'RUB', 'label': 'Rublo ruso'},
+                      {'code': 'RWF', 'label': 'Franco ruandés'},
+                      {'code': 'SAR', 'label': 'Riyal saudí'},
+                      {'code': 'SBD', 'label': 'Dólar de las Islas Salomón'},
+                      {'code': 'SCR', 'label': 'Rupia de Seychelles'},
+                      {'code': 'SDG', 'label': 'Libra sudanesa'},
+                      {'code': 'SEK', 'label': 'Corona sueca'},
+                      {'code': 'SGD', 'label': 'Dolar De Singapur'},
+                      {'code': 'SHP', 'label': 'Libra de Santa Helena'},
+                      {'code': 'SLL', 'label': 'Leona'},
+                      {'code': 'SOS', 'label': 'Chelín somalí'},
+                      {'code': 'SRD', 'label': 'Dólar de Suriname'},
+                      {'code': 'SSP', 'label': 'Libra sudanesa Sur'},
+                      {'code': 'STD', 'label': 'Dobra'},
+                      {'code': 'SVC', 'label': 'Colon El Salvador'},
+                      {'code': 'SYP', 'label': 'Libra Siria'},
+                      {'code': 'SZL', 'label': 'Lilangeni'},
+                      {'code': 'THB', 'label': 'Baht'},
+                      {'code': 'TJS', 'label': 'Somoni'},
+                      {'code': 'TMT', 'label': 'Turkmenistán nuevo manat'},
+                      {'code': 'TND', 'label': 'Dinar tunecino'},
+                      {'code': 'TOP', 'label': "Pa'anga"},
+                      {'code': 'TRY', 'label': 'Lira turca'},
+                      {'code': 'TTD', 'label': 'Dólar de Trinidad y Tobago'},
+                      {'code': 'TWD', 'label': 'Nuevo dólar de Taiwán'},
+                      {'code': 'TZS', 'label': 'Shilling tanzano'},
+                      {'code': 'UAH', 'label': 'Hryvnia'},
+                      {'code': 'UGX', 'label': 'Shilling de Uganda'},
+                      {'code': 'USD', 'label': 'Dolar americano'},
+                      {'code': 'USN', 'label': 'Dólar estadounidense (día siguiente)'},
+                      {'code': 'UYI', 'label': 'Peso Uruguay en Unidades Indexadas (URUIURUI)'},
+                      {'code': 'UYU', 'label': 'Peso Uruguayo'},
+                      {'code': 'UZS', 'label': 'Uzbekistán Sum'},
+                      {'code': 'VEF', 'label': 'Bolívar'},
+                      {'code': 'VND', 'label': 'Dong'},
+                      {'code': 'VUV', 'label': 'Vatu'},
+                      {'code': 'WST', 'label': 'Tala'},
+                      {'code': 'XAF', 'label': 'Franco CFA BEAC'},
+                      {'code': 'XAG', 'label': 'Plata'},
+                      {'code': 'XAU', 'label': 'Oro'},
+                      {'code': 'XBA',
+                       'label': 'Unidad de Mercados de Bonos Unidad Europea Composite (EURCO)'},
+                      {'code': 'XBB',
+                       'label': 'Unidad Monetaria de Bonos de Mercados Unidad Europea (UEM-6)'},
+                      {'code': 'XBC',
+                       'label': 'Mercados de Bonos Unidad Europea unidad de cuenta a 9 (UCE-9)'},
+                      {'code': 'XBD',
+                       'label': 'Mercados de Bonos Unidad Europea unidad de cuenta a 17 (UCE-17)'},
+                      {'code': 'XCD', 'label': 'Dólar del Caribe Oriental'},
+                      {'code': 'XDR', 'label': 'DEG (Derechos Especiales de Giro)'},
+                      {'code': 'XOF', 'label': 'Franco CFA BCEAO'},
+                      {'code': 'XPD', 'label': 'Paladio'},
+                      {'code': 'XPF', 'label': 'Franco CFP'},
+                      {'code': 'XPT', 'label': 'Platino'},
+                      {'code': 'XSU', 'label': 'Sucre'},
+                      {'code': 'XTS',
+                       'label': 'Códigos reservados específicamente para propósitos de prueba'},
+                      {'code': 'XUA', 'label': 'Unidad ADB de Cuenta'},
+                      {'code': 'XXX',
+                       'label': 'Los códigos asignados para las transacciones en que intervenga ninguna '
+                                'moneda'},
+                      {'code': 'YER', 'label': 'Rial yemení'},
+                      {'code': 'ZAR', 'label': 'Rand'},
+                      {'code': 'ZMW', 'label': 'Kwacha zambiano'},
+                      {'code': 'ZWL', 'label': 'Zimbabwe Dólar'},
+                      {'code': 'NULL', 'label': 'NULL'}]},
+ 'pais': {'label': 'País (ISO 3166)',
+          'is_system': True,
+          'items': [{'code': 'ABW', 'label': 'Aruba'},
+                    {'code': 'AFG', 'label': 'Afganistán'},
+                    {'code': 'AGO', 'label': 'Angola'},
+                    {'code': 'AIA', 'label': 'Anguila'},
+                    {'code': 'ALA', 'label': 'Islas Åland'},
+                    {'code': 'ALB', 'label': 'Albania'},
+                    {'code': 'AND', 'label': 'Andorra'},
+                    {'code': 'ARE', 'label': 'Emiratos Árabes Unidos (Los)'},
+                    {'code': 'ARG', 'label': 'Argentina'},
+                    {'code': 'ARM', 'label': 'Armenia'},
+                    {'code': 'ASM', 'label': 'Samoa Americana'},
+                    {'code': 'ATA', 'label': 'Antártida'},
+                    {'code': 'ATF', 'label': 'Territorios Australes Franceses (los)'},
+                    {'code': 'ATG', 'label': 'Antigua y Barbuda'},
+                    {'code': 'AUS', 'label': 'Australia'},
+                    {'code': 'AUT', 'label': 'Austria'},
+                    {'code': 'AZE', 'label': 'Azerbaiyán'},
+                    {'code': 'BDI', 'label': 'Burundi'},
+                    {'code': 'BEL', 'label': 'Bélgica'},
+                    {'code': 'BEN', 'label': 'Benín'},
+                    {'code': 'BES', 'label': 'Bonaire, San Eustaquio y Saba'},
+                    {'code': 'BFA', 'label': 'Burkina Faso'},
+                    {'code': 'BGD', 'label': 'Bangladés'},
+                    {'code': 'BGR', 'label': 'Bulgaria'},
+                    {'code': 'BHR', 'label': 'Baréin'},
+                    {'code': 'BHS', 'label': 'Bahamas (las)'},
+                    {'code': 'BIH', 'label': 'Bosnia y Herzegovina'},
+                    {'code': 'BLM', 'label': 'San Bartolomé'},
+                    {'code': 'BLR', 'label': 'Bielorrusia'},
+                    {'code': 'BLZ', 'label': 'Belice'},
+                    {'code': 'BMU', 'label': 'Bermudas'},
+                    {'code': 'BOL', 'label': 'Bolivia, Estado Plurinacional de'},
+                    {'code': 'BRA', 'label': 'Brasil'},
+                    {'code': 'BRB', 'label': 'Barbados'},
+                    {'code': 'BRN', 'label': 'Brunéi Darussalam'},
+                    {'code': 'BTN', 'label': 'Bután'},
+                    {'code': 'BVT', 'label': 'Isla Bouvet'},
+                    {'code': 'BWA', 'label': 'Botsuana'},
+                    {'code': 'CAF', 'label': 'República Centroafricana (la)'},
+                    {'code': 'CAN', 'label': 'Canadá'},
+                    {'code': 'CCK', 'label': 'Islas Cocos (Keeling)'},
+                    {'code': 'CHE', 'label': 'Suiza'},
+                    {'code': 'CHL', 'label': 'Chile'},
+                    {'code': 'CHN', 'label': 'China'},
+                    {'code': 'CIV', 'label': "Côte d'Ivoire"},
+                    {'code': 'CMR', 'label': 'Camerún'},
+                    {'code': 'COD', 'label': 'Congo (la República Democrática del)'},
+                    {'code': 'COG', 'label': 'Congo'},
+                    {'code': 'COK', 'label': 'Islas Cook (las)'},
+                    {'code': 'COL', 'label': 'Colombia'},
+                    {'code': 'COM', 'label': 'Comoras'},
+                    {'code': 'CPV', 'label': 'Cabo Verde'},
+                    {'code': 'CRI', 'label': 'Costa Rica'},
+                    {'code': 'CUB', 'label': 'Cuba'},
+                    {'code': 'CUW', 'label': 'Curaçao'},
+                    {'code': 'CXR', 'label': 'Isla de Navidad'},
+                    {'code': 'CYM', 'label': 'Islas Caimán (las)'},
+                    {'code': 'CYP', 'label': 'Chipre'},
+                    {'code': 'CZE', 'label': 'República Checa (la)'},
+                    {'code': 'DEU', 'label': 'Alemania'},
+                    {'code': 'DJI', 'label': 'Yibuti'},
+                    {'code': 'DMA', 'label': 'Dominica'},
+                    {'code': 'DNK', 'label': 'Dinamarca'},
+                    {'code': 'DOM', 'label': 'República Dominicana (la)'},
+                    {'code': 'DZA', 'label': 'Argelia'},
+                    {'code': 'ECU', 'label': 'Ecuador'},
+                    {'code': 'EGY', 'label': 'Egipto'},
+                    {'code': 'ERI', 'label': 'Eritrea'},
+                    {'code': 'ESH', 'label': 'Sahara Occidental'},
+                    {'code': 'ESP', 'label': 'España'},
+                    {'code': 'EST', 'label': 'Estonia'},
+                    {'code': 'ETH', 'label': 'Etiopía'},
+                    {'code': 'FIN', 'label': 'Finlandia'},
+                    {'code': 'FJI', 'label': 'Fiyi'},
+                    {'code': 'FLK', 'label': 'Islas Malvinas [Falkland] (las)'},
+                    {'code': 'FRA', 'label': 'Francia'},
+                    {'code': 'FRO', 'label': 'Islas Feroe (las)'},
+                    {'code': 'FSM', 'label': 'Micronesia (los Estados Federados de)'},
+                    {'code': 'GAB', 'label': 'Gabón'},
+                    {'code': 'GBR', 'label': 'Reino Unido (el)'},
+                    {'code': 'GEO', 'label': 'Georgia'},
+                    {'code': 'GGY', 'label': 'Guernsey'},
+                    {'code': 'GHA', 'label': 'Ghana'},
+                    {'code': 'GIB', 'label': 'Gibraltar'},
+                    {'code': 'GIN', 'label': 'Guinea'},
+                    {'code': 'GLP', 'label': 'Guadalupe'},
+                    {'code': 'GMB', 'label': 'Gambia (La)'},
+                    {'code': 'GNB', 'label': 'Guinea-Bisáu'},
+                    {'code': 'GNQ', 'label': 'Guinea Ecuatorial'},
+                    {'code': 'GRC', 'label': 'Grecia'},
+                    {'code': 'GRD', 'label': 'Granada'},
+                    {'code': 'GRL', 'label': 'Groenlandia'},
+                    {'code': 'GTM', 'label': 'Guatemala'},
+                    {'code': 'GUF', 'label': 'Guayana Francesa'},
+                    {'code': 'GUM', 'label': 'Guam'},
+                    {'code': 'GUY', 'label': 'Guyana'},
+                    {'code': 'HKG', 'label': 'Hong Kong'},
+                    {'code': 'HMD', 'label': 'Isla Heard e Islas McDonald'},
+                    {'code': 'HND', 'label': 'Honduras'},
+                    {'code': 'HRV', 'label': 'Croacia'},
+                    {'code': 'HTI', 'label': 'Haití'},
+                    {'code': 'HUN', 'label': 'Hungría'},
+                    {'code': 'IDN', 'label': 'Indonesia'},
+                    {'code': 'IMN', 'label': 'Isla de Man'},
+                    {'code': 'IND', 'label': 'India'},
+                    {'code': 'IOT', 'label': 'Territorio Británico del Océano Índico (el)'},
+                    {'code': 'IRL', 'label': 'Irlanda'},
+                    {'code': 'IRN', 'label': 'Irán (la República Islámica de)'},
+                    {'code': 'IRQ', 'label': 'Irak'},
+                    {'code': 'ISL', 'label': 'Islandia'},
+                    {'code': 'ISR', 'label': 'Israel'},
+                    {'code': 'ITA', 'label': 'Italia'},
+                    {'code': 'JAM', 'label': 'Jamaica'},
+                    {'code': 'JEY', 'label': 'Jersey'},
+                    {'code': 'JOR', 'label': 'Jordania'},
+                    {'code': 'JPN', 'label': 'Japón'},
+                    {'code': 'KAZ', 'label': 'Kazajistán'},
+                    {'code': 'KEN', 'label': 'Kenia'},
+                    {'code': 'KGZ', 'label': 'Kirguistán'},
+                    {'code': 'KHM', 'label': 'Camboya'},
+                    {'code': 'KIR', 'label': 'Kiribati'},
+                    {'code': 'KNA', 'label': 'San Cristóbal y Nieves'},
+                    {'code': 'KOR', 'label': 'Corea (la República de)'},
+                    {'code': 'KWT', 'label': 'Kuwait'},
+                    {'code': 'LAO', 'label': 'Lao, (la) República Democrática Popular'},
+                    {'code': 'LBN', 'label': 'Líbano'},
+                    {'code': 'LBR', 'label': 'Liberia'},
+                    {'code': 'LBY', 'label': 'Libia'},
+                    {'code': 'LCA', 'label': 'Santa Lucía'},
+                    {'code': 'LIE', 'label': 'Liechtenstein'},
+                    {'code': 'LKA', 'label': 'Sri Lanka'},
+                    {'code': 'LSO', 'label': 'Lesoto'},
+                    {'code': 'LTU', 'label': 'Lituania'},
+                    {'code': 'LUX', 'label': 'Luxemburgo'},
+                    {'code': 'LVA', 'label': 'Letonia'},
+                    {'code': 'MAC', 'label': 'Macao'},
+                    {'code': 'MAF', 'label': 'San Martín (parte francesa)'},
+                    {'code': 'MAR', 'label': 'Marruecos'},
+                    {'code': 'MCO', 'label': 'Mónaco'},
+                    {'code': 'MDA', 'label': 'Moldavia (la República de)'},
+                    {'code': 'MDG', 'label': 'Madagascar'},
+                    {'code': 'MDV', 'label': 'Maldivas'},
+                    {'code': 'MEX', 'label': 'México'},
+                    {'code': 'MHL', 'label': 'Islas Marshall (las)'},
+                    {'code': 'MKD', 'label': 'Macedonia (la antigua República Yugoslava de)'},
+                    {'code': 'MLI', 'label': 'Malí'},
+                    {'code': 'MLT', 'label': 'Malta'},
+                    {'code': 'MMR', 'label': 'Myanmar'},
+                    {'code': 'MNE', 'label': 'Montenegro'},
+                    {'code': 'MNG', 'label': 'Mongolia'},
+                    {'code': 'MNP', 'label': 'Islas Marianas del Norte (las)'},
+                    {'code': 'MOZ', 'label': 'Mozambique'},
+                    {'code': 'MRT', 'label': 'Mauritania'},
+                    {'code': 'MSR', 'label': 'Montserrat'},
+                    {'code': 'MTQ', 'label': 'Martinica'},
+                    {'code': 'MUS', 'label': 'Mauricio'},
+                    {'code': 'MWI', 'label': 'Malaui'},
+                    {'code': 'MYS', 'label': 'Malasia'},
+                    {'code': 'MYT', 'label': 'Mayotte'},
+                    {'code': 'NAM', 'label': 'Namibia'},
+                    {'code': 'NCL', 'label': 'Nueva Caledonia'},
+                    {'code': 'NER', 'label': 'Níger (el)'},
+                    {'code': 'NFK', 'label': 'Isla Norfolk'},
+                    {'code': 'NGA', 'label': 'Nigeria'},
+                    {'code': 'NIC', 'label': 'Nicaragua'},
+                    {'code': 'NIU', 'label': 'Niue'},
+                    {'code': 'NLD', 'label': 'Países Bajos (los)'},
+                    {'code': 'NOR', 'label': 'Noruega'},
+                    {'code': 'NPL', 'label': 'Nepal'},
+                    {'code': 'NRU', 'label': 'Nauru'},
+                    {'code': 'NZL', 'label': 'Nueva Zelanda'},
+                    {'code': 'OMN', 'label': 'Omán'},
+                    {'code': 'PAK', 'label': 'Pakistán'},
+                    {'code': 'PAN', 'label': 'Panamá'},
+                    {'code': 'PCN', 'label': 'Pitcairn'},
+                    {'code': 'PER', 'label': 'Perú'},
+                    {'code': 'PHL', 'label': 'Filipinas (las)'},
+                    {'code': 'PLW', 'label': 'Palaos'},
+                    {'code': 'PNG', 'label': 'Papúa Nueva Guinea'},
+                    {'code': 'POL', 'label': 'Polonia'},
+                    {'code': 'PRI', 'label': 'Puerto Rico'},
+                    {'code': 'PRK', 'label': 'Corea (la República Democrática Popular de)'},
+                    {'code': 'PRT', 'label': 'Portugal'},
+                    {'code': 'PRY', 'label': 'Paraguay'},
+                    {'code': 'PSE', 'label': 'Palestina, Estado de'},
+                    {'code': 'PYF', 'label': 'Polinesia Francesa'},
+                    {'code': 'QAT', 'label': 'Catar'},
+                    {'code': 'REU', 'label': 'Reunión'},
+                    {'code': 'ROU', 'label': 'Rumania'},
+                    {'code': 'RUS', 'label': 'Rusia, (la) Federación de'},
+                    {'code': 'RWA', 'label': 'Ruanda'},
+                    {'code': 'SAU', 'label': 'Arabia Saudita'},
+                    {'code': 'SDN', 'label': 'Sudán (el)'},
+                    {'code': 'SEN', 'label': 'Senegal'},
+                    {'code': 'SGP', 'label': 'Singapur'},
+                    {'code': 'SGS', 'label': 'Georgia del sur y las islas sandwich del sur'},
+                    {'code': 'SHN', 'label': 'Santa Helena, Ascensión y Tristán de Acuña'},
+                    {'code': 'SJM', 'label': 'Svalbard y Jan Mayen'},
+                    {'code': 'SLB', 'label': 'Islas Salomón (las)'},
+                    {'code': 'SLE', 'label': 'Sierra leona'},
+                    {'code': 'NULL', 'label': 'NULL'}]},
+ 'estado': {'label': 'Estado / Provincia',
+            'is_system': True,
+            'items': [{'code': 'AGU',
+                       'label': 'Aguascalientes',
+                       'parent_catalog': 'pais',
+                       'parent_code': 'MEX'},
+                      {'code': 'BCN',
+                       'label': 'Baja California',
+                       'parent_catalog': 'pais',
+                       'parent_code': 'MEX'},
+                      {'code': 'BCS',
+                       'label': 'Baja California Sur',
+                       'parent_catalog': 'pais',
+                       'parent_code': 'MEX'},
+                      {'code': 'CAM', 'label': 'Campeche', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'CHP', 'label': 'Chiapas', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'CHH', 'label': 'Chihuahua', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'CMX',
+                       'label': 'Ciudad de México',
+                       'parent_catalog': 'pais',
+                       'parent_code': 'MEX'},
+                      {'code': 'COA', 'label': 'Coahuila', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'COL', 'label': 'Colima', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'DUR', 'label': 'Durango', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'GUA', 'label': 'Guanajuato', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'GRO', 'label': 'Guerrero', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'HID', 'label': 'Hidalgo', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'JAL', 'label': 'Jalisco', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'MEX',
+                       'label': 'Estado de México',
+                       'parent_catalog': 'pais',
+                       'parent_code': 'MEX'},
+                      {'code': 'MIC', 'label': 'Michoacán', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'MOR', 'label': 'Morelos', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'NAY', 'label': 'Nayarit', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'NLE', 'label': 'Nuevo León', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'OAX', 'label': 'Oaxaca', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'PUE', 'label': 'Puebla', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'QUE', 'label': 'Querétaro', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'ROO',
+                       'label': 'Quintana Roo',
+                       'parent_catalog': 'pais',
+                       'parent_code': 'MEX'},
+                      {'code': 'SLP',
+                       'label': 'San Luis Potosí',
+                       'parent_catalog': 'pais',
+                       'parent_code': 'MEX'},
+                      {'code': 'SIN', 'label': 'Sinaloa', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'SON', 'label': 'Sonora', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'TAB', 'label': 'Tabasco', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'TAM', 'label': 'Tamaulipas', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'TLA', 'label': 'Tlaxcala', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'VER', 'label': 'Veracruz', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'YUC', 'label': 'Yucatán', 'parent_catalog': 'pais', 'parent_code': 'MEX'},
+                      {'code': 'ZAC', 'label': 'Zacatecas', 'parent_catalog': 'pais', 'parent_code': 'MEX'}]},
+ 'tipo_domicilio': {'label': 'Tipo de domicilio',
+                    'is_system': False,
+                    'items': [{'code': 'fiscal', 'label': 'Fiscal'},
+                              {'code': 'oficina', 'label': 'Oficina'},
+                              {'code': 'sucursal', 'label': 'Sucursal'},
+                              {'code': 'bodega', 'label': 'Bodega'},
+                              {'code': 'patio', 'label': 'Patio'},
+                              {'code': 'terminal', 'label': 'Terminal'},
+                              {'code': 'almacen', 'label': 'Almacén'}]},
+ 'area': {'label': 'Área / Departamento',
+          'is_system': False,
+          'items': [{'code': 'ventas', 'label': 'Ventas'},
+                    {'code': 'operaciones', 'label': 'Operaciones'},
+                    {'code': 'facturacion', 'label': 'Facturación'},
+                    {'code': 'cobranza', 'label': 'Cobranza'},
+                    {'code': 'servicio_cliente', 'label': 'Servicio al cliente'}]},
+ 'cobertura': {'label': 'Cobertura',
+               'is_system': True,
+               'items': [{'code': 'nacional', 'label': 'Nacional'},
+                         {'code': 'internacional', 'label': 'Internacional'}]},
+ 'clasificacion_proveedor': {'label': 'Clasificación del proveedor',
+                             'is_system': False,
+                             'items': [{'code': 'naviera', 'label': 'Naviera'},
+                                       {'code': 'aerolinea', 'label': 'Aerolínea'},
+                                       {'code': 'transportista_terrestre',
+                                        'label': 'Transportista Terrestre'},
+                                       {'code': 'ferrocarril', 'label': 'Ferrocarril'},
+                                       {'code': 'agente_aduanal', 'label': 'Agente Aduanal'},
+                                       {'code': 'agente_carga', 'label': 'Agente de Carga'},
+                                       {'code': 'agente_corresponsal', 'label': 'Agente Corresponsal'},
+                                       {'code': 'almacen', 'label': 'Almacén'},
+                                       {'code': 'aseguradora', 'label': 'Aseguradora'},
+                                       {'code': 'paqueteria', 'label': 'Paquetería'},
+                                       {'code': 'otro', 'label': 'Otro'}]}}
+
+TENANT_CATALOG_LABELS = {'servicio': 'Servicios que ofrece',
+ 'puerto': 'Puertos donde opera',
+ 'aeropuerto': 'Aeropuertos donde opera',
+ 'aduana': 'Aduanas donde opera'}

backend/api/v1/modules/crm/catalogs/service.py

@@ -0,0 +1,168 @@
+"""Lógica de negocio de los catálogos de referencia del CRM."""
+
+from typing import Any
+
+from fastapi import HTTPException, status
+from sqlalchemy import and_, or_
+from sqlalchemy.orm import Session
+
+from core.security import is_hub_admin
+
+from .dto import CatalogItemCreate, CatalogItemUpdate, CatalogMeta
+from .models import CatalogItem
+from .seed_data import GLOBAL_CATALOGS, TENANT_CATALOG_LABELS
+
+# Metadata de catálogos (labels y si el cliente puede llenarlos).
+CATALOG_LABELS: dict[str, str] = {k: v["label"] for k, v in GLOBAL_CATALOGS.items()}
+CATALOG_LABELS.update(TENANT_CATALOG_LABELS)
+# Catálogos que administra el cliente (tenant). El resto son globales (Aduanasoft).
+TENANT_CATALOG_KEYS = set(TENANT_CATALOG_LABELS.keys())
+KNOWN_CATALOGS = set(CATALOG_LABELS.keys())
+
+
+def _require_known(catalog: str) -> None:
+    if catalog not in KNOWN_CATALOGS:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Catálogo '{catalog}' no existe")
+
+
+def list_meta(db: Session, tenant_id: int) -> list[CatalogMeta]:
+    """Lista todos los catálogos disponibles con su conteo (global + del tenant)."""
+    out: list[CatalogMeta] = []
+    for key, label in CATALOG_LABELS.items():
+        is_tenant = key in TENANT_CATALOG_KEYS
+        count = (
+            db.query(CatalogItem)
+            .filter(
+                CatalogItem.catalog == key,
+                or_(CatalogItem.tenant_id.is_(None), CatalogItem.tenant_id == tenant_id),
+            )
+            .count()
+        )
+        out.append(
+            CatalogMeta(
+                catalog=key,
+                label=label,
+                scope="tenant" if is_tenant else "global",
+                is_system=bool(GLOBAL_CATALOGS.get(key, {}).get("is_system", False)),
+                count=count,
+            )
+        )
+    return out
+
+
+def list_items(
+    db: Session,
+    catalog: str,
+    tenant_id: int,
+    parent_code: str | None = None,
+    include_inactive: bool = False,
+) -> list[CatalogItem]:
+    _require_known(catalog)
+    q = db.query(CatalogItem).filter(
+        CatalogItem.catalog == catalog,
+        or_(CatalogItem.tenant_id.is_(None), CatalogItem.tenant_id == tenant_id),
+    )
+    if not include_inactive:
+        q = q.filter(CatalogItem.is_active.is_(True))
+    if parent_code:
+        q = q.filter(CatalogItem.parent_code == parent_code)
+    return q.order_by(CatalogItem.sort_order, CatalogItem.label).all()
+
+
+def _resolve_write_scope(catalog: str, scope: str | None, current_user: dict) -> int | None:
+    """Devuelve el tenant_id a usar al escribir (None = global) y valida permisos.
+
+    - scope 'global' → solo hub_admin puede tocar catálogos globales (Aduanasoft).
+    - scope 'tenant' (default) → se guarda en el tenant del usuario.
+    """
+    wants_global = scope == "global"
+    if wants_global:
+        if not is_hub_admin(current_user):
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Solo un administrador de Aduanasoft puede editar catálogos globales.",
+            )
+        return None
+    return int(current_user["tenant_id"])
+
+
+def create_item(
+    db: Session, catalog: str, data: CatalogItemCreate, current_user: dict, scope: str | None = None
+) -> CatalogItem:
+    _require_known(catalog)
+    target_tenant = _resolve_write_scope(catalog, scope, current_user)
+
+    # No duplicar por (catalog, code, tenant_id)
+    exists = (
+        db.query(CatalogItem)
+        .filter(
+            CatalogItem.catalog == catalog,
+            CatalogItem.code == data.code,
+            CatalogItem.tenant_id.is_(None) if target_tenant is None else CatalogItem.tenant_id == target_tenant,
+        )
+        .first()
+    )
+    if exists:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Ya existe la clave '{data.code}' en el catálogo '{catalog}'.",
+        )
+
+    item = CatalogItem(
+        catalog=catalog,
+        code=data.code,
+        label=data.label,
+        parent_catalog=data.parent_catalog,
+        parent_code=data.parent_code,
+        tenant_id=target_tenant,
+        sort_order=data.sort_order,
+        is_active=data.is_active,
+        is_system=False,
+        created_by=current_user.get("sub"),
+        updated_by=current_user.get("sub"),
+    )
+    db.add(item)
+    db.commit()
+    db.refresh(item)
+    return item
+
+
+def _get_writable(db: Session, catalog: str, item_id: int, current_user: dict) -> CatalogItem:
+    _require_known(catalog)
+    item = db.query(CatalogItem).filter(CatalogItem.id == item_id, CatalogItem.catalog == catalog).first()
+    if not item:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Elemento no encontrado")
+    if item.tenant_id is None:
+        # Global (Aduanasoft): solo hub_admin.
+        if not is_hub_admin(current_user):
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Solo un administrador de Aduanasoft puede editar este catálogo global.",
+            )
+    elif item.tenant_id != int(current_user["tenant_id"]):
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Elemento no encontrado")
+    return item
+
+
+def update_item(
+    db: Session, catalog: str, item_id: int, data: CatalogItemUpdate, current_user: dict
+) -> CatalogItem:
+    item = _get_writable(db, catalog, item_id, current_user)
+    payload: dict[str, Any] = data.model_dump(exclude_unset=True)
+    for field, value in payload.items():
+        setattr(item, field, value)
+    item.updated_by = current_user.get("sub")
+    db.commit()
+    db.refresh(item)
+    return item
+
+
+def delete_item(db: Session, catalog: str, item_id: int, current_user: dict) -> None:
+    item = _get_writable(db, catalog, item_id, current_user)
+    if item.is_system:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Un catálogo base del sistema no se puede borrar; puedes desactivarlo.",
+        )
+    db.delete(item)
+    db.commit()

backend/api/v1/modules/crm/suppliers/dto.py

@@ -13,6 +13,7 @@ class SupplierBase(BaseModel):
     person_type: str | None = Field(None, max_length=10)
     status: str = Field("active", max_length=20)
     classifications: list[str] = Field(default_factory=list)
+    classification_other: str | None = Field(None, max_length=120)
     # Comercial
     services_offered: str | None = None
     coverage: str | None = Field(None, max_length=20)
@@ -52,6 +53,7 @@ class SupplierUpdate(BaseModel):
     person_type: str | None = Field(None, max_length=10)
     status: str | None = Field(None, max_length=20)
     classifications: list[str] | None = None
+    classification_other: str | None = Field(None, max_length=120)
     services_offered: str | None = None
     coverage: str | None = Field(None, max_length=20)
     countries: list[str] | None = None

backend/api/v1/modules/crm/suppliers/models.py

@@ -30,6 +30,8 @@ class Supplier(Base, TenantScopedMixin, TimestampMixin):
     # Clasificación (múltiple): naviera, aerolinea, transportista_terrestre, ferrocarril,
     # agente_aduanal, agente_carga, agente_corresponsal, almacen, aseguradora, paqueteria, otro
     classifications: Mapped[list | None] = mapped_column(JSON, nullable=True, default=list)
+    # Texto libre cuando la clasificación incluye "otro"
+    classification_other: Mapped[str | None] = mapped_column(String(120), nullable=True)
 
     # ----- Información comercial -----
     services_offered: Mapped[str | None] = mapped_column(Text, nullable=True)

backend/core/config.py

@@ -42,6 +42,19 @@ class Settings(BaseSettings):
     PERMISSION_CACHE_ENABLED: bool = True
     PERMISSION_CACHE_TTL_SECONDS: int = 300
 
+    # Sesión local del CRM (patrón SIWEB) — desacopla la sesión de la app del
+    # token KC de 60s. Tras SSO/login se guardan los tokens KC en valkey y se emite
+    # una sesión local firmada (HS256) con vida por inactividad (idle) y cap
+    # absoluto. Así el refresh del token KC contra el Hub solo se intenta al expirar
+    # la sesión local (no cada ~60s), lo que elimina el bucle de login.
+    #
+    # SE RESPETA la revocación central de Keycloak: si el Hub rechaza el refresh, la
+    # sesión termina (no hay re-emisión local de fallback). Flag-gated para rollback:
+    # con SESSION_STORE_ENABLED=False el comportamiento no cambia.
+    SESSION_STORE_ENABLED: bool = False
+    SESSION_IDLE_MINUTES: int = 30
+    SESSION_MAX_HOURS: int = 10
+
     # Synchronization
     SYNC_SECRET_TOKEN: str = "change-this-sync-token-in-production"
     CENTRAL_SERVER_URL: str = "http://localhost:8000/api/v1/core/help-center/sync/"

backend/core/hub_token.py

@@ -0,0 +1,67 @@
+"""
+Obtención de un access token de Keycloak VÁLIDO para llamar a la API del Hub.
+
+Con el patrón de sesión local (SIWEB) el Bearer de la app es un JWT propio (HS256)
+que el Hub NO entiende. Para las llamadas server→Hub se usa el token KC guardado en
+la sesión (valkey, vía cookie crm_sid), refrescándolo si está por expirar.
+"""
+
+import logging
+import time
+from typing import Optional
+
+import httpx
+from jose import jwt
+
+from core.config import settings
+from core import session_store
+
+logger = logging.getLogger(__name__)
+
+
+def _kc_exp_ok(token: str, leeway_seconds: int = 30) -> bool:
+    """True si el token KC no está expirado (con margen)."""
+    try:
+        claims = jwt.get_unverified_claims(token)
+        exp = claims.get("exp")
+        return isinstance(exp, (int, float)) and (int(exp) - int(time.time())) > leeway_seconds
+    except Exception:
+        return False
+
+
+async def get_hub_access_token(request) -> Optional[str]:
+    """
+    Devuelve un access token KC válido tomado de la sesión (valkey vía crm_sid),
+    refrescándolo contra el Hub si está por expirar. None si no hay sesión.
+    Best-effort: si el refresh falla, devuelve el token guardado (puede estar vencido).
+    """
+    sid = request.cookies.get("crm_sid") if request is not None else None
+    if not sid:
+        return None
+    sess = session_store.get_session(sid)
+    if not sess:
+        return None
+
+    access = sess.get("access_token")
+    refresh = sess.get("refresh_token")
+
+    if access and _kc_exp_ok(access):
+        return access
+
+    if refresh:
+        try:
+            async with httpx.AsyncClient(timeout=8.0) as client:
+                r = await client.post(
+                    f"{settings.HUB_URL}api/v1/auth/refresh",
+                    json={"refresh_token": refresh},
+                )
+            if r.status_code == 200:
+                data = r.json()
+                new_access = data.get("access_token") or access
+                session_store.update_session_tokens(sid, new_access, data.get("refresh_token") or refresh)
+                return new_access
+            logger.info("get_hub_access_token: Hub refresh devolvió %s", r.status_code)
+        except Exception as exc:
+            logger.warning("get_hub_access_token: refresh falló: %s", exc)
+
+    return access

backend/core/local_session.py

@@ -0,0 +1,94 @@
+"""
+Sesión local del CRM (patrón SIWEB).
+
+Emite y valida un JWT de sesión propio (HS256, firmado con SECRET_KEY) que
+transporta la identidad YA verificada por Keycloak/Hub. Desacopla la sesión de la
+app del token KC de 60s: la app valida esta sesión local (sin ir al Hub) durante
+su ventana de inactividad, de modo que el refresh del token KC solo se intenta al
+expirar la sesión local — no cada ~60s. Esto elimina el bucle de login.
+
+Se RESPETA la revocación central: si el Hub rechaza el refresh, la sesión termina
+(no hay re-emisión de fallback).
+
+Marcadores del token:
+  - source: "local" + crm_session: True  → distingue de tokens KC (RS256) y del
+    token dev-local (dev_local: True).
+  - sst (session start time, epoch seg)   → fija la vida ABSOLUTA máxima (cap).
+  - exp                                    → sliding por inactividad (idle); se
+    re-emite en cada refresh mientras no se supere el cap.
+
+Seguridad: es un desacople CONSCIENTE de la revocación central de KC (OWASP A07).
+Se acota con idle corto (= ssoSessionIdleTimeout) y cap absoluto
+(= ssoSessionMaxLifespan); el logout elimina la sesión de valkey.
+"""
+
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from jose import JWTError, jwt
+
+from core.config import settings
+
+# Claims de identidad que se propagan del token KC a la sesión local.
+_IDENTITY_CLAIMS = (
+    "sub", "email", "preferred_username", "username", "name",
+    "given_name", "family_name", "first_name", "last_name",
+    "tenant_id", "tenant_slug", "roles", "permissions",
+    "is_hub_admin", "avatar_url",
+)
+
+
+def _now_epoch() -> int:
+    return int(datetime.now(timezone.utc).timestamp())
+
+
+def mint_session_token(claims: Dict[str, Any], session_start: Optional[int] = None) -> str:
+    """
+    Emite un JWT de sesión local a partir de los claims (verificados) del usuario.
+    `session_start` (epoch seg) fija el inicio de sesión para el cap absoluto; si
+    no se provee, se usa el momento actual (sesión nueva).
+    """
+    now = _now_epoch()
+    sst = int(session_start) if session_start else now
+
+    payload: Dict[str, Any] = {
+        k: claims[k] for k in _IDENTITY_CLAIMS if claims.get(k) is not None
+    }
+    payload.update({
+        "source": "local",
+        "crm_session": True,
+        "sst": sst,
+        "iat": now,
+        "exp": now + settings.SESSION_IDLE_MINUTES * 60,
+    })
+    return jwt.encode(payload, settings.SECRET_KEY, algorithm="HS256")
+
+
+def verify_session_token(token: str) -> Optional[Dict[str, Any]]:
+    """
+    Valida un JWT de sesión local. Retorna los claims si es válido, no expiró por
+    inactividad y no superó el cap absoluto de vida; None en cualquier otro caso.
+    Nunca lanza (para poder encadenar con la validación contra el Hub).
+    """
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+    except JWTError:
+        return None
+
+    # Solo aceptamos tokens de sesión local del CRM (no KC, no dev-local).
+    if not payload.get("crm_session") or payload.get("source") != "local":
+        return None
+
+    # Cap absoluto de vida de sesión (independiente del sliding por idle).
+    sst = payload.get("sst")
+    if isinstance(sst, (int, float)):
+        if _now_epoch() - int(sst) > settings.SESSION_MAX_HOURS * 3600:
+            return None
+
+    return payload
+
+
+def session_start_of(payload: Dict[str, Any]) -> Optional[int]:
+    """Extrae el epoch de inicio de sesión (sst) de un payload de sesión local."""
+    sst = payload.get("sst")
+    return int(sst) if isinstance(sst, (int, float)) else None

backend/core/middleware.py

@@ -3,6 +3,7 @@ import time
 import httpx
 from datetime import datetime, timezone
 from typing import Callable, Optional
+from cachetools import TTLCache
 from fastapi import Request, Response
 from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware
@@ -12,6 +13,11 @@ from .security import get_tenant_from_token, verify_token, get_active_system
 
 logger = logging.getLogger(__name__)
 
+# Caché de validación de licencia por tenant (patrón SIWEB): evita consultar al
+# Hub en cada request. Valor: "valid" o "invalid:<mensaje>". TTL corto para que
+# los cambios de licencia se propaguen en minutos.
+_license_cache: TTLCache = TTLCache(maxsize=1000, ttl=600)
+
 
 def _normalize_text(value: str | None) -> str:
     if not value:
@@ -145,6 +151,18 @@ class LicenseValidationMiddleware(BaseHTTPMiddleware):
         
         token = auth_header.split(" ")[1]
 
+        # Sesión local del CRM (patrón SIWEB): el Bearer es un JWT HS256 propio que
+        # el Hub NO entiende. No se le reenvía: la licencia se valida con el token KC
+        # guardado en valkey y se cachea por tenant.
+        if getattr(settings, "SESSION_STORE_ENABLED", False):
+            try:
+                from core.local_session import verify_session_token
+                local_claims = verify_session_token(token)
+            except Exception:
+                local_claims = None
+            if local_claims is not None:
+                return await self._handle_local_session_license(request, call_next, local_claims)
+
         tenant_override = request.headers.get("X-Tenant-Override")
         if not tenant_override:
             # Fallback para flujos SSO cuando el override no viaja en header.
@@ -307,6 +325,136 @@ class LicenseValidationMiddleware(BaseHTTPMiddleware):
             }
         )
 
+    async def _handle_local_session_license(self, request: Request, call_next: Callable, local_claims: dict):
+        """
+        Valida licencia para una sesión local del CRM (patrón SIWEB).
+
+        El Hub no valida el JWT HS256 local, así que se usa el token KC guardado en
+        valkey (refrescándolo si está vencido) para consultar verify-license, con
+        caché por tenant. Si el Hub no es concluyente (p. ej. su refresh falla), se
+        permite el paso: la sesión local se emitió tras un login válido (el App
+        Launcher solo ofrece apps licenciadas), evitando bloquear por un problema
+        transitorio del Hub. Los resultados concluyentes (válido/ inválido) sí se cachean.
+        """
+        from core import session_store
+
+        tenant_key = str(local_claims.get("tenant_id") or "")
+
+        cached = _license_cache.get(tenant_key) if tenant_key else None
+        if cached == "valid":
+            return await call_next(request)
+        if isinstance(cached, str) and cached.startswith("invalid:"):
+            return JSONResponse(
+                status_code=402,
+                content={"error": "LICENSE_ERROR", "message": cached[len("invalid:"):], "status_code": 402},
+            )
+
+        tenant_override = (
+            tenant_key
+            or request.cookies.get("sso_tenant_id")
+            or request.cookies.get("sso_tenant_pub")
+            or ""
+        )
+
+        sid = request.cookies.get("crm_sid")
+        sess = session_store.get_session(sid) if sid else None
+        kc_token = (sess or {}).get("access_token") or ""
+        kc_refresh = (sess or {}).get("refresh_token") or ""
+
+        async def _verify(tok: str):
+            if not tok:
+                return None
+            headers = {"Authorization": f"Bearer {tok}"}
+            if tenant_override:
+                headers["X-Tenant-Override"] = str(tenant_override)
+            try:
+                async with httpx.AsyncClient(timeout=5.0) as client:
+                    return await client.get(
+                        f"{settings.HUB_URL}api/v1/auth/verify-license", headers=headers
+                    )
+            except Exception as exc:
+                logger.warning("[license] verify-license (sesión local) error de red: %s", exc)
+                return None
+
+        resp = await _verify(kc_token)
+
+        # ¿El KC token guardado está vencido? Refrescar una vez y reintentar.
+        needs_refresh = resp is None or resp.status_code == 401
+        if not needs_refresh and resp.status_code == 200:
+            try:
+                _d = resp.json()
+            except Exception:
+                _d = {}
+            if not _d.get("valid", False) and _is_token_issue_message(
+                _d.get("message"), _d.get("detail"), _d.get("reason")
+            ):
+                needs_refresh = True
+
+        if needs_refresh and kc_refresh:
+            try:
+                async with httpx.AsyncClient(timeout=8.0) as client:
+                    rr = await client.post(
+                        f"{settings.HUB_URL}api/v1/auth/refresh",
+                        json={"refresh_token": kc_refresh},
+                    )
+                if rr.status_code == 200:
+                    nt = rr.json()
+                    kc_token = nt.get("access_token") or kc_token
+                    if sid:
+                        session_store.update_session_tokens(
+                            sid, kc_token, nt.get("refresh_token") or kc_refresh
+                        )
+                    resp = await _verify(kc_token)
+                else:
+                    logger.warning("[license] refresh KC para verify-license devolvió %s", rr.status_code)
+            except Exception as exc:
+                logger.warning("[license] refresh KC para verify-license falló: %s", exc)
+
+        if resp is not None and resp.status_code == 200:
+            try:
+                data = resp.json()
+            except Exception:
+                data = {}
+            if data.get("valid", False):
+                expires_at_str = data.get("expires_at")
+                if expires_at_str:
+                    try:
+                        expires_at = datetime.fromisoformat(expires_at_str.replace("Z", "+00:00"))
+                        if expires_at.tzinfo is None:
+                            expires_at = expires_at.replace(tzinfo=timezone.utc)
+                        if expires_at < datetime.now(timezone.utc):
+                            msg = f"La licencia venció el {expires_at.strftime('%d/%m/%Y')}. Renueva tu suscripción."
+                            if tenant_key:
+                                _license_cache[tenant_key] = f"invalid:{msg}"
+                            return JSONResponse(
+                                status_code=402,
+                                content={"error": "LICENSE_EXPIRED", "message": msg, "status_code": 402},
+                            )
+                    except (ValueError, TypeError):
+                        pass
+                if tenant_key:
+                    _license_cache[tenant_key] = "valid"
+                request.state.license_info = data
+                return await call_next(request)
+
+            message = data.get("message", "Sin licencia asignada para este tenant")
+            if not _is_token_issue_message(data.get("message"), data.get("detail"), data.get("reason")):
+                if tenant_key:
+                    _license_cache[tenant_key] = f"invalid:{message}"
+                return JSONResponse(
+                    status_code=402,
+                    content={"error": "LICENSE_ERROR", "message": message, "status_code": 402},
+                )
+
+        # No concluyente (Hub no dio 200, o el problema de token persiste porque su
+        # refresh falla): la sesión local es válida → permitir sin cachear. Evita el
+        # bucle de 401 por el bug de refresh del Hub.
+        logger.warning(
+            "[license] verify-license no concluyente para sesión local (tenant=%s) — se permite",
+            tenant_key,
+        )
+        return await call_next(request)
+
 
 class RequestLoggingMiddleware(BaseHTTPMiddleware):
     """

backend/core/security.py

@@ -47,6 +47,19 @@ async def verify_token(token: str, tenant_id_override: str = None) -> Dict[str,
     if cache_key in token_cache:
         return token_cache[cache_key]
 
+    # Sesión local del CRM (patrón SIWEB): si el token es una sesión local firmada
+    # (HS256, crm_session), validarla sin ir al Hub en cada request. Así el refresh
+    # del token KC solo se intenta al expirar la sesión local (no cada ~60s), lo que
+    # elimina el bucle de login. verify_session_token retorna None para tokens KC
+    # (RS256), así que no interfiere con el flujo normal.
+    if settings.SESSION_STORE_ENABLED:
+        from core.local_session import verify_session_token
+
+        local_claims = verify_session_token(token)
+        if local_claims is not None:
+            token_cache[cache_key] = local_claims
+            return local_claims
+
     # Shortcut para tokens de desarrollo local
     if settings.DEV_LOCAL_AUTH:
         try:
@@ -653,6 +666,20 @@ def validate_access_to_resource(
 
     tenant_id = resolve_effective_tenant_id_from_user(current_user)
 
+    # Si el usuario no trae tenant en el token (p. ej. hub_admin del workspace),
+    # resolverlo desde la compañía activa (a76.company.tenant_id). Permite operar
+    # por compañía seleccionada cuando el token no está ligado a un tenant.
+    if tenant_id is None and company_id:
+        try:
+            from sqlalchemy import text as _text
+            row = db.execute(
+                _text("SELECT tenant_id FROM a76.company WHERE id = :c"), {"c": company_id}
+            ).first()
+            if row and row[0] is not None:
+                tenant_id = int(row[0])
+        except Exception as exc:
+            logger.warning("no se pudo resolver tenant desde company_id=%s: %s", company_id, exc)
+
     # Bypass de checks de permisos: hub_admin (atestado por el Hub en /auth/me)
     # o rol local "super_admin" en la compañía (fuente de verdad: BD de a76).
     # Se reemplazó el antiguo "admin" in realm_access.roles para que la

backend/core/session_store.py

@@ -0,0 +1,111 @@
+"""
+Store de sesión en Valkey/Redis (patrón SIWEB).
+
+Guarda los tokens de Keycloak (access + refresh) FUERA del browser, indexados por
+un session_id opaco. La app usa la sesión local firmada (ver core.local_session)
+para su propia auth; los tokens KC de aquí solo se usan para llamadas al Hub
+(provisioning, my-apps, my-tenants), refrescándolos best-effort.
+
+Fail-silent: si Valkey no está disponible, las operaciones degradan a None/no-op
+y la sesión local firmada sigue sosteniendo la app.
+"""
+
+import json
+import logging
+import uuid
+from typing import Optional
+
+from core.config import settings
+
+try:
+    import redis  # type: ignore
+except Exception:  # pragma: no cover - redis es opcional en algunos entornos
+    redis = None  # type: ignore
+
+logger = logging.getLogger(__name__)
+
+_KEY_PREFIX = "crm:session:"
+_client = None
+
+
+def _get_client():
+    """Cliente Redis/Valkey compartido (perezoso). None si no está disponible."""
+    global _client
+    if redis is None:
+        return None
+    if _client is None:
+        try:
+            _client = redis.Redis.from_url(settings.VALKEY_URL, decode_responses=True)
+        except Exception as exc:
+            logger.warning("session_store_init_failed: %s", exc)
+            return None
+    return _client
+
+
+def _ttl_seconds() -> int:
+    # La sesión en valkey vive como máximo lo que la vida absoluta de la sesión.
+    return settings.SESSION_MAX_HOURS * 3600
+
+
+def create_session(access_token: str, refresh_token: str, session_start: int) -> Optional[str]:
+    """Crea una sesión con los tokens KC y devuelve el session_id (o None si Valkey no está)."""
+    client = _get_client()
+    if client is None:
+        return None
+    session_id = str(uuid.uuid4())
+    data = json.dumps({
+        "access_token": access_token,
+        "refresh_token": refresh_token or "",
+        "sst": int(session_start),
+    })
+    try:
+        client.setex(f"{_KEY_PREFIX}{session_id}", _ttl_seconds(), data)
+        return session_id
+    except Exception as exc:
+        logger.warning("session_store_create_failed: %s", exc)
+        return None
+
+
+def get_session(session_id: str) -> Optional[dict]:
+    """Devuelve {access_token, refresh_token, sst} de la sesión, o None."""
+    client = _get_client()
+    if client is None or not session_id:
+        return None
+    try:
+        raw = client.get(f"{_KEY_PREFIX}{session_id}")
+        return json.loads(raw) if raw else None
+    except Exception as exc:
+        logger.warning("session_store_get_failed: %s", exc)
+        return None
+
+
+def update_session_tokens(session_id: str, access_token: str, refresh_token: str) -> None:
+    """Actualiza los tokens KC de una sesión existente conservando su TTL y su sst."""
+    client = _get_client()
+    if client is None or not session_id:
+        return
+    try:
+        key = f"{_KEY_PREFIX}{session_id}"
+        ttl = client.ttl(key)
+        if ttl and ttl > 0:
+            existing = client.get(key)
+            sst = json.loads(existing).get("sst") if existing else None
+            data = json.dumps({
+                "access_token": access_token,
+                "refresh_token": refresh_token or "",
+                "sst": sst,
+            })
+            client.setex(key, ttl, data)
+    except Exception as exc:
+        logger.warning("session_store_update_failed: %s", exc)
+
+
+def delete_session(session_id: str) -> None:
+    """Elimina la sesión (logout). Fail-silent."""
+    client = _get_client()
+    if client is None or not session_id:
+        return
+    try:
+        client.delete(f"{_KEY_PREFIX}{session_id}")
+    except Exception as exc:
+        logger.warning("session_store_delete_failed: %s", exc)

backend/tests/test_local_session.py

@@ -0,0 +1,74 @@
+"""
+Pruebas de la sesión local del CRM (patrón SIWEB) — core.local_session.
+
+Lógica pura (firma HS256 + claims); no requiere BD ni valkey.
+"""
+
+from datetime import datetime, timezone
+
+from jose import jwt
+
+from core.config import settings
+from core.local_session import mint_session_token, verify_session_token, session_start_of
+
+
+def _now() -> int:
+    return int(datetime.now(timezone.utc).timestamp())
+
+
+def test_round_trip_conserva_identidad():
+    claims = {
+        "sub": "kc-user-123",
+        "email": "user@example.com",
+        "tenant_id": 11,
+        "tenant_slug": "aduanasoft",
+        "is_hub_admin": True,
+    }
+    token = mint_session_token(claims)
+    out = verify_session_token(token)
+
+    assert out is not None
+    assert out["sub"] == "kc-user-123"
+    assert out["tenant_id"] == 11
+    assert out["tenant_slug"] == "aduanasoft"
+    assert out["is_hub_admin"] is True
+    assert out["source"] == "local"
+    assert out["crm_session"] is True
+    assert isinstance(out["sst"], int)
+
+
+def test_cap_absoluto_rechaza_sesion_vieja():
+    # session_start más allá del cap absoluto → verify debe rechazar aunque no expiró por idle.
+    old_start = _now() - (settings.SESSION_MAX_HOURS * 3600 + 120)
+    token = mint_session_token({"sub": "x"}, session_start=old_start)
+    assert verify_session_token(token) is None
+
+
+def test_preserva_session_start():
+    start = _now() - 60
+    token = mint_session_token({"sub": "x"}, session_start=start)
+    out = verify_session_token(token)
+    assert out is not None
+    assert session_start_of(out) == start
+
+
+def test_firma_alterada_se_rechaza():
+    token = mint_session_token({"sub": "x"})
+    # Alterar el último carácter de la firma invalida el token.
+    tampered = token[:-1] + ("A" if token[-1] != "A" else "B")
+    assert verify_session_token(tampered) is None
+
+
+def test_token_no_crm_se_rechaza():
+    # Un HS256 válido pero SIN los marcadores de sesión local no debe aceptarse.
+    other = jwt.encode(
+        {"sub": "x", "exp": _now() + 600},
+        settings.SECRET_KEY,
+        algorithm="HS256",
+    )
+    assert verify_session_token(other) is None
+
+
+def test_token_basura_se_rechaza():
+    assert verify_session_token("no-es-un-jwt") is None
+    assert verify_session_token("") is None

deploy/RUNBOOK-produccion.md

@@ -0,0 +1,162 @@
+# Runbook — Despliegue a PRODUCCIÓN · CRM Agente de Carga
+
+> **Quién ejecuta:** un operador con acceso al servidor de producción y a la base de
+> datos de prod. **Este runbook no lo ejecuta ningún agente automático.**
+> **Prerrequisito de proceso:** el PR de `feature/crm-workspace-altas-org-usuario`
+> debe estar **revisado y mergeado** a la rama que corresponda antes de desplegar.
+>
+> **Antes de empezar: respaldo.** Toma un backup de la base `crm_core` de prod
+> (`pg_dump`) y del `.env` actual. Sin respaldo verificado, no continúes.
+
+Este cambio es grande (auth/RBAC): login 100% vía Workspace/Hub, **sesión local
+(patrón SIWEB)**, gestión de compañías/usuarios/roles y provisión vía Hub. Léelo
+completo antes de tocar prod.
+
+---
+
+## 0. Alcance del cambio
+
+- **Auth:** el login deja de hablar directo con Keycloak; todo pasa por el Hub
+  (App Launcher → `/auth/sso?relay=<uuid>` → `POST {HUB_URL}/api/v1/auth/sso-exchange`).
+- **Sesión local:** cookie de sesión propia (HS256) + token KC guardado en **valkey**
+  por `crm_sid`. Requiere valkey arriba. Se controla con `SESSION_STORE_ENABLED`.
+- **RBAC/Compañías:** compañías en `a76.company` por tenant; roles por carril
+  (Ventas, Operaciones, Facturación, Consulta); permisos por módulo.
+
+**Migraciones de esquema:** este set **no** agrega tablas nuevas (usa `core.*`,
+`a76.company` y valkey). Aun así, **verifica migraciones pendientes** en prod antes
+de desplegar (paso 5). No corras migraciones a ciegas.
+
+---
+
+## 1. Prerrequisitos de infraestructura
+
+- [ ] DNS de prod (p. ej. `crm.aduanasoft.com`) apuntando al server de prod.
+- [ ] Docker + Docker Compose en el server.
+- [ ] Servicios del stack: `backend`, `frontend`, `postgres`, `valkey`, `minio`,
+      `celery_worker`, `celery_beat`.
+- [ ] **valkey** operativo (lo usan la sesión local y `hub_token`).
+- [ ] nginx + TLS (certbot) para servir app + API en el **mismo origen**.
+- [ ] Acceso al **Hub de producción** (no el de testing) y al client/realm correctos.
+
+---
+
+## 2. Variables de entorno (`.env` en el server de prod)
+
+Basado en `deploy/env.testing.example`, pero con **hosts, dominio y secretos de
+producción**. Nunca subas el `.env` con secretos al repo.
+
+```env
+# --- Seguridad ---
+ENVIRONMENT=production
+DEV_LOCAL_AUTH=false
+SECRET_KEY=<openssl rand -hex 32>
+
+# --- Sesión local (patrón SIWEB) ---
+SESSION_STORE_ENABLED=true
+SESSION_IDLE_MINUTES=30
+SESSION_MAX_HOURS=10
+VALKEY_URL=redis://valkey:6379/0
+
+# --- Workspace / Hub de PRODUCCIÓN (mismo Hub que genera el relay) ---
+WORKSPACE_URL=https://<hub-produccion>
+HUB_URL=https://<hub-produccion>
+INTERNAL_HUB_URL=https://<hub-produccion>
+VITE_HUB_URL=https://<hub-produccion>
+
+# --- Keycloak (single-realm / single-client) ---
+KEYCLOAK_URL=https://<keycloak-produccion>/kcauth
+VITE_KEYCLOAK_URL=https://<keycloak-produccion>/kcauth
+KEYCLOAK_REALM=master
+KEYCLOAK_CLIENT_ID=aduanasoft
+KEYCLOAK_CLIENT_SECRET=<secret del producto provisionado en prod>
+
+# --- Dominio del CRM (mismo origen app + API vía nginx) ---
+ORIGIN=https://<dominio-crm-produccion>
+APP_PUBLIC_URL=https://<dominio-crm-produccion>
+VITE_API_URL=https://<dominio-crm-produccion>/api/
+INTERNAL_API_URL=http://backend:8000/api/
+CORS_ORIGINS=https://<dominio-crm-produccion>
+
+# --- PostgreSQL ---
+CORE_DB_HOST=postgres
+CORE_DB_PORT=5432
+CORE_DB_NAME=crm_core
+CORE_DB_USER=<usuario>
+POSTGRES_APP_PASSWORD=<password fuerte>
+
+# --- MinIO / S3 ---
+S3_ENDPOINT_URL=http://minio:9000
+S3_ACCESS_KEY=<access>
+S3_SECRET_KEY=<secret>
+S3_BUCKET=crm
+S3_REGION=us-east-1
+S3_USE_SSL=false
+```
+
+> **Importante:** `ENVIRONMENT=production` hace que el bootstrap de permisos solo dé
+> `super_admin` al **primer** usuario (no a todos). Es el comportamiento deseado en prod.
+
+---
+
+## 3. Build del frontend — **en CI, no en el server**
+
+La VM de prod no debe compilar el frontend (el build satura RAM). Compila la imagen
+en **Jenkins/CI** y publícala al registry, o compílala en una máquina de build:
+
+```bash
+docker compose -f docker-compose.yml -f docker-compose.prod.yml build frontend
+# push al registry interno si aplica
+```
+
+El backend usa la imagen/código directamente (uvicorn sin --reload).
+
+---
+
+## 4. Despliegue
+
+```bash
+# En el server de prod, en el directorio del proyecto:
+docker compose -f docker-compose.yml -f docker-compose.prod.yml pull        # si usas registry
+docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
+docker compose ps            # verifica que todos queden healthy
+```
+
+---
+
+## 5. Post-despliegue (datos) — **operador humano, con respaldo hecho**
+
+1. **Verificar migraciones pendientes** (si el proyecto usa Alembic u otro):
+   revisar y aplicar **solo** las que correspondan, con backup previo.
+2. **Seed base** (compañía por tenant + carriles), equivalente a `seed_crm.py`
+   (`ensure_company` + roles Ventas/Operaciones/Facturación/Consulta).
+3. **Sync de permisos** (registra el catálogo por módulo):
+
+```bash
+docker compose exec backend python -c "from api.v1.modules.core.permissions.service import PermissionService; from core.database import CoreSessionLocal; PermissionService(CoreSessionLocal()).sync_permissions()"
+```
+
+---
+
+## 6. Verificación / smoke test
+
+```bash
+curl -fsS https://<dominio-crm-produccion>/api/health && echo OK
+```
+
+- [ ] Login vía **App Launcher del Workspace** entra sin bucle.
+- [ ] El dashboard carga compañías del tenant (switcher con el tenant correcto).
+- [ ] **Usuarios**: lista carga tras refrescar; alta por invitación crea enlace.
+- [ ] **Roles y permisos**: catálogo por módulo carga; marcar un permiso lo guarda
+      (toast) y persiste al refrescar.
+- [ ] Licencia válida (sin bucle 401 / "sesión expirada").
+
+---
+
+## 7. Rollback
+
+1. `docker compose ... up -d` con la **imagen/tag anterior** del frontend/backend.
+2. Restaurar `.env` anterior si se cambió.
+3. Restaurar el backup de `crm_core` **solo** si hubo cambios de datos irreversibles.
+4. `SESSION_STORE_ENABLED=false` revierte al comportamiento previo de sesión sin
+   redeploy de código (feature-flag), como mitigación rápida.

deploy/docker-compose.testing.yml

@@ -5,11 +5,26 @@
 #   docker compose -f docker-compose.yml -f deploy/docker-compose.testing.yml up -d --build
 services:
   backend:
+    # DNS por-contenedor: el resolver del host no es alcanzable desde los contenedores;
+    # el backend debe resolver workspace.aduanasoft.com (Hub) en runtime.
+    dns:
+      - "8.8.8.8"
+      - "1.1.1.1"
     ports: !override
       - "127.0.0.1:8000:8000"
+    # Sesión local del CRM (patrón SIWEB). El backend toma su config de esta lista
+    # (no lee el .env dentro del contenedor), así que los flags van aquí. Valores
+    # desde el .env por sustitución. SESSION_STORE_ENABLED=false revierte al comportamiento previo.
+    environment:
+      - SESSION_STORE_ENABLED=${SESSION_STORE_ENABLED:-true}
+      - SESSION_IDLE_MINUTES=${SESSION_IDLE_MINUTES:-30}
+      - SESSION_MAX_HOURS=${SESSION_MAX_HOURS:-10}
     command: ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--log-level", "info"]
 
   frontend:
+    dns:
+      - "8.8.8.8"
+      - "1.1.1.1"
     build:
       context: ./frontend
       dockerfile: Dockerfile.prod
@@ -21,8 +36,11 @@ services:
         VITE_KEYCLOAK_CLIENT_ID: ${KEYCLOAK_CLIENT_ID:-aduanasoft}
     environment:
       - NODE_ENV=production
+      # El callback OIDC (/auth/callback) intercambia el código por tokens con el
+      # secret del client confidencial 'aduanasoft'. El compose base no lo pasa al frontend.
+      - KEYCLOAK_CLIENT_SECRET=${KEYCLOAK_CLIENT_SECRET:-}
     volumes: !override []
-    command: !override ["pnpm", "start"]
+    command: !override ["node", "build/index.js"]
     ports: !override
       - "127.0.0.1:5173:5173"
 
@@ -31,3 +49,10 @@ services:
 
   minio:
     ports: !override []
+
+# En el server no existe el Hub local: app-hub deja de ser red externa y se crea local.
+# El CRM alcanza el Hub por su URL pública (workspace.aduanasoft.com), no por esta red.
+networks:
+  app-hub:
+    external: false
+    driver: bridge

deploy/nginx/testing.crm.aduanasoft.com.conf

@@ -29,9 +29,8 @@ server {
 
 # ---- HTTPS ----
 server {
-    listen 443 ssl;
-    listen [::]:443 ssl;
-    http2 on;
+    listen 443 ssl http2;
+    listen [::]:443 ssl http2;
     server_name testing.crm.aduanasoft.com;
 
     ssl_certificate     /etc/letsencrypt/live/testing.crm.aduanasoft.com/fullchain.pem;
@@ -50,6 +49,13 @@ server {
     # Subida de documentos (máx. 25 MB en la app) + margen
     client_max_body_size 30m;
 
+    # Buffers grandes para headers de respuesta: /auth/sso setea el JWT (fragmentado
+    # si supera ~4KB) + refresh/id_token/tenant como cookies → el header excede el
+    # buffer default de nginx (evita "upstream sent too big header" → 502).
+    proxy_buffer_size 32k;
+    proxy_buffers 16 32k;
+    proxy_busy_buffers_size 64k;
+
     gzip on;
     gzip_types text/plain text/css application/javascript application/json image/svg+xml;
     gzip_min_length 1024;

frontend/Dockerfile.prod

@@ -38,6 +38,9 @@ ENV INTERNAL_API_URL=${INTERNAL_API_URL}
 # Copiar el resto del código
 COPY . .
 
+# Subir el límite de heap de Node para el build (VM chico → evita OOM en vite build)
+ENV NODE_OPTIONS="--max-old-space-size=3072"
+
 # Construir el proyecto
 RUN pnpm run build
 
@@ -49,10 +52,8 @@ FROM node:22-alpine AS runtime
 
 WORKDIR /app
 
-RUN apk add --no-cache wget
-
-RUN npm config set strict-ssl false && \
-    npm install -g pnpm
+# Runtime SIN dependencias de red (redes restringidas): busybox ya trae wget y
+# se arranca con node directo (sin pnpm), así el runtime no toca apk/npm.
 
 # Crear usuario no-root para seguridad antes de copiar con --chown
 RUN addgroup -g 1001 -S nodejs
@@ -85,5 +86,5 @@ ENV INTERNAL_API_URL=http://backend:8000/api/
 
 ENTRYPOINT ["/entrypoint.sh"]
 
-# Ejecutar aplicación con Node.js
-CMD ["pnpm", "start"]
+# Ejecutar aplicación con Node.js (adapter-node, sin pnpm)
+CMD ["node", "build/index.js"]

frontend/src/lib/api/crm/catalogs.ts

@@ -0,0 +1,63 @@
+/**
+ * Cliente API — Catálogos de referencia del CRM (SAT/ISO + del cliente).
+ * T2026-07-081/082.
+ */
+import { api, type ApiResponse } from '$lib/api';
+
+export interface CatalogItem {
+	id: number;
+	catalog: string;
+	code: string;
+	label: string;
+	parent_catalog?: string | null;
+	parent_code?: string | null;
+	tenant_id: number | null;
+	sort_order: number;
+	is_active: boolean;
+	is_system: boolean;
+}
+
+export interface CatalogMeta {
+	catalog: string;
+	label: string;
+	scope: 'global' | 'tenant';
+	is_system: boolean;
+	count: number;
+}
+
+export interface CatalogItemInput {
+	code: string;
+	label: string;
+	parent_catalog?: string | null;
+	parent_code?: string | null;
+	sort_order?: number;
+	is_active?: boolean;
+}
+
+function qp(companyId: number, extra?: Record<string, string | number | boolean | undefined>) {
+	const qs = new URLSearchParams({ company_id: String(companyId) });
+	for (const [k, v] of Object.entries(extra ?? {})) if (v !== undefined && v !== '') qs.set(k, String(v));
+	return qs.toString();
+}
+async function unwrap<T>(p: Promise<{ data?: T; error?: string }>): Promise<T> {
+	const res = await p;
+	if (res.error) throw new Error(res.error);
+	return res.data as T;
+}
+
+export const referenceCatalogsAPI = {
+	/** Metadata de todos los catálogos (para la pantalla de administración). */
+	meta: (companyId: number) => unwrap<CatalogMeta[]>(api.get(`/v1/crm/catalogs?${qp(companyId)}`)),
+	/** Opciones activas de un catálogo (global + del tenant), con dependiente opcional. */
+	list: (catalog: string, companyId: number, parentCode?: string) =>
+		unwrap<CatalogItem[]>(api.get(`/v1/crm/catalogs/${catalog}?${qp(companyId, { parent_code: parentCode })}`)),
+	/** Todas las opciones incluyendo inactivas (administración). */
+	listAll: (catalog: string, companyId: number) =>
+		unwrap<CatalogItem[]>(api.get(`/v1/crm/catalogs/${catalog}?${qp(companyId, { include_inactive: true })}`)),
+	create: (catalog: string, companyId: number, data: CatalogItemInput, scope: 'tenant' | 'global' = 'tenant') =>
+		api.post(`/v1/crm/catalogs/${catalog}?${qp(companyId, { scope })}`, data) as Promise<ApiResponse<CatalogItem>>,
+	update: (catalog: string, id: number, companyId: number, data: Partial<CatalogItemInput>) =>
+		api.patch(`/v1/crm/catalogs/${catalog}/${id}?${qp(companyId)}`, data) as Promise<ApiResponse<CatalogItem>>,
+	remove: (catalog: string, id: number, companyId: number) =>
+		api.delete(`/v1/crm/catalogs/${catalog}/${id}?${qp(companyId)}`) as Promise<ApiResponse<void>>
+};

frontend/src/lib/api/crm/types.ts

@@ -24,10 +24,12 @@ export interface Account {
 	status: AccountStatus;
 	commercial_classification: string | null;
 	preferred_contact_method: string | null;
+	preferred_contact_other: string | null;
 	language: string | null;
 	email: string | null;
 	phone: string | null;
 	website: string | null;
+	commercial_observations: string | null;
 	tax_regime: string | null;
 	cfdi_use: string | null;
 	payment_method: string | null;
@@ -66,6 +68,7 @@ export interface Supplier {
 	person_type: string | null;
 	status: AccountStatus;
 	classifications: string[];
+	classification_other: string | null;
 	services_offered: string | null;
 	coverage: string | null;
 	countries: string[];

frontend/src/lib/api/dashboard/admin/permissions.ts

@@ -57,7 +57,9 @@ export const permissionsAPI = {
 		if (params?.action) queryParams.set('action', params.action);
 		if (params?.search) queryParams.set('search', params.search);
 		const query = queryParams.toString();
-		const response = await api.get(`/v1/core/permissions/${query ? '?' + query : ''}`);
+		// Sin slash final: la ruta backend es @router.get("") = /v1/core/permissions.
+		// Con slash FastAPI responde 307 y el cliente server-side no lo sigue.
+		const response = await api.get(`/v1/core/permissions${query ? '?' + query : ''}`);
 		return response.data;
 	},
 
@@ -65,7 +67,7 @@ export const permissionsAPI = {
 	 * Obtener un permiso por ID
 	 */
 	async getById(id: number): Promise<Permission> {
-		const response = await api.get(`/v1/core/permissions/${id}/`);
+		const response = await api.get(`/v1/core/permissions/${id}`);
 		return response.data;
 	},
 
@@ -73,7 +75,7 @@ export const permissionsAPI = {
 	 * Crear un nuevo permiso
 	 */
 	async create(data: CreatePermissionData): Promise<Permission> {
-		const response = await api.post('/v1/core/permissions/', data);
+		const response = await api.post('/v1/core/permissions', data);
 		return response.data;
 	},
 
@@ -81,7 +83,7 @@ export const permissionsAPI = {
 	 * Actualizar un permiso
 	 */
 	async update(id: number, data: UpdatePermissionData): Promise<Permission> {
-		const response = await api.put(`/v1/core/permissions/${id}/`, data);
+		const response = await api.put(`/v1/core/permissions/${id}`, data);
 		return response.data;
 	},
 
@@ -89,14 +91,14 @@ export const permissionsAPI = {
 	 * Eliminar un permiso
 	 */
 	async delete(id: number): Promise<void> {
-		await api.delete(`/v1/core/permissions/${id}/`);
+		await api.delete(`/v1/core/permissions/${id}`);
 	},
 
 	/**
 	 * Obtener módulos únicos
 	 */
 	async getModules(): Promise<string[]> {
-		const response = await api.get('/v1/core/permissions/modules/');
+		const response = await api.get('/v1/core/permissions/modules');
 		return response.data;
 	},
 
@@ -104,7 +106,7 @@ export const permissionsAPI = {
 	 * Obtener acciones únicas
 	 */
 	async getActions(): Promise<string[]> {
-		const response = await api.get('/v1/core/permissions/actions/');
+		const response = await api.get('/v1/core/permissions/actions');
 		return response.data;
 	}
 };

frontend/src/lib/api/dashboard/admin/role-permissions.ts

@@ -48,7 +48,11 @@ export const rolePermissionsAPI = {
 		companyId: number,
 		data: AssignPermissionData
 	): Promise<RolePermission> {
-		const response = await api.post(`/v1/core/permissions/roles/${roleId}/permissions?company_id=${companyId}`, data);
+		// El backend recibe permission_id como query param (no en el body).
+		const response = await api.post(
+			`/v1/core/permissions/roles/${roleId}/permissions?permission_id=${data.permission_id}&company_id=${companyId}`,
+			{}
+		);
 		return response.data;
 	},
 

frontend/src/lib/auth.ts

@@ -407,10 +407,12 @@ export const initAuth = async (): Promise<boolean> => {
 			return true;
 		}
 
-		// Sin token local, intentar Keycloak JS (flujo SSO)
-		const authenticated = await initKeycloak();
+		// Sin token local: no hay sesión en el cliente. El login entra SIEMPRE por
+		// el App Launcher del Workspace (relay → /auth/sso → Hub /sso-exchange);
+		// el CRM NO inicializa Keycloak en el browser. Si no hay token, el layout
+		// del servidor reenvía al Workspace.
 		authStore.setLoading(false);
-		return authenticated;
+		return false;
 	} catch (err) {
 		console.error('[auth] Error en initAuth:', err);
 		authStore.setLoading(false);

frontend/src/lib/components/crm/AccountFields.svelte

@@ -1,15 +1,23 @@
 <script lang="ts">
+	import { onMount } from 'svelte';
 	import type { AccountInput } from '$lib/api/crm';
-	import {
-		ACCOUNT_TYPES, ACCOUNT_STATUS, RECORD_TYPES, PERSON_TYPES,
-		COMMERCIAL_CLASSIFICATION, CONTACT_METHODS
-	} from '$lib/components/crm/format';
+	import { ACCOUNT_TYPES } from '$lib/components/crm/format';
+	import { crmCatalogs } from '$lib/stores/crm-catalogs.svelte';
 
 	// `form` es un objeto reactivo del padre; se mutan sus propiedades vía bind:value.
 	let { form = $bindable(), tab }: { form: AccountInput; tab: string } = $props();
 
 	const inputCls =
 		'rounded-md border bg-transparent px-3 py-2 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring';
+
+	// Catálogos que usa este formulario (se precargan; los selects se llenan solos).
+	onMount(() => {
+		void crmCatalogs.preload([
+			'tipo_registro', 'tipo_persona', 'estatus', 'giro', 'clasificacion_cliente',
+			'medio_contacto', 'idioma', 'regimen_fiscal', 'uso_cfdi', 'metodo_pago',
+			'forma_pago', 'moneda'
+		]);
+	});
 </script>
 
 {#if tab === 'generales'}
@@ -18,28 +26,32 @@
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Nombre comercial</span><input class={inputCls} bind:value={form.trade_name} /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">RFC</span><input class="font-mono {inputCls}" maxlength="13" bind:value={form.rfc} /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">CURP</span><input class="font-mono {inputCls}" maxlength="18" bind:value={form.curp} /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Tipo de registro</span><select class={inputCls} bind:value={form.record_type}>{#each RECORD_TYPES as r (r.value)}<option value={r.value}>{r.label}</option>{/each}</select></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Tipo de persona</span><select class={inputCls} bind:value={form.person_type}><option value={undefined}>—</option>{#each PERSON_TYPES as p (p.value)}<option value={p.value}>{p.label}</option>{/each}</select></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Giro / Industria</span><input class={inputCls} bind:value={form.industry} /></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Tipo de registro</span><select class={inputCls} bind:value={form.record_type}>{#each crmCatalogs.options('tipo_registro') as r (r.value)}<option value={r.value}>{r.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Tipo de persona</span><select class={inputCls} bind:value={form.person_type}><option value={undefined}>—</option>{#each crmCatalogs.options('tipo_persona') as p (p.value)}<option value={p.value}>{p.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Giro / Industria</span><select class={inputCls} bind:value={form.industry}><option value={undefined}>—</option>{#each crmCatalogs.options('giro') as g (g.value)}<option value={g.value}>{g.label}</option>{/each}</select></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Tipo operativo</span><select class={inputCls} bind:value={form.account_type}><option value={undefined}>—</option>{#each ACCOUNT_TYPES as t (t.value)}<option value={t.value}>{t.label}</option>{/each}</select></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Estatus</span><select class={inputCls} bind:value={form.status}>{#each ACCOUNT_STATUS as s (s.value)}<option value={s.value}>{s.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Estatus</span><select class={inputCls} bind:value={form.status}>{#each crmCatalogs.options('estatus') as s (s.value)}<option value={s.value}>{s.label}</option>{/each}</select></label>
 	</div>
 {:else if tab === 'comercial'}
 	<div class="grid gap-4 sm:grid-cols-2">
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Clasificación</span><select class={inputCls} bind:value={form.commercial_classification}><option value={undefined}>—</option>{#each COMMERCIAL_CLASSIFICATION as c (c.value)}<option value={c.value}>{c.label}</option>{/each}</select></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Medio de contacto preferido</span><select class={inputCls} bind:value={form.preferred_contact_method}><option value={undefined}>—</option>{#each CONTACT_METHODS as m (m.value)}<option value={m.value}>{m.label}</option>{/each}</select></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Idioma</span><input class={inputCls} bind:value={form.language} /></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Clasificación del cliente</span><select class={inputCls} bind:value={form.commercial_classification}><option value={undefined}>—</option>{#each crmCatalogs.options('clasificacion_cliente') as c (c.value)}<option value={c.value}>{c.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Medio de contacto preferido</span><select class={inputCls} bind:value={form.preferred_contact_method}><option value={undefined}>—</option>{#each crmCatalogs.options('medio_contacto') as m (m.value)}<option value={m.value}>{m.label}</option>{/each}</select></label>
+		{#if form.preferred_contact_method === 'otro'}
+			<label class="flex flex-col gap-1 text-sm sm:col-span-2"><span class="font-medium">Especifica el medio de contacto</span><input class={inputCls} bind:value={form.preferred_contact_other} placeholder="Indica cuál" /></label>
+		{/if}
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Idioma</span><select class={inputCls} bind:value={form.language}><option value={undefined}>—</option>{#each crmCatalogs.options('idioma') as i (i.value)}<option value={i.value}>{i.label}</option>{/each}</select></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Email</span><input type="email" class={inputCls} bind:value={form.email} /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Teléfono</span><input class={inputCls} bind:value={form.phone} /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Sitio web</span><input class={inputCls} bind:value={form.website} /></label>
+		<label class="flex flex-col gap-1 text-sm sm:col-span-2"><span class="font-medium">Observaciones generales</span><textarea rows="3" class={inputCls} bind:value={form.commercial_observations}></textarea></label>
 	</div>
 {:else if tab === 'fiscal'}
 	<div class="grid gap-4 sm:grid-cols-2">
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Régimen fiscal</span><input class={inputCls} bind:value={form.tax_regime} /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Uso de CFDI</span><input class={inputCls} bind:value={form.cfdi_use} /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Método de pago</span><input class={inputCls} bind:value={form.payment_method} /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Forma de pago</span><input class={inputCls} bind:value={form.payment_form} /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Moneda</span><input class={inputCls} maxlength="3" bind:value={form.currency} /></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Régimen fiscal</span><select class={inputCls} bind:value={form.tax_regime}><option value={undefined}>—</option>{#each crmCatalogs.options('regimen_fiscal') as r (r.value)}<option value={r.value}>{r.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Uso de CFDI</span><select class={inputCls} bind:value={form.cfdi_use}><option value={undefined}>—</option>{#each crmCatalogs.options('uso_cfdi') as u (u.value)}<option value={u.value}>{u.value} — {u.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Método de pago</span><select class={inputCls} bind:value={form.payment_method}><option value={undefined}>—</option>{#each crmCatalogs.options('metodo_pago') as m (m.value)}<option value={m.value}>{m.value} — {m.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Forma de pago</span><select class={inputCls} bind:value={form.payment_form}><option value={undefined}>—</option>{#each crmCatalogs.options('forma_pago') as f (f.value)}<option value={f.value}>{f.value} — {f.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Moneda</span><select class={inputCls} bind:value={form.currency}><option value={undefined}>—</option>{#each crmCatalogs.options('moneda') as c (c.value)}<option value={c.value}>{c.value} — {c.label}</option>{/each}</select></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Límite de crédito</span><input type="number" min="0" step="0.01" class={inputCls} bind:value={form.credit_limit} /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Días de crédito</span><input type="number" min="0" class={inputCls} bind:value={form.credit_days} /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Patente aduanal</span><input class={inputCls} maxlength="20" bind:value={form.patente_aduanal} /></label>
@@ -47,7 +59,7 @@
 	</div>
 {:else if tab === 'observaciones'}
 	<div class="grid gap-4 sm:grid-cols-2">
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Comentarios</span><textarea rows="4" class={inputCls} bind:value={form.notes}></textarea></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Comentarios generales</span><textarea rows="4" class={inputCls} bind:value={form.notes}></textarea></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Notas internas</span><textarea rows="4" class={inputCls} bind:value={form.internal_notes}></textarea></label>
 	</div>
 {/if}

frontend/src/lib/components/crm/RelatedManager.svelte

@@ -8,10 +8,16 @@
 		addressesAPI, contactsAPI, documentsAPI,
 		type Address, type Contact, type Document, type AddressInput, type ContactInput, type DocumentInput
 	} from '$lib/api/crm';
-	import { ADDRESS_TYPES, DOC_TYPES, CONTACT_AREAS, labelOf } from '$lib/components/crm/format';
+	import { DOC_TYPES, labelOf } from '$lib/components/crm/format';
+	import { crmCatalogs } from '$lib/stores/crm-catalogs.svelte';
+	import { onMount } from 'svelte';
 	import { uploadFile, uploadUrl } from '$lib/api/uploads';
 	import { toast } from 'svelte-sonner';
 
+	onMount(() => {
+		void crmCatalogs.preload(['tipo_domicilio', 'area', 'pais']);
+	});
+
 	// Dueño de los registros relacionados y qué sección mostrar
 	let {
 		ownerType,
@@ -31,7 +37,7 @@
 	let activeModal = $state<'address' | 'contact' | 'document' | null>(null);
 	let saving = $state(false);
 
-	let addressForm = $state<AddressInput>({ address_type: 'fiscal', country: 'MX', is_primary: false });
+	let addressForm = $state<AddressInput>({ address_type: 'fiscal', country: 'MEX', is_primary: false });
 	let contactForm = $state<ContactInput>({ first_name: '' });
 	let documentForm = $state<DocumentInput>({ doc_type: 'constancia_fiscal', name: '' });
 	let uploading = $state(false);
@@ -70,6 +76,11 @@
 		if (companyId && ownerId) void load(companyId);
 	});
 
+	// Estado depende del país seleccionado (catálogo dependiente)
+	$effect(() => {
+		if (addressForm.country) void crmCatalogs.ensure('estado', addressForm.country);
+	});
+
 	async function load(cid: number) {
 		try {
 			[addresses, contacts, documents] = await Promise.all([
@@ -83,7 +94,7 @@
 	}
 
 	function openModal(kind: 'address' | 'contact' | 'document') {
-		if (kind === 'address') addressForm = { address_type: 'fiscal', country: 'MX', is_primary: false };
+		if (kind === 'address') addressForm = { address_type: 'fiscal', country: 'MEX', is_primary: false };
 		if (kind === 'contact') contactForm = { first_name: '' };
 		if (kind === 'document') documentForm = { doc_type: 'constancia_fiscal', name: '' };
 		activeModal = kind;
@@ -174,7 +185,7 @@
 						<Table.Body>
 							{#each addresses as a (a.id)}
 								<Table.Row>
-									<Table.Cell>{labelOf(ADDRESS_TYPES, a.address_type)}{#if a.is_primary}<span class="ml-1 text-[10px] text-primary">(principal)</span>{/if}</Table.Cell>
+									<Table.Cell>{crmCatalogs.label('tipo_domicilio', a.address_type)}{#if a.is_primary}<span class="ml-1 text-[10px] text-primary">(principal)</span>{/if}</Table.Cell>
 									<Table.Cell class="text-sm">{[a.street, a.ext_number, a.neighborhood].filter(Boolean).join(' ') || '—'}</Table.Cell>
 									<Table.Cell>{a.postal_code ?? '—'}</Table.Cell>
 									<Table.Cell>{[a.city, a.state].filter(Boolean).join(', ') || '—'}</Table.Cell>
@@ -204,7 +215,7 @@
 							{#each contacts as c (c.id)}
 								<Table.Row>
 									<Table.Cell class="font-medium">{c.first_name} {c.last_name ?? ''}{#if c.is_primary}<span class="ml-1 text-[10px] text-primary">(principal)</span>{/if}</Table.Cell>
-									<Table.Cell class="text-sm">{[c.job_title, labelOf(CONTACT_AREAS, c.area) !== '—' ? labelOf(CONTACT_AREAS, c.area) : null].filter(Boolean).join(' · ') || '—'}</Table.Cell>
+									<Table.Cell class="text-sm">{[c.job_title, c.area ? crmCatalogs.label('area', c.area) : null].filter(Boolean).join(' · ') || '—'}</Table.Cell>
 									<Table.Cell>{c.email ?? '—'}</Table.Cell>
 									<Table.Cell>{c.phone ?? c.mobile ?? '—'}</Table.Cell>
 									<Table.Cell class="text-right"><Button variant="ghost" size="sm" onclick={() => removeContact(c)} aria-label="Eliminar"><Trash2 class="h-4 w-4 text-destructive" /></Button></Table.Cell>
@@ -252,15 +263,15 @@
 			{#if activeModal === 'address'}
 				<h3 class="mb-4 text-base font-semibold">Nueva dirección</h3>
 				<form class="grid gap-3 sm:grid-cols-2" onsubmit={saveAddress}>
-					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Tipo</span><select class={inputCls} bind:value={addressForm.address_type}>{#each ADDRESS_TYPES as t (t.value)}<option value={t.value}>{t.label}</option>{/each}</select></label>
+					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Tipo de domicilio</span><select class={inputCls} bind:value={addressForm.address_type}>{#each crmCatalogs.options('tipo_domicilio') as t (t.value)}<option value={t.value}>{t.label}</option>{/each}</select></label>
 					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Código Postal</span><input class={inputCls} maxlength="10" bind:value={addressForm.postal_code} /></label>
 					<label class="flex flex-col gap-1 text-sm sm:col-span-2"><span class="font-medium">Calle</span><input class={inputCls} bind:value={addressForm.street} /></label>
 					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Núm. exterior</span><input class={inputCls} bind:value={addressForm.ext_number} /></label>
 					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Núm. interior</span><input class={inputCls} bind:value={addressForm.int_number} /></label>
 					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Colonia</span><input class={inputCls} bind:value={addressForm.neighborhood} /></label>
-					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Municipio</span><input class={inputCls} bind:value={addressForm.city} /></label>
-					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Estado</span><input class={inputCls} bind:value={addressForm.state} /></label>
-					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">País</span><input class={inputCls} maxlength="2" bind:value={addressForm.country} /></label>
+					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Municipio / Ciudad</span><input class={inputCls} bind:value={addressForm.city} /></label>
+					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Estado</span>{#if crmCatalogs.options('estado', addressForm.country).length > 0}<select class={inputCls} bind:value={addressForm.state}><option value={undefined}>—</option>{#each crmCatalogs.options('estado', addressForm.country) as s (s.value)}<option value={s.value}>{s.label}</option>{/each}</select>{:else}<input class={inputCls} bind:value={addressForm.state} placeholder="Estado / provincia" />{/if}</label>
+					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">País</span><select class={inputCls} bind:value={addressForm.country}><option value={undefined}>—</option>{#each crmCatalogs.options('pais') as p (p.value)}<option value={p.value}>{p.label}</option>{/each}</select></label>
 					<label class="flex flex-col gap-1 text-sm sm:col-span-2"><span class="font-medium">Referencias</span><textarea rows="2" class={inputCls} bind:value={addressForm.reference_notes}></textarea></label>
 					<label class="flex items-center gap-2 text-sm sm:col-span-2"><input type="checkbox" class="h-4 w-4 rounded border" bind:checked={addressForm.is_primary} /><span>Domicilio principal</span></label>
 					<div class="flex justify-end gap-2 sm:col-span-2"><Button type="button" variant="outline" onclick={() => (activeModal = null)}>Cancelar</Button><Button type="submit" disabled={saving}>Guardar</Button></div>
@@ -271,7 +282,7 @@
 					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Nombre *</span><input class={inputCls} bind:value={contactForm.first_name} required /></label>
 					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Apellidos</span><input class={inputCls} bind:value={contactForm.last_name} /></label>
 					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Puesto</span><input class={inputCls} bind:value={contactForm.job_title} /></label>
-					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Área</span><select class={inputCls} bind:value={contactForm.area}><option value={undefined}>—</option>{#each CONTACT_AREAS as a (a.value)}<option value={a.value}>{a.label}</option>{/each}</select></label>
+					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Área / Departamento</span><select class={inputCls} bind:value={contactForm.area}><option value={undefined}>—</option>{#each crmCatalogs.options('area') as a (a.value)}<option value={a.value}>{a.label}</option>{/each}</select></label>
 					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Email</span><input type="email" class={inputCls} bind:value={contactForm.email} /></label>
 					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Teléfono</span><input class={inputCls} bind:value={contactForm.phone} /></label>
 					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Extensión</span><input class={inputCls} bind:value={contactForm.extension} /></label>

frontend/src/lib/components/crm/SupplierFields.svelte

@@ -1,6 +1,7 @@
 <script lang="ts">
+	import { onMount } from 'svelte';
 	import type { SupplierInput } from '$lib/api/crm';
-	import { SUPPLIER_CLASSIFICATIONS, COVERAGE, ACCOUNT_STATUS, PERSON_TYPES } from '$lib/components/crm/format';
+	import { crmCatalogs } from '$lib/stores/crm-catalogs.svelte';
 
 	// listas separadas por coma también son bindables (el padre las convierte a arreglo)
 	let {
@@ -21,6 +22,15 @@
 
 	const inputCls =
 		'rounded-md border bg-transparent px-3 py-2 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring';
+
+	const hasOtro = $derived((form.classifications ?? []).includes('otro'));
+
+	onMount(() => {
+		void crmCatalogs.preload([
+			'tipo_persona', 'estatus', 'clasificacion_proveedor', 'cobertura', 'moneda',
+			'regimen_fiscal', 'metodo_pago', 'forma_pago'
+		]);
+	});
 </script>
 
 {#if tab === 'generales'}
@@ -28,25 +38,28 @@
 		<label class="flex flex-col gap-1 text-sm sm:col-span-2"><span class="font-medium">Razón social *</span><input class={inputCls} bind:value={form.name} required /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Nombre comercial</span><input class={inputCls} bind:value={form.trade_name} /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">RFC</span><input class="font-mono {inputCls}" maxlength="13" bind:value={form.rfc} /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Tipo de persona</span><select class={inputCls} bind:value={form.person_type}><option value={undefined}>—</option>{#each PERSON_TYPES as p (p.value)}<option value={p.value}>{p.label}</option>{/each}</select></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Estatus</span><select class={inputCls} bind:value={form.status}>{#each ACCOUNT_STATUS as s (s.value)}<option value={s.value}>{s.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Tipo de persona</span><select class={inputCls} bind:value={form.person_type}><option value={undefined}>—</option>{#each crmCatalogs.options('tipo_persona') as p (p.value)}<option value={p.value}>{p.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Estatus</span><select class={inputCls} bind:value={form.status}>{#each crmCatalogs.options('estatus') as s (s.value)}<option value={s.value}>{s.label}</option>{/each}</select></label>
 	</div>
 	<div class="mt-4">
-		<p class="mb-2 text-sm font-medium">Clasificación (una o varias)</p>
+		<p class="mb-2 text-sm font-medium">Clasificación del proveedor (una o varias)</p>
 		<div class="grid grid-cols-2 gap-2 sm:grid-cols-3">
-			{#each SUPPLIER_CLASSIFICATIONS as c (c.value)}
+			{#each crmCatalogs.options('clasificacion_proveedor') as c (c.value)}
 				<label class="flex items-center gap-2 text-sm"><input type="checkbox" class="h-4 w-4 rounded border" value={c.value} bind:group={form.classifications} /><span>{c.label}</span></label>
 			{/each}
 		</div>
+		{#if hasOtro}
+			<label class="mt-3 flex max-w-md flex-col gap-1 text-sm"><span class="font-medium">Especifica la clasificación "Otro"</span><input class={inputCls} bind:value={form.classification_other} placeholder="Indica cuál" /></label>
+		{/if}
 	</div>
 {:else if tab === 'comercial'}
 	<div class="grid gap-4 sm:grid-cols-2">
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Cobertura</span><select class={inputCls} bind:value={form.coverage}><option value={undefined}>—</option>{#each COVERAGE as c (c.value)}<option value={c.value}>{c.label}</option>{/each}</select></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Moneda de cotización</span><input class={inputCls} maxlength="3" bind:value={form.quote_currency} /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Países (separados por coma)</span><input class={inputCls} bind:value={countriesStr} placeholder="MX, US, PA" /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Puertos</span><input class={inputCls} bind:value={portsStr} placeholder="Veracruz, Manzanillo" /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Aeropuertos</span><input class={inputCls} bind:value={airportsStr} /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Aduanas</span><input class={inputCls} bind:value={customsStr} placeholder="Nuevo Laredo, Colombia" /></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Cobertura</span><select class={inputCls} bind:value={form.coverage}><option value={undefined}>—</option>{#each crmCatalogs.options('cobertura') as c (c.value)}<option value={c.value}>{c.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Moneda de cotización</span><select class={inputCls} bind:value={form.quote_currency}><option value={undefined}>—</option>{#each crmCatalogs.options('moneda') as m (m.value)}<option value={m.value}>{m.value} — {m.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Países donde opera (separados por coma)</span><input class={inputCls} bind:value={countriesStr} placeholder="México, Estados Unidos" /></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Puertos donde opera</span><input class={inputCls} bind:value={portsStr} placeholder="Veracruz, Manzanillo" /></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Aeropuertos donde opera</span><input class={inputCls} bind:value={airportsStr} /></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Aduanas donde opera</span><input class={inputCls} bind:value={customsStr} placeholder="Nuevo Laredo, Colombia" /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Horario de atención</span><input class={inputCls} bind:value={form.business_hours} /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Tiempo prom. de respuesta</span><input class={inputCls} bind:value={form.avg_response_time} /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Email</span><input type="email" class={inputCls} bind:value={form.email} /></label>
@@ -56,16 +69,16 @@
 	</div>
 {:else if tab === 'fiscal'}
 	<div class="grid gap-4 sm:grid-cols-2">
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Régimen fiscal</span><input class={inputCls} bind:value={form.tax_regime} /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Método de pago</span><input class={inputCls} bind:value={form.payment_method} /></label>
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Forma de pago</span><input class={inputCls} bind:value={form.payment_form} /></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Régimen fiscal</span><select class={inputCls} bind:value={form.tax_regime}><option value={undefined}>—</option>{#each crmCatalogs.options('regimen_fiscal') as r (r.value)}<option value={r.value}>{r.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Método de pago</span><select class={inputCls} bind:value={form.payment_method}><option value={undefined}>—</option>{#each crmCatalogs.options('metodo_pago') as m (m.value)}<option value={m.value}>{m.value} — {m.label}</option>{/each}</select></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Forma de pago</span><select class={inputCls} bind:value={form.payment_form}><option value={undefined}>—</option>{#each crmCatalogs.options('forma_pago') as f (f.value)}<option value={f.value}>{f.value} — {f.label}</option>{/each}</select></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Límite de crédito</span><input type="number" min="0" step="0.01" class={inputCls} bind:value={form.credit_limit} /></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Días de crédito</span><input type="number" min="0" class={inputCls} bind:value={form.credit_days} /></label>
 		<label class="flex flex-col gap-1 text-sm sm:col-span-2"><span class="font-medium">Condiciones comerciales</span><textarea rows="3" class={inputCls} bind:value={form.commercial_terms}></textarea></label>
 	</div>
 {:else if tab === 'observaciones'}
 	<div class="grid gap-4 sm:grid-cols-2">
-		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Comentarios</span><textarea rows="4" class={inputCls} bind:value={form.notes}></textarea></label>
+		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Comentarios generales</span><textarea rows="4" class={inputCls} bind:value={form.notes}></textarea></label>
 		<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Notas internas</span><textarea rows="4" class={inputCls} bind:value={form.internal_notes}></textarea></label>
 	</div>
 {/if}

frontend/src/lib/components/crm/format.ts

@@ -43,7 +43,7 @@ export const ACCOUNT_STATUS: Option[] = [
 export const COMMERCIAL_CLASSIFICATION: Option[] = [
 	{ value: 'importador', label: 'Importador' },
 	{ value: 'exportador', label: 'Exportador' },
-	{ value: 'ambos', label: 'Importador / Exportador' }
+	{ value: 'importador_exportador', label: 'Importador / Exportador' }
 ];
 
 export const ACCOUNT_TYPES: Option[] = [
@@ -58,7 +58,7 @@ export const ACCOUNT_TYPES: Option[] = [
 export const CONTACT_METHODS: Option[] = [
 	{ value: 'llamada', label: 'Llamada telefónica' },
 	{ value: 'correo', label: 'Correo electrónico' },
-	{ value: 'videollamada', label: 'Videoconferencia' },
+	{ value: 'videoconferencia', label: 'Videoconferencia' },
 	{ value: 'whatsapp', label: 'WhatsApp' },
 	{ value: 'otro', label: 'Otro' }
 ];

frontend/src/lib/components/sidebar/modules.ts

@@ -6,6 +6,7 @@ import {
 	Briefcase,
 	Ship,
 	Receipt,
+	Building,
 } from '@lucide/svelte';
 
 export type SystemContext = 'fixed_asset' | 'inventory';
@@ -51,6 +52,7 @@ export function getNavMain(): NavMainItem[] {
 				{ title: 'Prospectos (embudo)', url: '/dashboard/crm/prospectos' },
 				{ title: 'Oportunidades', url: '/dashboard/crm/oportunidades' },
 				{ title: 'Actividades', url: '/dashboard/crm/actividades' },
+				{ title: 'Catálogos', url: '/dashboard/crm/catalogos' },
 			],
 		},
 		{
@@ -69,6 +71,11 @@ export function getNavMain(): NavMainItem[] {
 				{ title: 'Facturas y cobranza', url: '/dashboard/fin/facturas' },
 			],
 		},
+		{
+			title: 'Compañías',
+			url: '/dashboard/companias',
+			icon: Building,
+		},
 		{
 			title: 'Usuarios',
 			url: '/dashboard/users',

frontend/src/lib/components/sidebar/team-switcher.svelte

@@ -145,9 +145,18 @@
 			>
 				<DropdownMenu.Label class="text-xs text-muted-foreground">Tenant</DropdownMenu.Label>
 				{#if userTenants.length === 0}
-					<DropdownMenu.Item disabled class="gap-2 p-2">
-						<span class="text-muted-foreground">Sin tenant asignado</span>
-					</DropdownMenu.Item>
+					{#if companyStore.activeCompany?.tenant_name}
+							<DropdownMenu.Item disabled class="gap-2 p-2">
+								<div class="flex size-6 items-center justify-center rounded-md border bg-muted">
+									<BuildingIcon class="size-3.5" />
+								</div>
+								<span class="truncate font-medium">{companyStore.activeCompany.tenant_name}</span>
+							</DropdownMenu.Item>
+						{:else}
+							<DropdownMenu.Item disabled class="gap-2 p-2">
+								<span class="text-muted-foreground">Sin tenant asignado</span>
+							</DropdownMenu.Item>
+						{/if}
 				{:else}
 					{#each userTenants as tenant (tenant.id)}
 						<DropdownMenu.Item

frontend/src/lib/server/api.ts

@@ -82,6 +82,60 @@ export function clearAuthTokens(cookies: Cookies) {
 	cookies.delete('id_token', { path: '/' });
 	cookies.delete('active_company_id', { path: '/' });
 	cookies.delete('active_system', { path: '/' });
+	// Sesión local del CRM (patrón SIWEB)
+	cookies.delete('kc_access_token', { path: '/' });
+	cookies.delete('crm_sid', { path: '/' });
+}
+
+/**
+ * Token de Keycloak para llamadas DIRECTAS al Hub (my-apps, my-tenants,
+ * provisioning). Con el patrón de sesión local (SIWEB) el `access_token` guarda
+ * la sesión local del CRM, así que el token KC vive en su propia cookie
+ * `kc_access_token`. Fallback a `access_token` cuando el patrón está apagado
+ * (kc_access_token ausente) → comportamiento histórico intacto.
+ */
+export function getKcAccessToken(cookies: Cookies): string | null {
+	return cookies.get('kc_access_token') ?? getAccessTokenFromCookies(cookies);
+}
+
+/**
+ * Aplica a las cookies la respuesta de /v1/auth/refresh considerando la sesión
+ * local del CRM (patrón SIWEB):
+ *  - Con `session_token`: `access_token` = sesión local (bearer de la app),
+ *    `kc_access_token` = token KC (para el Hub), `crm_sid` = id de sesión valkey.
+ *  - Sin él: comportamiento histórico (`access_token` = token KC).
+ * Devuelve el token que la app debe usar para reintentar (la sesión local si aplica).
+ */
+export function applyRefreshedTokens(
+	cookies: Cookies,
+	data: { access_token?: string; refresh_token?: string; session_token?: string; session_id?: string }
+): string | null {
+	const secure = isSecureContext();
+	if (data.session_token) {
+		setAccessTokenCookies(cookies, data.session_token, { secure, maxAge: 60 * 60 * 24 * 7 });
+		// access_token KC vacío = fallback sin token fresco → conservar el actual.
+		if (data.access_token) {
+			cookies.set('kc_access_token', data.access_token, {
+				path: '/', httpOnly: true, sameSite: 'lax', secure, maxAge: 60 * 60 * 24 * 7
+			});
+		}
+		if (data.session_id) {
+			cookies.set('crm_sid', data.session_id, {
+				path: '/', httpOnly: true, sameSite: 'lax', secure, maxAge: 60 * 60 * 24 * 30
+			});
+		}
+		if (data.refresh_token) {
+			cookies.set('refresh_token', data.refresh_token, {
+				path: '/', httpOnly: true, sameSite: 'lax', secure, maxAge: 60 * 60 * 24 * 30
+			});
+		}
+		return data.session_token;
+	}
+	if (data.access_token) {
+		setAuthTokens(cookies, data.access_token, data.refresh_token);
+		return data.access_token;
+	}
+	return null;
 }
 
 /**
@@ -113,12 +167,21 @@ export async function refreshAccessToken(
 
 	try {
 		const baseUrl = getServerApiUrl();
+		// Sesión local actual del CRM (patrón SIWEB): se envía para preservar el
+		// inicio de sesión (cap absoluto) y permitir el re-emitido de fallback
+		// cuando el refresh del token KC contra el Hub falla.
+		const currentSession = getAccessTokenFromCookies(cookies);
+		const sessionId = cookies.get('crm_sid');
 		const response = await fetch(`${baseUrl}v1/auth/refresh`, {
 			method: 'POST',
 			headers: {
 				'Content-Type': 'application/json'
 			},
-			body: JSON.stringify({ refresh_token: refreshToken })
+			body: JSON.stringify({
+				refresh_token: refreshToken,
+				...(currentSession ? { session_token: currentSession } : {}),
+				...(sessionId ? { session_id: sessionId } : {})
+			})
 		});
 
 		if (!response.ok) {
@@ -127,10 +190,8 @@ export async function refreshAccessToken(
 
 		const data = await response.json();
 
-		// Actualizar las cookies con los nuevos tokens
-		setAuthTokens(cookies, data.access_token, data.refresh_token);
-
-		return data.access_token;
+		// Actualiza las cookies teniendo en cuenta la sesión local (o histórico si no aplica).
+		return applyRefreshedTokens(cookies, data);
 	} catch (error) {
 		console.error('🔄 [API] Error al refrescar token:', error);
 		return null;

frontend/src/lib/server/workspace-auth.ts

@@ -5,9 +5,14 @@ const DEFAULT_WORKSPACE_BASE_URL = 'https://workspace.aduanasoft.com';
 const RETURN_PATH_COOKIE = 'workspace_return_path';
 
 /**
- * Returns true only when the public-facing URL uses HTTPS.
- * Use this for cookie `secure` flag instead of NODE_ENV so that
- * cookies work on HTTP LAN dev environments (e.g. 192.168.x.x).
+ * Autenticación 100% vía el Hub/Workspace (patrón SIWEB). El CRM NUNCA habla
+ * directo a Keycloak: el login entra por el App Launcher del workspace (relay
+ * → /auth/sso → Hub /sso-exchange) y el resto de auth va por la API del Hub.
+ */
+
+/**
+ * True solo cuando la URL pública usa HTTPS. Se usa para el flag `secure` de las
+ * cookies (en vez de NODE_ENV) para que funcionen en dev HTTP LAN (192.168.x.x).
  */
 export function isSecureContext(): boolean {
 	const origin = (env.ORIGIN || process.env.ORIGIN || '').trim();
@@ -20,9 +25,8 @@ function stripTrailingSlashes(value: string): string {
 }
 
 /**
- * Detecta si una URL apunta a un host que solo es accesible localmente:
- * localhost, 127.0.0.1, IPs de red LAN/privada y hostnames internos de Docker.
- * Estas URLs no son válidas como redirect_uri ni como KC public URL en producción.
+ * Detecta URLs solo accesibles localmente (localhost, IPs LAN/privadas, hosts
+ * internos de Docker). No son válidas como URL pública del Workspace.
  */
 function isDevOnlyUrl(rawUrl: string): boolean {
 	try {
@@ -60,27 +64,14 @@ export function getWorkspaceBaseUrl(): string {
 }
 
 /**
- * Normaliza la URL base del sistema (Mi Aplicación) para construir redirect_uri seguros.
- *
- * Problema habitual en producción: SvelteKit deriva `url.origin` de la variable de entorno
- * `ORIGIN`. Si el contenedor se despliega con `ORIGIN=http://localhost:5173` (valor del .env
- * de dev), todos los redirect_uri generados por el servidor apuntan a localhost.
- *
- * Esta función:
- * 1. Usa `requestOrigin` si ya es una URL pública (no dev-only).
- * 2. Si es localhost, busca `SITE_URL` (env var de producción recomendada) como fallback.
- * 3. Como último recurso devuelve requestOrigin tal cual (entorno dev genuino).
- *
- * Var de entorno recomendada en producción:
- *   SITE_URL=https://mi-app.dominio.com   (además de arreglar ORIGIN)
+ * Normaliza la URL base del sistema (Mi Aplicación) para construir redirect_uri.
+ * Corrige el caso donde `ORIGIN` env var apunta a localhost en producción.
  */
 export function resolveSystemBaseUrl(requestOrigin: string): string {
 	if (!isDevOnlyUrl(requestOrigin)) {
 		return stripTrailingSlashes(requestOrigin);
 	}
 
-	// requestOrigin es dev-only → ORIGIN env var apunta a localhost en producción.
-	// Buscar URL pública en env vars adicionales.
 	const candidates = [
 		(env.SITE_URL || '').trim(),
 		(env.APP_URL || '').trim(),
@@ -93,31 +84,17 @@ export function resolveSystemBaseUrl(requestOrigin: string): string {
 		}
 	}
 
-	// Entorno dev genuino: devolver requestOrigin tal cual
 	return stripTrailingSlashes(requestOrigin);
 }
 
-export type WorkspaceLoginUrlOptions = {
-	/**
-	 * URL del login del Hub sin `return_to`. Usar en `post_logout_redirect_uri` para que,
-	 * tras logout en KC, el Hub aplique myApps() (launcher si el usuario tiene varias apps).
-	 * Con `return_to` a Mi Aplicación, el re-login siempre rebotaba a esa app aunque hubiera más.
-	 */
-	forPostLogout?: boolean;
-};
-
-export function getWorkspaceLoginUrl(
-	systemBaseUrl: string,
-	options?: WorkspaceLoginUrlOptions
-): string {
-	const workspaceBaseUrl = getWorkspaceBaseUrl();
-	if (options?.forPostLogout) {
-		return `${workspaceBaseUrl}/login`;
-	}
-	// return_to includes sso_verified=1 so the workspace preserves it when redirecting
-	// back, regardless of what additional params the workspace appends.
-	const loginUrl = `${systemBaseUrl}/login?sso_verified=1`;
-	return `${workspaceBaseUrl}/login?return_to=${encodeURIComponent(loginUrl)}`;
+/**
+ * URL de login del Workspace. NO lleva `return_to` a Mi Aplicación: el Hub
+ * muestra el App Launcher y el usuario re-entra al CRM por relay
+ * (→ /auth/sso?relay=). Así se evita el rebote a /login sin sesión (bucle) y no
+ * se usa ningún flujo OIDC directo contra Keycloak.
+ */
+export function getWorkspaceLoginUrl(): string {
+	return `${getWorkspaceBaseUrl()}/login`;
 }
 
 export function storeReturnPath(cookies: Cookies, path: string): void {
@@ -131,26 +108,6 @@ export function storeReturnPath(cookies: Cookies, path: string): void {
 	});
 }
 
-export function getPublicKeycloakBaseUrl(): string {
-	const configuredKeycloakUrl = (env.VITE_KEYCLOAK_URL || '').trim();
-	// Si VITE_KEYCLOAK_URL apunta a un host dev-only (localhost, IP LAN, Docker service),
-	// ignorarlo y derivar la URL del hostname público del Workspace.
-	// Esto protege contra builds donde el .env de dev llega a producción por error.
-	if (configuredKeycloakUrl && !isDevOnlyUrl(configuredKeycloakUrl)) {
-		return stripTrailingSlashes(configuredKeycloakUrl);
-	}
-
-	return `${getWorkspaceBaseUrl()}/kcauth`;
-}
-
-export function getKeycloakRealm(): string {
-	return (env.KEYCLOAK_REALM || env.VITE_KEYCLOAK_REALM || 'master').trim();
-}
-
-export function getKeycloakClientId(): string {
-	return (env.KEYCLOAK_CLIENT_ID || env.VITE_KEYCLOAK_CLIENT_ID || 'app-frontend').trim();
-}
-
 export function getCleanReturnPath(url: URL): string {
 	const cleanParams = new URLSearchParams(url.searchParams);
 	cleanParams.delete('sso_verified');
@@ -186,68 +143,9 @@ export function clearWorkspaceReturnPath(cookies: Cookies): void {
 	cookies.delete(RETURN_PATH_COOKIE, { path: '/' });
 }
 
-export function buildKeycloakAuthorizationUrl(systemBaseUrl: string, redirectPath: string): string {
-	const keycloakBaseUrl = getPublicKeycloakBaseUrl();
-	// resolveSystemBaseUrl corrige el caso donde url.origin es localhost por ORIGIN env var mal configurado
-	const publicBase = resolveSystemBaseUrl(systemBaseUrl);
-	const redirectUri = `${publicBase}/auth/callback`;
-	const state = JSON.stringify({ redirect_url: redirectPath });
-	const params = new URLSearchParams({
-		client_id: getKeycloakClientId(),
-		redirect_uri: redirectUri,
-		response_type: 'code',
-		scope: 'openid',
-		prompt: 'none',
-		state
-	});
-
-	return `${keycloakBaseUrl}/realms/${getKeycloakRealm()}/protocol/openid-connect/auth?${params.toString()}`;
-}
-
-/**
- * Construye URL de login directo en KC sin prompt=none.
- * Usa la sesión KC existente si la hay; si no, muestra el form de login.
- * Usar cuando se recibe ?redirect= del Hub (rompe el loop Hub↔login).
- */
-export function buildKeycloakLoginUrl(systemBaseUrl: string, redirectPath: string): string {
-	const keycloakBaseUrl = getPublicKeycloakBaseUrl();
-	// resolveSystemBaseUrl corrige el caso donde url.origin es localhost por ORIGIN env var mal configurado
-	const publicBase = resolveSystemBaseUrl(systemBaseUrl);
-	const redirectUri = `${publicBase}/auth/callback`;
-	const state = JSON.stringify({ redirect_url: redirectPath });
-	const params = new URLSearchParams({
-		client_id: getKeycloakClientId(),
-		redirect_uri: redirectUri,
-		response_type: 'code',
-		scope: 'openid',
-		state
-	});
-
-	return `${keycloakBaseUrl}/realms/${getKeycloakRealm()}/protocol/openid-connect/auth?${params.toString()}`;
-}
-
-export function redirectToWorkspaceLogin(cookies: Cookies, url: URL): never {
-	// Modo local: nunca salir al workspace, mostrar el login local.
-	if ((env.DEV_LOCAL_AUTH ?? '').toLowerCase() === 'true') {
-		throw redirect(303, '/login');
-	}
-	storeWorkspaceReturnPath(cookies, url);
-	throw redirect(303, getWorkspaceLoginUrl(url.origin));
-}
-
-export function redirectToKeycloakAuthorization(systemBaseUrl: string, redirectPath: string): never {
-	throw redirect(303, buildKeycloakAuthorizationUrl(systemBaseUrl, redirectPath));
-}
-
-export function redirectToKeycloakLogin(systemBaseUrl: string, redirectPath: string): never {
-	throw redirect(303, buildKeycloakLoginUrl(systemBaseUrl, redirectPath));
-}
-
 /**
  * URL del Hub FastAPI para llamadas server-to-server (ej. sso-exchange).
  * No aplica isDevOnlyUrl: las URLs internas de Docker son válidas aquí.
- * Lee HUB_BACKEND_URL (override explícito) → INTERNAL_HUB_URL (ya en docker-compose)
- * → fallback a URL pública del workspace (vía proxy SvelteKit del Hub).
  */
 export function getHubBackendUrl(): string {
 	const direct =
@@ -257,19 +155,15 @@ export function getHubBackendUrl(): string {
 	return getWorkspaceBaseUrl();
 }
 
-export function buildKeycloakLogoutUrl(systemBaseUrl: string, idTokenHint?: string): string {
-	const keycloakBaseUrl = getPublicKeycloakBaseUrl();
-	const postLogoutRedirectUri = `${systemBaseUrl}/auth/post-logout`;
-	const params = new URLSearchParams({
-		client_id: getKeycloakClientId(),
-		post_logout_redirect_uri: postLogoutRedirectUri
-	});
-
-	// Con id_token_hint KC acepta cualquier post_logout_redirect_uri sin necesidad
-	// de que esté registrado explícitamente en el cliente.
-	if (idTokenHint) {
-		params.set('id_token_hint', idTokenHint);
+/**
+ * Redirige al login del Workspace (App Launcher). Único punto de entrada de
+ * login: el CRM no inicia ningún flujo contra Keycloak.
+ */
+export function redirectToWorkspaceLogin(cookies: Cookies, url: URL): never {
+	// Modo local: nunca salir al workspace, mostrar el login local.
+	if ((env.DEV_LOCAL_AUTH ?? '').toLowerCase() === 'true') {
+		throw redirect(303, '/login');
 	}
-
-	return `${keycloakBaseUrl}/realms/${getKeycloakRealm()}/protocol/openid-connect/logout?${params.toString()}`;
-}
+	storeWorkspaceReturnPath(cookies, url);
+	throw redirect(303, getWorkspaceLoginUrl());
+}

frontend/src/lib/server/workspace-provision.shared.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest';
+import {
+	slugifyTenantName,
+	validateTenantForm,
+	hubErrorMessage,
+	isForbiddenStatus,
+	TENANT_SLUG_RE
+} from './workspace-provision.shared';
+
+describe('slugifyTenantName', () => {
+	it('convierte nombre con acentos y espacios a slug válido', () => {
+		const slug = slugifyTenantName('Logística Peña & Cía S.A. de C.V.');
+		expect(slug).toBe('logistica-pena-cia-s-a-de-c-v');
+		expect(TENANT_SLUG_RE.test(slug)).toBe(true);
+	});
+
+	it('quita guiones al inicio y al final', () => {
+		expect(slugifyTenantName('  --Hola--  ')).toBe('hola');
+	});
+
+	it('cadena sin caracteres válidos da string vacío', () => {
+		expect(slugifyTenantName('!!!')).toBe('');
+	});
+});
+
+describe('validateTenantForm', () => {
+	it('acepta datos válidos', () => {
+		expect(
+			validateTenantForm({ name: 'Empresa ABC', slug: 'empresa-abc', contact_email: 'a@b.com' })
+		).toBeNull();
+	});
+
+	it('rechaza nombre demasiado corto', () => {
+		expect(
+			validateTenantForm({ name: 'A', slug: 'a-b', contact_email: 'a@b.com' })
+		).toMatch(/al menos 2/);
+	});
+
+	it('rechaza slug con mayúsculas o espacios', () => {
+		expect(
+			validateTenantForm({ name: 'Empresa ABC', slug: 'Empresa ABC', contact_email: 'a@b.com' })
+		).toMatch(/slug/i);
+	});
+
+	it('rechaza email inválido', () => {
+		expect(
+			validateTenantForm({ name: 'Empresa ABC', slug: 'empresa-abc', contact_email: 'no-email' })
+		).toMatch(/email/i);
+	});
+});
+
+describe('hubErrorMessage', () => {
+	it('devuelve el detail string tal cual', () => {
+		expect(hubErrorMessage({ detail: 'Slug ya existe' }, 409)).toBe('Slug ya existe');
+	});
+
+	it('formatea el primer error de validación de Pydantic', () => {
+		const body = { detail: [{ loc: ['body', 'contact_email'], msg: 'value is not a valid email' }] };
+		expect(hubErrorMessage(body, 422)).toBe('contact_email: value is not a valid email');
+	});
+
+	it('mensaje de permisos ante 403 sin detail', () => {
+		expect(hubErrorMessage(null, 403)).toMatch(/permisos/i);
+	});
+
+	it('mensaje genérico con status ante cuerpo desconocido', () => {
+		expect(hubErrorMessage(null, 500)).toMatch(/500/);
+	});
+});
+
+describe('isForbiddenStatus', () => {
+	it('true para 401 y 403', () => {
+		expect(isForbiddenStatus(401)).toBe(true);
+		expect(isForbiddenStatus(403)).toBe(true);
+	});
+	it('false para otros', () => {
+		expect(isForbiddenStatus(422)).toBe(false);
+		expect(isForbiddenStatus(200)).toBe(false);
+	});
+});

frontend/src/lib/server/workspace-provision.shared.ts

@@ -0,0 +1,85 @@
+/**
+ * Helpers puros para el alta de organizaciones/usuarios en el Workspace (Hub).
+ * Sin dependencias de entorno para poder testearse en aislamiento (Vitest).
+ */
+
+// Slug del tenant: mismas reglas que el Hub (TenantCreateDTO.slug → ^[a-z0-9-]+$).
+export const TENANT_SLUG_RE = /^[a-z0-9-]+$/;
+
+// Roles válidos para invitar un usuario. Son los que el Hub reconoce en su
+// flujo de alta (ver ProvisionUserRequestDTO / create_invite). No inventar otros.
+export const WORKSPACE_INVITE_ROLES = ['user', 'admin', 'supervisor', 'operador', 'visor'] as const;
+export type WorkspaceInviteRole = (typeof WORKSPACE_INVITE_ROLES)[number];
+
+/**
+ * Deriva un slug candidato a partir del nombre de la organización:
+ * minúsculas, sin acentos, espacios y símbolos → guiones.
+ */
+export function slugifyTenantName(name: string): string {
+	return name
+		.normalize('NFD')
+		.replace(/[̀-ͯ]/g, '') // quita acentos (marcas combinantes Unicode)
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, '-')
+		.replace(/^-+|-+$/g, '')
+		.slice(0, 100);
+}
+
+export type TenantFormValues = {
+	name: string;
+	slug: string;
+	contact_email: string;
+};
+
+/**
+ * Valida los campos obligatorios del alta de organización antes de llamar al Hub,
+ * para dar feedback inmediato sin gastar un round-trip.
+ * Devuelve un mensaje de error o null si es válido.
+ */
+export function validateTenantForm(values: TenantFormValues): string | null {
+	if (!values.name || values.name.trim().length < 2) {
+		return 'El nombre de la organización debe tener al menos 2 caracteres.';
+	}
+	if (!TENANT_SLUG_RE.test(values.slug)) {
+		return 'El slug solo admite minúsculas, dígitos y guiones (sin espacios ni acentos).';
+	}
+	if (!values.contact_email || !values.contact_email.includes('@')) {
+		return 'El email de contacto es obligatorio y debe ser válido.';
+	}
+	return null;
+}
+
+/**
+ * Extrae un mensaje legible del cuerpo de error de FastAPI (Hub).
+ * - 401/403 → mensaje de permisos.
+ * - detail string → tal cual.
+ * - detail array (422 Pydantic) → "campo: msg" del primer error.
+ * - cualquier otro → mensaje genérico con el status.
+ */
+export function hubErrorMessage(body: unknown, status: number): string {
+	const detail =
+		body && typeof body === 'object' ? (body as { detail?: unknown }).detail : null;
+
+	if (typeof detail === 'string' && detail.trim()) {
+		return detail;
+	}
+
+	if (Array.isArray(detail) && detail.length > 0) {
+		const first = detail[0] as { loc?: unknown[]; msg?: string };
+		const loc = Array.isArray(first.loc) ? first.loc : [];
+		const field = loc.length ? String(loc[loc.length - 1]) : '';
+		const msg = first.msg ?? 'dato inválido';
+		return field ? `${field}: ${msg}` : msg;
+	}
+
+	if (status === 401 || status === 403) {
+		return 'No tienes permisos de administrador en el workspace para esta acción.';
+	}
+
+	return `El workspace respondió con un error (${status}).`;
+}
+
+/** True si el status del Hub indica falta de permisos/sesión. */
+export function isForbiddenStatus(status: number): boolean {
+	return status === 401 || status === 403;
+}

frontend/src/lib/server/workspace-provision.ts

@@ -0,0 +1,126 @@
+/**
+ * Orquestación del Hub (Workspace) para dar de alta ORGANIZACIONES (tenants) y
+ * USUARIOS (invitaciones) desde el CRM.
+ *
+ * Principio de seguridad: SIEMPRE se llama server-side reenviando el token del
+ * usuario autenticado (Bearer). Es el Hub quien valida el permiso —
+ * `hub_admin`/superadmin para tenants, `hub_admin` o `admin` del tenant para
+ * invitaciones. El CRM NO guarda secretos ni hace bypass de autorización.
+ *
+ * Endpoints del Hub (base = getHubBackendUrl()):
+ *   GET  /api/v1/hub/tenants   → lista de organizaciones (solo hub_admin)
+ *   POST /api/v1/hub/tenants   → crea tenant + realm Keycloak (solo hub_admin)
+ *   POST /api/v1/hub/invites   → invitación de un solo uso + email (hub_admin | admin del tenant)
+ */
+
+import { getHubBackendUrl } from '$lib/server/workspace-auth';
+import { hubErrorMessage, isForbiddenStatus } from '$lib/server/workspace-provision.shared';
+
+const HUB_API_PREFIX = '/api/v1/hub';
+
+function hubUrl(path: string): string {
+	return `${getHubBackendUrl()}${HUB_API_PREFIX}${path}`;
+}
+
+export type WorkspaceTenant = {
+	id: number;
+	name: string;
+	slug: string;
+	display_name?: string | null;
+	contact_name?: string | null;
+	contact_email: string;
+	status: string;
+	is_self_hosted: boolean;
+	has_license: boolean;
+	created_at: string;
+};
+
+export type WorkspaceInvite = {
+	id: number;
+	email: string;
+	tenant_slug: string;
+	role: string;
+	invite_url: string;
+	expires_at: string;
+	created_at: string;
+};
+
+export type HubResult<T> =
+	| { ok: true; data: T }
+	| { ok: false; status: number; forbidden: boolean; error: string };
+
+/** Construye el resultado de error a partir de una respuesta no-2xx del Hub. */
+async function toErrorResult<T>(res: Response): Promise<HubResult<T>> {
+	const body = await res.json().catch(() => null);
+	return {
+		ok: false,
+		status: res.status,
+		forbidden: isForbiddenStatus(res.status),
+		error: hubErrorMessage(body, res.status)
+	};
+}
+
+const jsonHeaders = (accessToken: string) => ({
+	Authorization: `Bearer ${accessToken}`,
+	'Content-Type': 'application/json'
+});
+
+/** Lista las organizaciones del workspace. Requiere hub_admin (403 si no). */
+export async function listWorkspaceTenants(
+	accessToken: string,
+	fetch: typeof globalThis.fetch
+): Promise<HubResult<WorkspaceTenant[]>> {
+	const res = await fetch(hubUrl('/tenants'), {
+		headers: { Authorization: `Bearer ${accessToken}` }
+	});
+	if (!res.ok) return toErrorResult<WorkspaceTenant[]>(res);
+	const data = (await res.json()) as { tenants?: WorkspaceTenant[] };
+	return { ok: true, data: Array.isArray(data.tenants) ? data.tenants : [] };
+}
+
+export type CreateTenantInput = {
+	name: string;
+	slug: string;
+	contact_email: string;
+	contact_name?: string;
+	contact_phone?: string;
+	display_name?: string;
+	is_self_hosted: boolean;
+	app_url?: string;
+};
+
+/** Crea una organización (tenant) y provisiona su realm en Keycloak. */
+export async function createWorkspaceTenant(
+	accessToken: string,
+	fetch: typeof globalThis.fetch,
+	input: CreateTenantInput
+): Promise<HubResult<WorkspaceTenant>> {
+	const res = await fetch(hubUrl('/tenants'), {
+		method: 'POST',
+		headers: jsonHeaders(accessToken),
+		body: JSON.stringify(input)
+	});
+	if (!res.ok) return toErrorResult<WorkspaceTenant>(res);
+	return { ok: true, data: (await res.json()) as WorkspaceTenant };
+}
+
+export type CreateInviteInput = {
+	email: string;
+	tenant_slug: string;
+	role: string;
+};
+
+/** Genera una invitación de un solo uso para un usuario en un tenant. */
+export async function createWorkspaceInvite(
+	accessToken: string,
+	fetch: typeof globalThis.fetch,
+	input: CreateInviteInput
+): Promise<HubResult<WorkspaceInvite>> {
+	const res = await fetch(hubUrl('/invites'), {
+		method: 'POST',
+		headers: jsonHeaders(accessToken),
+		body: JSON.stringify(input)
+	});
+	if (!res.ok) return toErrorResult<WorkspaceInvite>(res);
+	return { ok: true, data: (await res.json()) as WorkspaceInvite };
+}

frontend/src/lib/stores/company.svelte.ts

@@ -11,6 +11,8 @@ interface Company {
 	rfc?: string;
 	logo?: string;
 	tenant_id: number;
+	tenant_name?: string;
+	tenant_slug?: string;
 }
 
 class CompanyStore {
@@ -158,7 +160,9 @@ class CompanyStore {
 					headers: {
 						'Content-Type': 'application/json'
 					},
-					body: JSON.stringify({ companyId: company.id }),
+					// tenant_id de la compañía → override para que el backend escale por
+					// ese tenant (necesario cuando el usuario es hub_admin sin tenant en el token).
+					body: JSON.stringify({ companyId: company.id, tenantId: company.tenant_id }),
 					credentials: 'include'
 				});
 			} catch (error) {

frontend/src/lib/stores/crm-catalogs.svelte.ts

@@ -0,0 +1,77 @@
+/**
+ * Store reactivo de catálogos de referencia del CRM.
+ *
+ * Carga desde el backend (/v1/crm/catalogs) y cachea por catálogo. Los
+ * formularios leen `options(catalog)` (reactivo) sin refetch. Los catálogos
+ * dependientes (Estado por País) se piden con `ensure(catalog, parentCode)`.
+ */
+import { referenceCatalogsAPI } from '$lib/api/crm/catalogs';
+import { companyStore } from '$lib/stores/company.svelte';
+import type { Option } from '$lib/components/crm/format';
+
+class CrmCatalogStore {
+	private _cache = $state<Record<string, Option[]>>({});
+	private _pending = new Set<string>();
+	private _companyId: number | null = null;
+
+	/** Toma la compañía activa; si cambió, limpia el caché. Devuelve su id (o null). */
+	private syncCompany(): number | null {
+		const cid = companyStore.activeCompany?.id ?? null;
+		if (cid !== this._companyId) {
+			this._companyId = cid;
+			this._cache = {};
+			this._pending.clear();
+		}
+		return cid;
+	}
+
+	private keyOf(catalog: string, parentCode?: string): string {
+		return parentCode ? `${catalog}:${parentCode}` : catalog;
+	}
+
+	/** Opciones de un catálogo ya cargado (vacío si aún no se ha cargado). */
+	options(catalog: string, parentCode?: string): Option[] {
+		return this._cache[this.keyOf(catalog, parentCode)] ?? [];
+	}
+
+	/** Descripción de una clave (para listados/detalle). */
+	label(catalog: string, code: string | null | undefined): string {
+		if (!code) return '—';
+		return this.options(catalog).find((o) => o.value === code)?.label ?? code;
+	}
+
+	/** Carga un catálogo (con dependiente opcional) si aún no está en caché. */
+	async ensure(catalog: string, parentCode?: string): Promise<void> {
+		const cid = this.syncCompany();
+		const key = this.keyOf(catalog, parentCode);
+		if (cid == null || key in this._cache || this._pending.has(key)) return;
+		this._pending.add(key);
+		try {
+			const items = await referenceCatalogsAPI.list(catalog, cid, parentCode);
+			this._cache[key] = items.map((i) => ({ value: i.code, label: i.label }));
+		} catch {
+			this._cache[key] = [];
+		} finally {
+			this._pending.delete(key);
+		}
+	}
+
+	/** Precarga varios catálogos globales en paralelo. */
+	async preload(catalogs: string[]): Promise<void> {
+		await Promise.all(catalogs.map((c) => this.ensure(c)));
+	}
+
+	/** Invalida el caché de un catálogo (tras editar en administración). */
+	invalidate(catalog?: string): void {
+		if (!catalog) {
+			this._cache = {};
+			return;
+		}
+		for (const k of Object.keys(this._cache)) {
+			if (k === catalog || k.startsWith(`${catalog}:`)) delete this._cache[k];
+		}
+		this._cache = { ...this._cache };
+	}
+}
+
+export const crmCatalogs = new CrmCatalogStore();

frontend/src/routes/api-sveltekit/auth/silent-refresh/+server.ts

@@ -14,8 +14,8 @@
 
 import { json } from '@sveltejs/kit';
 import type { RequestEvent } from '@sveltejs/kit';
-import { getServerApiUrl, setAuthTokens } from '$lib/server/api';
-import { clearAccessTokenCookies } from '$lib/server/access-token-cookie';
+import { getServerApiUrl, applyRefreshedTokens, clearAuthTokens } from '$lib/server/api';
+import { getAccessTokenFromCookies } from '$lib/server/access-token-cookie';
 
 export const POST = async ({ cookies, fetch }: RequestEvent) => {
 	const refreshToken = cookies.get('refresh_token');
@@ -27,34 +27,43 @@ export const POST = async ({ cookies, fetch }: RequestEvent) => {
 	try {
 		const baseUrl = getServerApiUrl();
 
+		// Sesión local actual del CRM (patrón SIWEB): se reenvía para preservar el
+		// inicio de sesión y permitir el re-emitido de fallback cuando el refresh KC falla.
+		const currentSession = getAccessTokenFromCookies(cookies);
+		const sessionId = cookies.get('crm_sid');
+
 		const response = await fetch(`${baseUrl}v1/auth/refresh`, {
 			method: 'POST',
 			headers: { 'Content-Type': 'application/json' },
-			body: JSON.stringify({ refresh_token: refreshToken })
+			body: JSON.stringify({
+				refresh_token: refreshToken,
+				...(currentSession ? { session_token: currentSession } : {}),
+				...(sessionId ? { session_id: sessionId } : {})
+			})
 		});
 
 		if (!response.ok) {
-			// El refresh token expiró o fue invalidado por Keycloak (sesión terminada).
-			// Limpiar las cookies para que el servidor redirigir al login en la siguiente carga.
-			cookies.delete('refresh_token', { path: '/' });
-			clearAccessTokenCookies(cookies);
-			cookies.delete('active_company_id', { path: '/' });
+			// El refresh falló y no hubo sesión local que re-emitir (cap superado o
+			// patrón apagado). Limpiar cookies para que el server redirija al login.
+			clearAuthTokens(cookies);
 
 			const status = response.status === 401 ? 401 : 400;
 			return json({ error: 'Refresh token expired or invalid' }, { status });
 		}
 
 		const data = (await response.json()) as {
-			access_token: string;
+			access_token?: string;
 			refresh_token?: string;
+			session_token?: string;
+			session_id?: string;
 			expires_in?: number;
 		};
 
-		// Actualizar las cookies HttpOnly con los nuevos tokens
-		setAuthTokens(cookies, data.access_token, data.refresh_token);
+		// Actualiza cookies considerando la sesión local; devuelve el bearer de la app.
+		const appToken = applyRefreshedTokens(cookies, data);
 
-		// Devolver solo el access_token al cliente
-		return json({ access_token: data.access_token });
+		// Devolver solo el token de app al cliente (sesión local si aplica, o KC).
+		return json({ access_token: appToken ?? data.access_token ?? '' });
 	} catch (error) {
 		console.error('[silent-refresh] Error inesperado:', error);
 		return json({ error: 'Internal server error' }, { status: 500 });

frontend/src/routes/api-sveltekit/auth/switch-tenant/+server.ts

@@ -9,7 +9,7 @@
 import { json } from '@sveltejs/kit';
 import { env } from '$env/dynamic/private';
 import type { RequestEvent } from '@sveltejs/kit';
-import { getServerApiUrl, getAuthTokens, setAuthTokens } from '$lib/server/api';
+import { getServerApiUrl, getAuthTokens, getKcAccessToken, setAuthTokens } from '$lib/server/api';
 
 export const POST = async ({ request, cookies, fetch }: RequestEvent) => {
 	const body = await request.json();
@@ -28,9 +28,11 @@ export const POST = async ({ request, cookies, fetch }: RequestEvent) => {
 	// Modo SSO relay: validar acceso vía Hub y actualizar cookie de override
 	if (tenant_id) {
 		try {
+			// Validación contra el Hub → token KC (el access_token puede ser la sesión local).
+			const kcToken = getKcAccessToken(cookies) ?? accessToken;
 			const hubUrl = (env.INTERNAL_HUB_URL || env.HUB_URL || 'http://localhost:8001').replace(/\/+$/, '');
 			const tenantsRes = await fetch(`${hubUrl}/api/v1/auth/my-tenants`, {
-				headers: { 'Authorization': `Bearer ${accessToken}` },
+				headers: { 'Authorization': `Bearer ${kcToken}` },
 			});
 			if (!tenantsRes.ok) {
 				return json({ error: 'Could not validate tenant access' }, { status: 403 });

frontend/src/routes/api-sveltekit/company/set-active/+server.ts

@@ -6,22 +6,28 @@ import type { RequestHandler } from './$types';
 
 export const POST: RequestHandler = async ({ cookies, request }) => {
 	try {
-		const { companyId } = await request.json();
+		const body = await request.json();
+		const companyId = body?.companyId;
+		const tenantId = body?.tenantId;
 
 		if (!companyId || typeof companyId !== 'number') {
 			return json({ error: 'Invalid company ID' }, { status: 400 });
 		}
 
-		// Establecer la cookie desde el servidor
-		cookies.set('active_company_id', companyId.toString(), {
-			path: '/',
-			maxAge: 60 * 60 * 24 * 30, // 30 días
-			sameSite: 'lax',
-			httpOnly: false, // Permitir acceso desde JavaScript
-			secure: process.env.NODE_ENV === 'production'
-		});
+		const isProd = process.env.NODE_ENV === 'production';
+		const base = { path: '/', maxAge: 60 * 60 * 24 * 30, sameSite: 'lax' as const, secure: isProd };
 
-		return json({ success: true, companyId });
+		// Compañía activa (legible desde JS)
+		cookies.set('active_company_id', companyId.toString(), { ...base, httpOnly: false });
+
+		// Fijar el tenant de la compañía como override → el backend escala por ese
+		// tenant aunque el token no lo traiga (caso hub_admin operando por compañía).
+		if (typeof tenantId === 'number' && Number.isFinite(tenantId)) {
+			cookies.set('sso_tenant_id', tenantId.toString(), { ...base, httpOnly: true });
+			cookies.set('sso_tenant_pub', tenantId.toString(), { ...base, httpOnly: false });
+		}
+
+		return json({ success: true, companyId, tenantId: tenantId ?? null });
 	} catch (error) {
 		console.error('Error setting active company:', error);
 		return json({ error: 'Internal server error' }, { status: 500 });

frontend/src/routes/auth/callback/+page.server.ts

@@ -1,132 +1,15 @@
-import { redirect, isRedirect } from '@sveltejs/kit';
+import { redirect } from '@sveltejs/kit';
 import type { PageServerLoad } from './$types';
-import { setAccessTokenCookies } from '$lib/server/access-token-cookie';
-import {
-	clearWorkspaceReturnPath,
-	getWorkspaceLoginUrl,
-	readWorkspaceReturnPath,
-	storeReturnPath,
-} from '$lib/server/workspace-auth';
 
-export const load: PageServerLoad = async ({ url, cookies, fetch }) => {
-	// Obtener el código y state de los query params
-	const code = url.searchParams.get('code');
-	const state = url.searchParams.get('state');
-	const errorParam = url.searchParams.get('error');
-	const errorDescription = url.searchParams.get('error_description');
-	
-	if (errorParam) {
-		console.error('❌ [Callback Server] KC auth error:', errorParam, errorDescription);
-		// login_required means no KC session exists yet → send to Workspace login.
-		// Preserve the intended destination through the detour so /login can pick it up.
-		if (state) {
-			try {
-				const stateObj = JSON.parse(state);
-				const returnPath = stateObj.redirect_url;
-				if (returnPath && returnPath.startsWith('/') && returnPath !== '/login') {
-					storeReturnPath(cookies, returnPath);
-				}
-			} catch { /* ignore malformed state */ }
-		}
-		throw redirect(303, getWorkspaceLoginUrl(url.origin));
-	}
-	
-	if (!code) {
-		console.error('❌ [Callback Server] No se recibió código de autorización');
-		throw redirect(303, getWorkspaceLoginUrl(url.origin));
-	}
-	
-	try {
-		// Intercambiar código por tokens usando el backend de Keycloak
-		// En el servidor (SSR), usar KEYCLOAK_URL que apunta a http://keycloak:8080
-		// En producción o fuera de Docker, usar VITE_KEYCLOAK_URL como fallback
-		const KEYCLOAK_URL = process.env.KEYCLOAK_URL || process.env.VITE_KEYCLOAK_URL || 'http://localhost:8080';
-		const KEYCLOAK_REALM = process.env.KEYCLOAK_REALM || process.env.VITE_KEYCLOAK_REALM || 'master';
-		const KEYCLOAK_CLIENT_ID = process.env.KEYCLOAK_CLIENT_ID || process.env.VITE_KEYCLOAK_CLIENT_ID || 'app-backend';
-		const KEYCLOAK_CLIENT_SECRET = process.env.KEYCLOAK_CLIENT_SECRET || '';
-		
-		// La redirect_uri debe coincidir exactamente con la registrada en Keycloak.
-		// resolveSystemBaseUrl corrige el caso donde url.origin es localhost porque
-		// ORIGIN env var apunta a localhost en producción (usa SITE_URL como fallback).
-		const { resolveSystemBaseUrl } = await import('$lib/server/workspace-auth');
-		const redirectUri = `${resolveSystemBaseUrl(url.origin)}/auth/callback`;
-		
-		const tokenEndpoint = `${KEYCLOAK_URL}/realms/${KEYCLOAK_REALM}/protocol/openid-connect/token`;
-		
-		const body = new URLSearchParams({
-			grant_type: 'authorization_code',
-			code: code,
-			redirect_uri: redirectUri,
-			client_id: KEYCLOAK_CLIENT_ID,
-			...(KEYCLOAK_CLIENT_SECRET && { client_secret: KEYCLOAK_CLIENT_SECRET })
-		});
-		
-		const tokenResponse = await fetch(tokenEndpoint, {
-			method: 'POST',
-			headers: {
-				'Content-Type': 'application/x-www-form-urlencoded'
-			},
-			body: body.toString()
-		});
-		
-		if (!tokenResponse.ok) {
-			const errorData = await tokenResponse.text();
-			console.error('❌ [Callback Server] Error al intercambiar código:', errorData);
-			throw new Error('Error al obtener tokens');
-		}
-		
-		const tokens = await tokenResponse.json();
-		
-		// Establecer las cookies en el servidor
-		// access_token → NO HttpOnly (el cliente JS lo usa para el header Authorization)
-		// refresh_token → HttpOnly (el JS nunca lo lee; el servidor lo gestiona)
-		const { isSecureContext } = await import('$lib/server/workspace-auth');
-		const isProduction = isSecureContext();
-		
-		setAccessTokenCookies(cookies, tokens.access_token, {
-			secure: isProduction,
-			maxAge: 60 * 60 * 24 * 7 // 7 días
-		});
-		
-		if (tokens.refresh_token) {
-			cookies.set('refresh_token', tokens.refresh_token, {
-				path: '/',
-				httpOnly: true,    // *** HttpOnly: nunca expuesto a JS ***
-				secure: isProduction,
-				sameSite: 'lax',
-				maxAge: 60 * 60 * 24 * 30 // 30 días
-			});
-		}
-
-		if (tokens.id_token) {
-			cookies.set('id_token', tokens.id_token, {
-				path: '/',
-				httpOnly: true,
-				secure: isProduction,
-				sameSite: 'lax',
-				maxAge: 60 * 60 * 24 * 7
-			});
-		}
-		
-		// Obtener la URL de redirección del state o ir al dashboard
-		let redirectTo = readWorkspaceReturnPath(cookies, '/dashboard');
-		if (state) {
-			try {
-				const stateObj = JSON.parse(state);
-				redirectTo = stateObj.redirect_url || '/dashboard';
-			} catch (e) {
-				console.warn('⚠️ [Callback Server] No se pudo obtener redirect_url del state');
-			}
-		}
-
-		clearWorkspaceReturnPath(cookies);
-		
-		// Redirigir a la página de destino
-		throw redirect(303, redirectTo);
-		
-	} catch (err: any) {
-		if (isRedirect(err)) throw err;
-		console.error('❌ [Callback Server] Error procesando autenticación:', err);
-		throw redirect(303, getWorkspaceLoginUrl(url.origin));
-	}
+/**
+ * Callback OIDC — OBSOLETO.
+ *
+ * El CRM ya no inicia flujo de autorización contra Keycloak: el login entra por
+ * el App Launcher del Workspace (relay → /auth/sso → Hub /sso-exchange). Esta
+ * ruta se conserva solo para no romper enlaces viejos; cualquier acceso se
+ * redirige al dashboard (el layout valida la sesión y, si no hay, reenvía al
+ * Workspace). No se intercambia ningún `code` con Keycloak.
+ */
+export const load: PageServerLoad = async () => {
+	throw redirect(303, '/dashboard');
 };

frontend/src/routes/auth/post-logout/+server.ts

@@ -3,11 +3,10 @@ import type { RequestHandler } from './$types';
 import { getWorkspaceLoginUrl } from '$lib/server/workspace-auth';
 
 /**
- * KC redirects here after completing the logout flow.
- * This URL is covered by the app's registered wildcard in KC (e.g. mi-app.dominio.com/*).
- * We then send the user to workspace login so it can apply myApps() launcher logic.
+ * Ruta de retorno post-logout. El CRM ya no dispara logout contra Keycloak
+ * (el cierre completo se hace desde el Workspace); se conserva por compatibilidad
+ * y redirige al App Launcher del Workspace.
  */
-export const GET: RequestHandler = async ({ request, url }) => {
-	const systemBaseUrl = url.origin;
-	throw redirect(303, getWorkspaceLoginUrl(systemBaseUrl, { forPostLogout: true }));
+export const GET: RequestHandler = async () => {
+	throw redirect(303, getWorkspaceLoginUrl());
 };

frontend/src/routes/auth/sso/+page.server.ts

@@ -134,12 +134,32 @@ export const load: PageServerLoad = async ({ url, cookies }) => {
 	const isProduction = isSecureContext();
 	console.log('[SSO] ORIGIN-based secure context:', isProduction);
 
+	// Sesión local del CRM (patrón SIWEB): si el refresh proactivo devolvió una
+	// sesión local firmada, el access_token guarda ESA sesión (bearer de la app,
+	// sobrevive aunque el refresh KC del Hub falle) y el token KC va a su propia
+	// cookie kc_access_token (solo para llamadas directas al Hub). Si no vino
+	// (flag apagado), comportamiento histórico: access_token = token KC.
+	const sessionToken = typeof tokens.session_token === 'string' ? tokens.session_token : null;
+	const kcAccessToken = tokens.access_token as string;
+
 	// access_token — NO HttpOnly (Bearer desde JS); fragmentado si el JWT supera ~4KB
-	setAccessTokenCookies(cookies, tokens.access_token as string, {
+	setAccessTokenCookies(cookies, sessionToken ?? kcAccessToken, {
 		secure: isProduction,
 		maxAge: 60 * 60 * 24 * 7,
 	});
 
+	if (sessionToken) {
+		// kc_access_token — HttpOnly; solo el server lo usa para llamar al Hub.
+		cookies.set('kc_access_token', kcAccessToken, {
+			path: '/', httpOnly: true, secure: isProduction, sameSite: 'lax', maxAge: 60 * 60 * 24 * 7,
+		});
+		if (typeof tokens.session_id === 'string') {
+			cookies.set('crm_sid', tokens.session_id, {
+				path: '/', httpOnly: true, secure: isProduction, sameSite: 'lax', maxAge: 60 * 60 * 24 * 30,
+			});
+		}
+	}
+
 	// refresh_token — HttpOnly (never exposed to JS)
 	if (typeof tokens.refresh_token === 'string') {
 		cookies.set('refresh_token', tokens.refresh_token, {

frontend/src/routes/dashboard/+layout.server.ts

@@ -3,6 +3,7 @@ import type { LayoutServerLoad } from './$types';
 import {
 	validateAuth,
 	getAuthTokens,
+	getKcAccessToken,
 	getUserCompanies,
 	clearAuthTokens
 } from '$lib/server/api';
@@ -30,12 +31,15 @@ export const load: LayoutServerLoad = async ({ cookies, url, fetch }) => {
 		let myApps: { apps: unknown[]; routing: unknown } = { apps: [], routing: null };
 
 		if (!DEV_LOCAL_AUTH) {
+			// Llamadas DIRECTAS al Hub → token KC (con el patrón de sesión local, el
+			// access_token guarda la sesión local del CRM, no el token de Keycloak).
+			const kcToken = getKcAccessToken(cookies) ?? accessToken;
 			try {
 				const hubUrl = (env.INTERNAL_HUB_URL || env.HUB_URL || 'http://localhost:8001').replace(/\/+$/, '');
 				const tenantOverride = cookies.get('sso_tenant_id');
 				const tenantsRes = await fetch(`${hubUrl}/api/v1/auth/my-tenants`, {
 					headers: {
-						'Authorization': `Bearer ${accessToken}`,
+						'Authorization': `Bearer ${kcToken}`,
 						...(tenantOverride ? { 'X-Tenant-Override': tenantOverride } : {})
 					}
 				});
@@ -46,8 +50,7 @@ export const load: LayoutServerLoad = async ({ cookies, url, fetch }) => {
 				// No bloquear el dashboard si falla la carga de tenants
 			}
 
-			const freshAccessToken = getAuthTokens(cookies).accessToken ?? accessToken;
-			myApps = await fetchMyApps(freshAccessToken, fetch, cookies.get('sso_tenant_id'));
+			myApps = await fetchMyApps(kcToken, fetch, cookies.get('sso_tenant_id'));
 		}
 
 		return {

frontend/src/routes/dashboard/companias/+page.svelte

@@ -0,0 +1,157 @@
+<script lang="ts">
+	import { onMount } from 'svelte';
+	import { Building, Plus } from '@lucide/svelte';
+	import * as Card from '$lib/components/ui/card';
+	import { Button } from '$lib/components/ui/button';
+	import { toast } from 'svelte-sonner';
+	import { api } from '$lib/api';
+	import { companyStore } from '$lib/stores/company.svelte';
+
+	const inputCls =
+		'rounded-md border bg-transparent px-3 py-2 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring';
+
+	type Tenant = { id: number; name: string; slug: string };
+
+	let tenants = $state<Tenant[]>([]);
+	let loading = $state(true);
+	let submitting = $state(false);
+	let name = $state('');
+	let rfc = $state('');
+	let tenantId = $state<number | null>(null);
+
+	const companies = $derived(companyStore.companies);
+
+	onMount(async () => {
+		const res = await api.get<Tenant[]>('/v1/auth/assignable-tenants');
+		if (res.data) {
+			tenants = res.data;
+			if (tenants.length === 1) tenantId = tenants[0].id;
+		}
+		await companyStore.loadCompanies();
+		loading = false;
+	});
+
+	async function createCompany() {
+		if (name.trim().length < 2) {
+			toast.error('El nombre de la compañía es obligatorio');
+			return;
+		}
+		if (!tenantId) {
+			toast.error('Selecciona el tenant al que pertenece');
+			return;
+		}
+		submitting = true;
+		try {
+			const res = await api.post<{ id: number }>('/v1/auth/companies', {
+				name: name.trim(),
+				tenant_id: tenantId,
+				rfc: rfc.trim() || null
+			});
+			if (res.error) {
+				toast.error(res.error);
+				return;
+			}
+			toast.success('Compañía creada');
+			name = '';
+			rfc = '';
+			await companyStore.loadCompanies();
+			// Seleccionarla como activa para poder trabajar de inmediato.
+			const created = res.data?.id
+				? companyStore.companies.find((c) => c.id === res.data!.id)
+				: null;
+			if (created) await companyStore.setActiveCompany(created);
+		} catch (e) {
+			toast.error(e instanceof Error ? e.message : 'No se pudo crear la compañía');
+		} finally {
+			submitting = false;
+		}
+	}
+</script>
+
+<div class="space-y-6">
+	<div>
+		<h1 class="flex items-center gap-2 text-2xl font-bold tracking-tight">
+			<Building class="h-6 w-6" /> Compañías
+		</h1>
+		<p class="mt-1 text-sm text-muted-foreground">
+			Da de alta las empresas del CRM. Cada compañía pertenece a un tenant (organización) del
+			Workspace. Al crear una, quedas asignado como administrador y se selecciona como activa.
+		</p>
+	</div>
+
+	<Card.Root>
+		<Card.Header>
+			<Card.Title class="flex items-center gap-2"><Plus class="h-4 w-4" /> Nueva compañía</Card.Title>
+			<Card.Description>El tenant lo crea el Workspace; aquí eliges bajo cuál registrar la empresa.</Card.Description>
+		</Card.Header>
+		<Card.Content>
+			<div class="grid gap-4 sm:grid-cols-2">
+				<label class="flex flex-col gap-1 text-sm sm:col-span-2">
+					<span class="font-medium">Nombre / Razón social *</span>
+					<input class={inputCls} bind:value={name} />
+				</label>
+				<label class="flex flex-col gap-1 text-sm">
+					<span class="font-medium">RFC</span>
+					<input class="font-mono {inputCls}" maxlength="13" bind:value={rfc} />
+				</label>
+				<label class="flex flex-col gap-1 text-sm">
+					<span class="font-medium">Tenant (Workspace) *</span>
+					<select class={inputCls} bind:value={tenantId}>
+						<option value={null} disabled>Selecciona…</option>
+						{#each tenants as t (t.id)}
+							<option value={t.id}>{t.name} ({t.slug})</option>
+						{/each}
+					</select>
+				</label>
+			</div>
+			<div class="mt-6 flex justify-end border-t pt-4">
+				<Button onclick={createCompany} disabled={submitting}>
+					{submitting ? 'Creando…' : 'Crear compañía'}
+				</Button>
+			</div>
+		</Card.Content>
+	</Card.Root>
+
+	<Card.Root>
+		<Card.Header>
+			<Card.Title>Compañías ({companies.length})</Card.Title>
+			<Card.Description>Empresas a las que tienes acceso.</Card.Description>
+		</Card.Header>
+		<Card.Content>
+			{#if loading}
+				<p class="text-sm text-muted-foreground">Cargando…</p>
+			{:else if companies.length === 0}
+				<p class="text-sm text-muted-foreground">Aún no tienes compañías. Crea una arriba.</p>
+			{:else}
+				<div class="overflow-x-auto">
+					<table class="w-full text-sm">
+						<thead class="text-left text-muted-foreground">
+							<tr class="border-b">
+								<th class="py-2 pr-4 font-medium">Nombre</th>
+								<th class="py-2 pr-4 font-medium">RFC</th>
+								<th class="py-2 pr-4 font-medium">Tenant</th>
+								<th class="py-2 pr-4 font-medium">Activa</th>
+							</tr>
+						</thead>
+						<tbody>
+							{#each companies as c (c.id)}
+								<tr class="border-b last:border-0">
+									<td class="py-2 pr-4">{c.name}</td>
+									<td class="py-2 pr-4 font-mono text-xs">{c.rfc ?? '—'}</td>
+									<td class="py-2 pr-4">{c.tenant_id}</td>
+									<td class="py-2 pr-4">
+										{#if companyStore.activeCompany?.id === c.id}
+											<span class="rounded-full bg-emerald-500/15 px-2 py-0.5 text-xs text-emerald-600">activa</span>
+										{:else}
+											<button class="text-xs text-primary hover:underline" onclick={() => companyStore.setActiveCompany(c)}>usar</button>
+										{/if}
+									</td>
+								</tr>
+							{/each}
+						</tbody>
+					</table>
+				</div>
+			{/if}
+		</Card.Content>
+	</Card.Root>
+</div>

frontend/src/routes/dashboard/crm/catalogos/+page.svelte

@@ -0,0 +1,217 @@
+<script lang="ts">
+	import { Database, Plus, Trash2, Pencil, Check, X, Lock } from '@lucide/svelte';
+	import * as Card from '$lib/components/ui/card';
+	import * as Table from '$lib/components/ui/table';
+	import { Button } from '$lib/components/ui/button';
+	import { companyStore } from '$lib/stores/company.svelte';
+	import { referenceCatalogsAPI, type CatalogItem, type CatalogMeta } from '$lib/api/crm/catalogs';
+	import { crmCatalogs } from '$lib/stores/crm-catalogs.svelte';
+	import { toast } from 'svelte-sonner';
+
+	const companyId = $derived(companyStore.activeCompany?.id ?? null);
+
+	let metas = $state<CatalogMeta[]>([]);
+	let selected = $state<CatalogMeta | null>(null);
+	let items = $state<CatalogItem[]>([]);
+	let loading = $state(false);
+
+	let newCode = $state('');
+	let newLabel = $state('');
+	let adding = $state(false);
+	let editId = $state<number | null>(null);
+	let editLabel = $state('');
+	let editActive = $state(true);
+
+	const inputCls =
+		'rounded-md border bg-transparent px-2 py-1 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring';
+
+	$effect(() => {
+		const cid = companyId;
+		if (cid) void loadMetas(cid);
+	});
+
+	async function loadMetas(cid: number) {
+		try {
+			metas = await referenceCatalogsAPI.meta(cid);
+			if (!selected && metas.length) void selectCatalog(metas[0]);
+		} catch (e) {
+			toast.error(e instanceof Error ? e.message : 'No se pudieron cargar los catálogos');
+		}
+	}
+
+	async function selectCatalog(m: CatalogMeta) {
+		selected = m;
+		editId = null;
+		newCode = '';
+		newLabel = '';
+		if (!companyId) return;
+		loading = true;
+		try {
+			items = await referenceCatalogsAPI.listAll(m.catalog, companyId);
+		} catch (e) {
+			toast.error(e instanceof Error ? e.message : 'No se pudieron cargar las opciones');
+		} finally {
+			loading = false;
+		}
+	}
+
+	async function addItem() {
+		if (!companyId || !selected) return;
+		const code = newCode.trim();
+		const label = newLabel.trim();
+		if (!code || !label) {
+			toast.error('Clave y descripción son obligatorias');
+			return;
+		}
+		adding = true;
+		try {
+			const res = await referenceCatalogsAPI.create(
+				selected.catalog,
+				companyId,
+				{ code, label },
+				selected.scope
+			);
+			if (res.error) {
+				toast.error(res.error);
+				return;
+			}
+			toast.success('Opción agregada');
+			newCode = '';
+			newLabel = '';
+			crmCatalogs.invalidate(selected.catalog);
+			await selectCatalog(selected);
+		} finally {
+			adding = false;
+		}
+	}
+
+	function startEdit(it: CatalogItem) {
+		editId = it.id;
+		editLabel = it.label;
+		editActive = it.is_active;
+	}
+
+	async function saveEdit(it: CatalogItem) {
+		if (!companyId || !selected) return;
+		const res = await referenceCatalogsAPI.update(selected.catalog, it.id, companyId, {
+			label: editLabel.trim() || it.label,
+			is_active: editActive
+		});
+		if (res.error) {
+			toast.error(res.error);
+			return;
+		}
+		toast.success('Opción actualizada');
+		editId = null;
+		crmCatalogs.invalidate(selected.catalog);
+		await selectCatalog(selected);
+	}
+
+	async function del(it: CatalogItem) {
+		if (!companyId || !selected) return;
+		if (!confirm(`¿Eliminar la opción "${it.label}"?`)) return;
+		const res = await referenceCatalogsAPI.remove(selected.catalog, it.id, companyId);
+		if (res.error) {
+			toast.error(res.error);
+			return;
+		}
+		toast.success('Opción eliminada');
+		crmCatalogs.invalidate(selected.catalog);
+		await selectCatalog(selected);
+	}
+</script>
+
+<div class="space-y-6">
+	<div>
+		<h1 class="flex items-center gap-2 text-2xl font-bold tracking-tight"><Database class="h-6 w-6" /> Catálogos</h1>
+		<p class="mt-1 text-sm text-muted-foreground">
+			Administra las opciones de los catálogos del CRM. Los catálogos base del sistema (SAT/ISO) solo se pueden activar/desactivar; los de tu empresa se pueden insertar, editar y borrar.
+		</p>
+	</div>
+
+	{#if !companyId}
+		<Card.Root><Card.Content class="pt-6 text-sm text-muted-foreground">Selecciona una compañía activa.</Card.Content></Card.Root>
+	{:else}
+		<div class="grid gap-6 lg:grid-cols-[260px_1fr]">
+			<Card.Root>
+				<Card.Header><Card.Title class="text-base">Catálogos</Card.Title></Card.Header>
+				<Card.Content class="space-y-1">
+					{#each metas as m (m.catalog)}
+						<button
+							type="button"
+							class="flex w-full items-center justify-between gap-2 rounded-md px-2 py-1.5 text-left text-sm {selected?.catalog === m.catalog ? 'bg-primary/10 text-primary' : 'hover:bg-muted'}"
+							onclick={() => selectCatalog(m)}
+						>
+							<span class="flex items-center gap-1">{#if m.is_system}<Lock class="h-3 w-3 opacity-60" />{/if}{m.label}</span>
+							<span class="text-xs text-muted-foreground">{m.count}</span>
+						</button>
+					{/each}
+				</Card.Content>
+			</Card.Root>
+
+			<Card.Root>
+				<Card.Header>
+					<Card.Title class="text-base">{selected?.label ?? 'Opciones'}</Card.Title>
+					<Card.Description>
+						{#if selected}
+							{selected.scope === 'global' ? 'Catálogo global (Aduanasoft)' : 'Catálogo de tu empresa'} · {selected.count} opciones
+							{#if selected.is_system} · base del sistema (no se borra){/if}
+						{/if}
+					</Card.Description>
+				</Card.Header>
+				<Card.Content>
+					<div class="mb-4 flex flex-wrap items-end gap-2">
+						<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Clave</span><input class="font-mono {inputCls}" bind:value={newCode} placeholder="clave" /></label>
+						<label class="flex flex-1 flex-col gap-1 text-sm"><span class="font-medium">Descripción</span><input class={inputCls} bind:value={newLabel} placeholder="Descripción visible" /></label>
+						<Button size="sm" onclick={addItem} disabled={adding}><Plus class="mr-1 h-4 w-4" /> Agregar</Button>
+					</div>
+
+					{#if loading}
+						<p class="py-6 text-center text-sm text-muted-foreground">Cargando…</p>
+					{:else if items.length === 0}
+						<p class="py-6 text-center text-sm text-muted-foreground">Sin opciones. Agrega la primera arriba.</p>
+					{:else}
+						<div class="overflow-x-auto">
+							<Table.Root>
+								<Table.Header><Table.Row><Table.Head>Clave</Table.Head><Table.Head>Descripción</Table.Head><Table.Head>Origen</Table.Head><Table.Head>Activo</Table.Head><Table.Head class="text-right">Acciones</Table.Head></Table.Row></Table.Header>
+								<Table.Body>
+									{#each items as it (it.id)}
+										<Table.Row>
+											<Table.Cell class="font-mono text-xs">{it.code}</Table.Cell>
+											<Table.Cell>
+												{#if editId === it.id}
+													<input class="{inputCls} w-full" bind:value={editLabel} />
+												{:else}
+													{it.label}
+												{/if}
+											</Table.Cell>
+											<Table.Cell class="text-xs text-muted-foreground">{it.tenant_id === null ? 'Global' : 'Empresa'}{#if it.is_system} · base{/if}</Table.Cell>
+											<Table.Cell>
+												{#if editId === it.id}
+													<input type="checkbox" class="h-4 w-4 rounded border" bind:checked={editActive} />
+												{:else}
+													<span class="inline-flex rounded-full px-2 py-0.5 text-xs {it.is_active ? 'bg-emerald-100 text-emerald-700 dark:bg-emerald-950/40 dark:text-emerald-400' : 'bg-muted text-muted-foreground'}">{it.is_active ? 'Sí' : 'No'}</span>
+												{/if}
+											</Table.Cell>
+											<Table.Cell class="text-right">
+												{#if editId === it.id}
+													<Button variant="ghost" size="sm" onclick={() => saveEdit(it)} aria-label="Guardar"><Check class="h-4 w-4 text-emerald-600" /></Button>
+													<Button variant="ghost" size="sm" onclick={() => (editId = null)} aria-label="Cancelar"><X class="h-4 w-4" /></Button>
+												{:else}
+													<Button variant="ghost" size="sm" onclick={() => startEdit(it)} aria-label="Editar"><Pencil class="h-4 w-4" /></Button>
+													{#if !it.is_system}
+														<Button variant="ghost" size="sm" onclick={() => del(it)} aria-label="Eliminar"><Trash2 class="h-4 w-4 text-destructive" /></Button>
+													{/if}
+												{/if}
+											</Table.Cell>
+										</Table.Row>
+									{/each}
+								</Table.Body>
+							</Table.Root>
+						</div>
+					{/if}
+				</Card.Content>
+			</Card.Root>
+		</div>
+	{/if}
+</div>

frontend/src/routes/dashboard/crm/cuentas/+page.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { Building2, Plus, Trash2, Search, ChevronRight } from '@lucide/svelte';
+	import { Building2, Plus, Trash2, Search, Pencil } from '@lucide/svelte';
 	import * as Card from '$lib/components/ui/card';
 	import * as Table from '$lib/components/ui/table';
 	import { Button } from '$lib/components/ui/button';
@@ -120,8 +120,8 @@
 									<Table.Cell>{labelOf(COMMERCIAL_CLASSIFICATION, a.commercial_classification)}</Table.Cell>
 									<Table.Cell>{labelOf(ACCOUNT_STATUS, a.status)}</Table.Cell>
 									<Table.Cell class="text-right">
-										<Button variant="ghost" size="sm" href={`/dashboard/crm/cuentas/${a.id}`} aria-label="Abrir">
-											<ChevronRight class="h-4 w-4" />
+										<Button variant="ghost" size="sm" href={`/dashboard/crm/cuentas/${a.id}`}>
+											<Pencil class="mr-1 h-4 w-4" /> Editar
 										</Button>
 										<Button variant="ghost" size="sm" onclick={() => remove(a)} aria-label="Eliminar">
 											<Trash2 class="h-4 w-4 text-destructive" />

frontend/src/routes/dashboard/crm/cuentas/[id]/+page.svelte

@@ -7,7 +7,7 @@
 	import RelatedManager from '$lib/components/crm/RelatedManager.svelte';
 	import { companyStore } from '$lib/stores/company.svelte';
 	import { accountsAPI, type Account, type AccountInput } from '$lib/api/crm';
-	import { RECORD_TYPES, ACCOUNT_STATUS, labelOf } from '$lib/components/crm/format';
+	import { RECORD_TYPES, ACCOUNT_STATUS, labelOf, formatDate } from '$lib/components/crm/format';
 	import { toast } from 'svelte-sonner';
 
 	type TabDef = { id: string; label: string; kind: 'info' | 'related'; section?: 'addresses' | 'contacts' | 'documents' };
@@ -86,6 +86,10 @@
 					{labelOf(RECORD_TYPES, account.record_type)} · {labelOf(ACCOUNT_STATUS, account.status)}
 					{#if account.rfc}· <span class="font-mono">{account.rfc}</span>{/if}
 				</p>
+				<p class="mt-1 text-xs text-muted-foreground">
+					ID #{account.id} · Creado {formatDate(account.created_at)}{#if account.created_by} por <span class="font-mono">{account.created_by}</span>{/if}
+					· Últ. actualización {formatDate(account.updated_at)}{#if account.updated_by} por <span class="font-mono">{account.updated_by}</span>{/if}
+				</p>
 			</div>
 		</div>
 

frontend/src/routes/dashboard/crm/proveedores/+page.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { Truck, Plus, Trash2, Search, ChevronRight } from '@lucide/svelte';
+	import { Truck, Plus, Trash2, Search, Pencil } from '@lucide/svelte';
 	import * as Card from '$lib/components/ui/card';
 	import * as Table from '$lib/components/ui/table';
 	import { Button } from '$lib/components/ui/button';
@@ -106,8 +106,8 @@
 									<Table.Cell>{labelOf(COVERAGE, s.coverage)}</Table.Cell>
 									<Table.Cell class="font-mono text-xs">{s.rfc ?? '—'}</Table.Cell>
 									<Table.Cell class="text-right">
-										<Button variant="ghost" size="sm" href={`/dashboard/crm/proveedores/${s.id}`} aria-label="Abrir">
-											<ChevronRight class="h-4 w-4" />
+										<Button variant="ghost" size="sm" href={`/dashboard/crm/proveedores/${s.id}`}>
+											<Pencil class="mr-1 h-4 w-4" /> Editar
 										</Button>
 										<Button variant="ghost" size="sm" onclick={() => remove(s)} aria-label="Eliminar">
 											<Trash2 class="h-4 w-4 text-destructive" />

frontend/src/routes/dashboard/crm/proveedores/[id]/+page.svelte

@@ -7,7 +7,7 @@
 	import RelatedManager from '$lib/components/crm/RelatedManager.svelte';
 	import { companyStore } from '$lib/stores/company.svelte';
 	import { suppliersAPI, type Supplier, type SupplierInput } from '$lib/api/crm';
-	import { COVERAGE, ACCOUNT_STATUS, labelOf } from '$lib/components/crm/format';
+	import { COVERAGE, ACCOUNT_STATUS, labelOf, formatDate } from '$lib/components/crm/format';
 	import { toast } from 'svelte-sonner';
 
 	type TabDef = { id: string; label: string; kind: 'info' | 'related'; section?: 'addresses' | 'contacts' | 'documents' };
@@ -104,7 +104,7 @@
 			</h1>
 			<p class="mt-1 text-sm text-muted-foreground">
 				{labelOf(COVERAGE, supplier.coverage)} · {labelOf(ACCOUNT_STATUS, supplier.status)}
-				{#if supplier.rfc}· <span class="font-mono">{supplier.rfc}</span>{/if}
+				{#if supplier.rfc}· <span class="font-mono">{supplier.rfc}</span>{/if}<br /><span class="text-xs">ID #{supplier.id} · Alta {formatDate(supplier.created_at)}{#if supplier.created_by} por <span class="font-mono">{supplier.created_by}</span>{/if} · Últ. modificación {formatDate(supplier.updated_at)}{#if supplier.updated_by} por <span class="font-mono">{supplier.updated_by}</span>{/if}</span>
 			</p>
 		</div>
 

frontend/src/routes/dashboard/roles/+page.svelte

@@ -1,26 +1,231 @@
 <script lang="ts">
-	import { Shield } from 'lucide-svelte';
+	import { Shield, Plus, Trash2, ChevronRight, ChevronDown } from '@lucide/svelte';
 	import * as Card from '$lib/components/ui/card';
+	import { Button } from '$lib/components/ui/button';
+	import { toast } from 'svelte-sonner';
+	import { companyStore } from '$lib/stores/company.svelte';
+	import { rolesAPI, type CompanyRole } from '$lib/api/dashboard/admin/roles';
+	import { permissionsAPI, type Permission } from '$lib/api/dashboard/admin/permissions';
+	import { rolePermissionsAPI } from '$lib/api/dashboard/admin/role-permissions';
+
+	const inputCls =
+		'rounded-md border bg-transparent px-3 py-2 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring';
+
+	const companyId = $derived(companyStore.activeCompany?.id ?? null);
+
+	let roles = $state<CompanyRole[]>([]);
+	let catalog = $state<Permission[]>([]);
+	let loading = $state(true);
+	let creating = $state(false);
+	let name = $state('');
+	let code = $state('');
+	let description = $state('');
+	let expandedRoleId = $state<number | null>(null);
+	// roleId → Set de permission_id asignados
+	let rolePerms = $state<Record<number, Set<number>>>({});
+	let savingPerm = $state<string | null>(null);
+
+	// Catálogo agrupado por módulo
+	const byModule = $derived.by(() => {
+		const m: Record<string, Permission[]> = {};
+		for (const p of catalog) (m[p.module] ??= []).push(p);
+		return m;
+	});
+
+	function slugify(s: string): string {
+		return s.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+	}
+
+	async function load() {
+		if (!companyId) {
+			loading = false;
+			return;
+		}
+		loading = true;
+		try {
+			const [rRes, pRes] = await Promise.all([
+				rolesAPI.list(companyId, { page_size: 100 }),
+				permissionsAPI.list({ page_size: 1000 })
+			]);
+			roles = rRes.data?.items ?? [];
+			catalog = pRes.items ?? [];
+		} catch {
+			toast.error('No se pudieron cargar roles/permisos');
+		} finally {
+			loading = false;
+		}
+	}
+
+	// Recarga los roles cuando cambia la compañía activa —incluida la hidratación
+	// inicial tras refrescar (en onMount el store aún no tenía compañía, por eso
+	// antes no aparecían hasta re-seleccionarla).
+	$effect(() => {
+		const id = companyId;
+		expandedRoleId = null;
+		rolePerms = {};
+		if (id) {
+			void load();
+		} else {
+			roles = [];
+			loading = false;
+		}
+	});
+
+	async function createRole() {
+		if (!companyId) return;
+		const n = name.trim();
+		if (n.length < 2) {
+			toast.error('El nombre del rol es obligatorio');
+			return;
+		}
+		const c = (code.trim() || slugify(n));
+		creating = true;
+		try {
+			const res = await rolesAPI.create(companyId, { name: n, code: c, description: description.trim() || undefined });
+			if (res.error) {
+				toast.error(res.error);
+				return;
+			}
+			toast.success('Rol creado');
+			name = '';
+			code = '';
+			description = '';
+			await load();
+		} finally {
+			creating = false;
+		}
+	}
+
+	async function delRole(r: CompanyRole) {
+		if (!companyId) return;
+		if (!confirm(`¿Eliminar el rol "${r.name}"?`)) return;
+		const res = await rolesAPI.delete(r.id, companyId);
+		if (res.error) {
+			toast.error(res.error);
+			return;
+		}
+		toast.success('Rol eliminado');
+		await load();
+	}
+
+	async function toggleExpand(r: CompanyRole) {
+		if (expandedRoleId === r.id) {
+			expandedRoleId = null;
+			return;
+		}
+		expandedRoleId = r.id;
+		if (!rolePerms[r.id] && companyId) {
+			try {
+				const resp = await rolePermissionsAPI.listByRole(r.id, companyId);
+				rolePerms = { ...rolePerms, [r.id]: new Set((resp.permissions ?? []).map((p) => p.permission_id)) };
+			} catch {
+				rolePerms = { ...rolePerms, [r.id]: new Set() };
+			}
+		}
+	}
+
+	async function togglePerm(roleId: number, perm: Permission, checked: boolean) {
+		if (!companyId) return;
+		savingPerm = `${roleId}:${perm.id}`;
+		try {
+			if (checked) {
+				await rolePermissionsAPI.assign(roleId, companyId, { permission_id: perm.id });
+				rolePerms[roleId]?.add(perm.id);
+			} else {
+				await rolePermissionsAPI.remove(roleId, perm.id, companyId);
+				rolePerms[roleId]?.delete(perm.id);
+			}
+			rolePerms = { ...rolePerms };
+			toast.success(checked ? 'Permiso agregado' : 'Permiso quitado');
+		} catch (e) {
+			toast.error('No se pudo actualizar el permiso');
+		} finally {
+			savingPerm = null;
+		}
+	}
 </script>
 
 <div class="space-y-6">
 	<div>
-		<h1 class="text-2xl font-bold tracking-tight flex items-center gap-2">
-			<Shield class="h-6 w-6" />
-			Roles y permisos
+		<h1 class="flex items-center gap-2 text-2xl font-bold tracking-tight">
+			<Shield class="h-6 w-6" /> Roles y permisos
 		</h1>
-		<p class="text-muted-foreground text-sm mt-1">
-			Gestión de roles y control de acceso.
+		<p class="mt-1 text-sm text-muted-foreground">
+			Define roles (carriles) por compañía y qué puede hacer cada uno. Los usuarios se asignan en Usuarios.
 		</p>
 	</div>
 
-	<Card.Root>
-		<Card.Header>
-			<Card.Title>Roles del sistema</Card.Title>
-			<Card.Description>Implementa aquí la gestión de roles y permisos de tu proyecto.</Card.Description>
-		</Card.Header>
-		<Card.Content>
-			<p class="text-sm text-muted-foreground">Sección en construcción.</p>
-		</Card.Content>
-	</Card.Root>
+	{#if !companyId}
+		<Card.Root><Card.Content class="pt-6 text-sm text-muted-foreground">Selecciona una compañía activa para gestionar sus roles.</Card.Content></Card.Root>
+	{:else}
+		<Card.Root>
+			<Card.Header>
+				<Card.Title class="flex items-center gap-2"><Plus class="h-4 w-4" /> Nuevo rol</Card.Title>
+			</Card.Header>
+			<Card.Content>
+				<div class="grid gap-4 sm:grid-cols-3">
+					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Nombre *</span><input class={inputCls} bind:value={name} placeholder="Ventas" /></label>
+					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Código</span><input class="font-mono {inputCls}" bind:value={code} placeholder="(auto)" title="Se genera del nombre si lo dejas vacío" /></label>
+					<label class="flex flex-col gap-1 text-sm"><span class="font-medium">Descripción</span><input class={inputCls} bind:value={description} /></label>
+				</div>
+				<div class="mt-4 flex justify-end"><Button onclick={createRole} disabled={creating}>{creating ? 'Creando…' : 'Crear rol'}</Button></div>
+			</Card.Content>
+		</Card.Root>
+
+		<Card.Root>
+			<Card.Header>
+				<Card.Title>Roles ({roles.length})</Card.Title>
+				<Card.Description>Haz clic en un rol para ver y editar sus permisos.</Card.Description>
+			</Card.Header>
+			<Card.Content class="space-y-2">
+				{#if loading}
+					<p class="text-sm text-muted-foreground">Cargando…</p>
+				{:else if roles.length === 0}
+					<p class="text-sm text-muted-foreground">No hay roles. Crea uno arriba.</p>
+				{:else}
+					{#each roles as r (r.id)}
+						<div class="rounded-md border">
+							<div class="flex items-center gap-2 px-3 py-2">
+								<button type="button" class="flex flex-1 items-center gap-2 text-left" onclick={() => toggleExpand(r)}>
+									{#if expandedRoleId === r.id}<ChevronDown class="h-4 w-4" />{:else}<ChevronRight class="h-4 w-4" />{/if}
+									<span class="font-medium">{r.name}</span>
+									<span class="font-mono text-xs text-muted-foreground">{r.code}</span>
+								</button>
+								<Button variant="ghost" size="sm" onclick={() => delRole(r)}><Trash2 class="h-4 w-4 text-destructive" /></Button>
+							</div>
+							{#if expandedRoleId === r.id}
+								<div class="border-t p-3">
+									{#if !rolePerms[r.id]}
+										<p class="text-sm text-muted-foreground">Cargando permisos…</p>
+									{:else}
+										<div class="space-y-4">
+											{#each Object.entries(byModule) as [mod, perms] (mod)}
+												<div>
+													<p class="mb-1 text-xs font-semibold uppercase tracking-wide text-muted-foreground">{mod}</p>
+													<div class="grid gap-1 sm:grid-cols-2 lg:grid-cols-3">
+														{#each perms as p (p.id)}
+															<label class="flex items-center gap-2 text-sm">
+																<input
+																	type="checkbox"
+																	class="h-4 w-4 rounded border"
+																	checked={rolePerms[r.id].has(p.id)}
+																	disabled={savingPerm === `${r.id}:${p.id}`}
+																	onchange={(e) => togglePerm(r.id, p, (e.currentTarget as HTMLInputElement).checked)}
+																/>
+																<span title={p.code}>{p.description || p.code}</span>
+															</label>
+														{/each}
+													</div>
+												</div>
+											{/each}
+										</div>
+									{/if}
+								</div>
+							{/if}
+						</div>
+					{/each}
+				{/if}
+			</Card.Content>
+		</Card.Root>
+	{/if}
 </div>

frontend/src/routes/dashboard/users/+page.svelte

@@ -1,23 +1,253 @@
 <script lang="ts">
-	import { Users } from 'lucide-svelte';
+	import { Users, X, UserPlus, Copy, Check } from '@lucide/svelte';
+	import { Button } from '$lib/components/ui/button';
 	import * as Card from '$lib/components/ui/card';
+	import { toast } from 'svelte-sonner';
+	import { companyStore } from '$lib/stores/company.svelte';
+	import { usersAPI, type User } from '$lib/api/dashboard/users';
+	import { rolesAPI, type CompanyRole } from '$lib/api/dashboard/admin/roles';
+	import { userRolesAPI, type UserRole } from '$lib/api/dashboard/admin/user-roles';
+
+	const inputCls =
+		'rounded-md border bg-transparent px-2 py-1 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring';
+
+	const companyId = $derived(companyStore.activeCompany?.id ?? null);
+
+	let users = $state<User[]>([]);
+	let roles = $state<CompanyRole[]>([]);
+	let assignments = $state<UserRole[]>([]);
+	let loading = $state(true);
+	let busy = $state<string | null>(null);
+
+	// Alta de usuario por invitación
+	let inviteEmail = $state('');
+	let inviteRoleId = $state<number | null>(null);
+	let inviting = $state(false);
+	let inviteUrl = $state<string | null>(null);
+	let copied = $state(false);
+
+	// user_id → asignaciones de rol
+	const rolesByUser = $derived.by(() => {
+		const m: Record<string, UserRole[]> = {};
+		for (const a of assignments) (m[String(a.user_id)] ??= []).push(a);
+		return m;
+	});
+
+	function fullName(u: User): string {
+		const n = `${u.first_name ?? ''} ${u.last_name ?? ''}`.trim();
+		return n || u.username || u.email || u.id;
+	}
+
+	async function load() {
+		if (!companyId) {
+			loading = false;
+			return;
+		}
+		loading = true;
+		try {
+			const [uRes, rRes, arRes] = await Promise.all([
+				usersAPI.list(companyId, { page_size: 100 }).catch(() => ({ users: [] as User[] })),
+				rolesAPI.list(companyId, { page_size: 100 }),
+				userRolesAPI.list(companyId, { page_size: 500 }).catch(() => ({ items: [] as UserRole[] } as any))
+			]);
+			users = uRes.users ?? [];
+			roles = rRes.data?.items ?? [];
+			assignments = arRes.items ?? [];
+		} catch {
+			toast.error('No se pudieron cargar los usuarios');
+		} finally {
+			loading = false;
+		}
+	}
+
+	// Recarga al cambiar la compañía activa —incluida la hidratación inicial tras
+	// refrescar (antes no cargaba hasta re-seleccionar la compañía).
+	$effect(() => {
+		const id = companyId;
+		if (id) {
+			void load();
+		} else {
+			users = [];
+			loading = false;
+		}
+	});
+
+	async function assignRole(user: User, roleIdRaw: string) {
+		if (!companyId) return;
+		const roleId = Number(roleIdRaw);
+		if (!roleId) return;
+		if (rolesByUser[String(user.id)]?.some((a) => a.company_role_id === roleId)) {
+			toast.info('El usuario ya tiene ese rol');
+			return;
+		}
+		busy = `assign:${user.id}`;
+		try {
+			await userRolesAPI.assign(companyId, { user_id: String(user.id), company_role_id: roleId });
+			toast.success('Rol asignado');
+			await load();
+		} catch (e) {
+			toast.error(e instanceof Error ? e.message : 'No se pudo asignar el rol');
+		} finally {
+			busy = null;
+		}
+	}
+
+	async function removeRole(a: UserRole) {
+		if (!companyId) return;
+		busy = `remove:${a.id}`;
+		try {
+			await userRolesAPI.remove(a.id, companyId);
+			toast.success('Rol removido');
+			await load();
+		} catch (e) {
+			toast.error(e instanceof Error ? e.message : 'No se pudo remover el rol');
+		} finally {
+			busy = null;
+		}
+	}
+
+	async function inviteUser() {
+		if (!companyId) return;
+		const email = inviteEmail.trim();
+		if (!email || !email.includes('@')) {
+			toast.error('Ingresa un email válido');
+			return;
+		}
+		if (!inviteRoleId) {
+			toast.error('Selecciona el rol del usuario');
+			return;
+		}
+		inviting = true;
+		inviteUrl = null;
+		try {
+			const res = await usersAPI.invite({ email, company_id: companyId, role_id: inviteRoleId });
+			toast.success('Invitación creada');
+			inviteUrl = res.invite_url ?? null;
+			inviteEmail = '';
+			await load();
+		} catch (e) {
+			toast.error(e instanceof Error ? e.message : 'No se pudo dar de alta el usuario');
+		} finally {
+			inviting = false;
+		}
+	}
+
+	async function copyInvite() {
+		if (!inviteUrl) return;
+		try {
+			await navigator.clipboard.writeText(inviteUrl);
+			copied = true;
+			toast.success('Enlace copiado');
+			setTimeout(() => (copied = false), 2000);
+		} catch {
+			toast.error('No se pudo copiar');
+		}
+	}
 </script>
 
 <div class="space-y-6">
 	<div>
-		<h1 class="text-2xl font-bold tracking-tight flex items-center gap-2">
-			<Users class="h-6 w-6" />
-			Usuarios
+		<h1 class="flex items-center gap-2 text-2xl font-bold tracking-tight">
+			<Users class="h-6 w-6" /> Usuarios
 		</h1>
-		<p class="text-muted-foreground text-sm mt-1">Gestión de usuarios y accesos.</p>
+		<p class="mt-1 text-sm text-muted-foreground">
+			Usuarios de la compañía activa y sus roles. Para dar de alta usuarios nuevos usa Workspace → Usuarios (invitaciones).
+		</p>
 	</div>
-	<Card.Root>
-		<Card.Header>
-			<Card.Title>Usuarios del sistema</Card.Title>
-			<Card.Description>Implementa aquí la gestión de usuarios de tu proyecto.</Card.Description>
-		</Card.Header>
-		<Card.Content>
-			<p class="text-sm text-muted-foreground">Sección en construcción.</p>
-		</Card.Content>
-	</Card.Root>
+
+	{#if !companyId}
+		<Card.Root><Card.Content class="pt-6 text-sm text-muted-foreground">Selecciona una compañía activa.</Card.Content></Card.Root>
+	{:else}
+		<Card.Root>
+			<Card.Header>
+				<Card.Title class="flex items-center gap-2"><UserPlus class="h-4 w-4" /> Dar de alta usuario</Card.Title>
+				<Card.Description>Se envía una invitación por email; el usuario crea su contraseña y queda en la compañía con el rol elegido.</Card.Description>
+			</Card.Header>
+			<Card.Content>
+				<div class="grid gap-4 sm:grid-cols-3">
+					<label class="flex flex-col gap-1 text-sm sm:col-span-2">
+						<span class="font-medium">Email *</span>
+						<input type="email" class={inputCls} bind:value={inviteEmail} placeholder="persona@empresa.com" />
+					</label>
+					<label class="flex flex-col gap-1 text-sm">
+						<span class="font-medium">Rol *</span>
+						<select class={inputCls} bind:value={inviteRoleId}>
+							<option value={null} disabled>Selecciona…</option>
+							{#each roles as r (r.id)}<option value={r.id}>{r.name}</option>{/each}
+						</select>
+					</label>
+				</div>
+				<div class="mt-4 flex items-center justify-between gap-2">
+					{#if roles.length === 0}
+						<span class="text-xs text-muted-foreground">Primero crea roles en "Roles y permisos".</span>
+					{:else}<span></span>{/if}
+					<Button onclick={inviteUser} disabled={inviting || roles.length === 0}>{inviting ? 'Enviando…' : 'Invitar / dar de alta'}</Button>
+				</div>
+				{#if inviteUrl}
+					<div class="mt-3 flex items-center gap-2 rounded-md border bg-muted/40 p-2">
+						<span class="whitespace-nowrap text-xs text-muted-foreground">Si el correo no llega, comparte:</span>
+						<input class="flex-1 font-mono text-xs {inputCls}" readonly value={inviteUrl} />
+						<Button variant="outline" size="sm" onclick={copyInvite}>{#if copied}<Check class="h-4 w-4" />{:else}<Copy class="h-4 w-4" />{/if}</Button>
+					</div>
+				{/if}
+			</Card.Content>
+		</Card.Root>
+
+		<Card.Root>
+			<Card.Header>
+				<Card.Title>Usuarios ({users.length})</Card.Title>
+				<Card.Description>Asigna o quita roles (los roles se definen en Roles y permisos).</Card.Description>
+			</Card.Header>
+			<Card.Content>
+				{#if loading}
+					<p class="text-sm text-muted-foreground">Cargando…</p>
+				{:else if users.length === 0}
+					<p class="text-sm text-muted-foreground">No hay usuarios en esta compañía todavía.</p>
+				{:else}
+					<div class="overflow-x-auto">
+						<table class="w-full text-sm">
+							<thead class="text-left text-muted-foreground">
+								<tr class="border-b">
+									<th class="py-2 pr-4 font-medium">Usuario</th>
+									<th class="py-2 pr-4 font-medium">Email</th>
+									<th class="py-2 pr-4 font-medium">Roles</th>
+									<th class="py-2 pr-4 font-medium">Asignar rol</th>
+								</tr>
+							</thead>
+							<tbody>
+								{#each users as u (u.id)}
+									<tr class="border-b last:border-0 align-top">
+										<td class="py-2 pr-4">{fullName(u)}</td>
+										<td class="py-2 pr-4 text-muted-foreground">{u.email ?? '—'}</td>
+										<td class="py-2 pr-4">
+											<div class="flex flex-wrap gap-1">
+												{#each rolesByUser[String(u.id)] ?? [] as a (a.id)}
+													<span class="inline-flex items-center gap-1 rounded-full bg-primary/10 px-2 py-0.5 text-xs text-primary">
+														{a.company_role?.name ?? a.company_role?.code ?? `rol ${a.company_role_id}`}
+														<button type="button" class="hover:text-destructive" disabled={busy === `remove:${a.id}`} onclick={() => removeRole(a)} title="Quitar rol"><X class="h-3 w-3" /></button>
+													</span>
+												{:else}
+													<span class="text-xs text-muted-foreground">sin rol</span>
+												{/each}
+											</div>
+										</td>
+										<td class="py-2 pr-4">
+											<select
+												class={inputCls}
+												disabled={busy === `assign:${u.id}` || roles.length === 0}
+												onchange={(e) => { const el = e.currentTarget as HTMLSelectElement; assignRole(u, el.value); el.value = ''; }}
+											>
+												<option value="">+ rol…</option>
+												{#each roles as r (r.id)}<option value={r.id}>{r.name}</option>{/each}
+											</select>
+										</td>
+									</tr>
+								{/each}
+							</tbody>
+						</table>
+					</div>
+				{/if}
+			</Card.Content>
+		</Card.Root>
+	{/if}
 </div>

frontend/src/routes/dashboard/workspace/organizaciones/+page.server.ts

@@ -0,0 +1,78 @@
+import { fail } from '@sveltejs/kit';
+import type { PageServerLoad, Actions } from './$types';
+import { getKcAccessToken } from '$lib/server/api';
+import {
+	listWorkspaceTenants,
+	createWorkspaceTenant,
+	type CreateTenantInput
+} from '$lib/server/workspace-provision';
+import { validateTenantForm } from '$lib/server/workspace-provision.shared';
+
+export const load: PageServerLoad = async ({ cookies, fetch }) => {
+	const accessToken = getKcAccessToken(cookies);
+	if (!accessToken) {
+		return { tenants: [], forbidden: true, loadError: null };
+	}
+
+	const res = await listWorkspaceTenants(accessToken, fetch);
+	if (!res.ok) {
+		// 401/403 → el usuario no es admin del workspace: se muestra estado informativo,
+		// no un error. Otros status sí se reportan como error de carga.
+		return { tenants: [], forbidden: res.forbidden, loadError: res.forbidden ? null : res.error };
+	}
+
+	return { tenants: res.data, forbidden: false, loadError: null };
+};
+
+export const actions: Actions = {
+	create: async ({ request, cookies, fetch }) => {
+		const accessToken = getKcAccessToken(cookies);
+		if (!accessToken) return fail(401, { error: 'Tu sesión expiró. Vuelve a entrar al CRM.' });
+
+		const data = await request.formData();
+		const name = String(data.get('name') ?? '').trim();
+		const slug = String(data.get('slug') ?? '')
+			.trim()
+			.toLowerCase();
+		const contact_email = String(data.get('contact_email') ?? '').trim();
+		const contact_name = String(data.get('contact_name') ?? '').trim();
+		const contact_phone = String(data.get('contact_phone') ?? '').trim();
+		const display_name = String(data.get('display_name') ?? '').trim();
+		const app_url = String(data.get('app_url') ?? '').trim();
+		const is_self_hosted = data.get('is_self_hosted') === 'on';
+
+		// Valores para repoblar el formulario si algo falla.
+		const values = {
+			name,
+			slug,
+			contact_email,
+			contact_name,
+			contact_phone,
+			display_name,
+			app_url,
+			is_self_hosted
+		};
+
+		const validationError = validateTenantForm({ name, slug, contact_email });
+		if (validationError) return fail(422, { error: validationError, values });
+
+		// Solo se envían los campos opcionales con valor, para no mandar strings vacíos.
+		const payload: CreateTenantInput = {
+			name,
+			slug,
+			contact_email,
+			is_self_hosted,
+			...(contact_name ? { contact_name } : {}),
+			...(contact_phone ? { contact_phone } : {}),
+			...(display_name ? { display_name } : {}),
+			...(app_url ? { app_url } : {})
+		};
+
+		const res = await createWorkspaceTenant(accessToken, fetch, payload);
+		if (!res.ok) {
+			return fail(res.forbidden ? 403 : 422, { error: res.error, values });
+		}
+
+		return { success: true, tenantName: res.data.name, tenantSlug: res.data.slug };
+	}
+};

frontend/src/routes/dashboard/workspace/organizaciones/+page.svelte

@@ -0,0 +1,180 @@
+<script lang="ts">
+	import { Building2, Plus, ShieldAlert, RefreshCw } from '@lucide/svelte';
+	import { enhance } from '$app/forms';
+	import * as Card from '$lib/components/ui/card';
+	import { Button } from '$lib/components/ui/button';
+	import { toast } from 'svelte-sonner';
+	import type { PageData, ActionData } from './$types';
+
+	let { data, form }: { data: PageData; form: ActionData } = $props();
+
+	let submitting = $state(false);
+
+	const inputCls =
+		'rounded-md border bg-transparent px-3 py-2 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring';
+
+	// Valores repoblados tras un fallo de validación del servidor.
+	const v = $derived((form && 'values' in form ? form.values : null) as Record<string, unknown> | null);
+	function prev(field: string): string {
+		const val = v?.[field];
+		return typeof val === 'string' ? val : '';
+	}
+</script>
+
+<div class="space-y-6">
+	<div>
+		<h1 class="flex items-center gap-2 text-2xl font-bold tracking-tight">
+			<Building2 class="h-6 w-6" /> Organizaciones del workspace
+		</h1>
+		<p class="mt-1 text-sm text-muted-foreground">
+			Da de alta un cliente nuevo (tenant). Se crea su realm en Keycloak y su licencia base.
+		</p>
+	</div>
+
+	{#if data.forbidden}
+		<Card.Root>
+			<Card.Content class="flex items-start gap-3 pt-6">
+				<ShieldAlert class="mt-0.5 h-5 w-5 text-amber-500" />
+				<div class="text-sm">
+					<p class="font-medium">Requiere permisos de administrador del workspace</p>
+					<p class="mt-1 text-muted-foreground">
+						El alta de organizaciones solo está disponible para administradores del Hub
+						(<code>hub_admin</code>). Tu usuario actual no tiene ese rol.
+					</p>
+				</div>
+			</Card.Content>
+		</Card.Root>
+	{:else}
+		{#if data.loadError}
+			<div class="rounded-md border border-destructive/40 bg-destructive/10 px-4 py-3 text-sm text-destructive">
+				No se pudo consultar el workspace: {data.loadError}
+			</div>
+		{/if}
+
+		<!-- Alta de organización -->
+		<Card.Root>
+			<Card.Header>
+				<Card.Title class="flex items-center gap-2"><Plus class="h-4 w-4" /> Nueva organización</Card.Title>
+				<Card.Description>El slug identifica al tenant; no se puede cambiar después.</Card.Description>
+			</Card.Header>
+			<Card.Content>
+				<form
+					method="POST"
+					action="?/create"
+					use:enhance={() => {
+						submitting = true;
+						return async ({ result, update }) => {
+							submitting = false;
+							if (result.type === 'success') {
+								toast.success(`Organización creada: ${result.data?.tenantName ?? ''}`);
+								await update({ reset: true });
+							} else if (result.type === 'failure') {
+								toast.error(String(result.data?.error ?? 'No se pudo crear la organización'));
+								await update({ reset: false });
+							} else {
+								await update();
+							}
+						};
+					}}
+				>
+					<div class="grid gap-4 sm:grid-cols-2">
+						<label class="flex flex-col gap-1 text-sm sm:col-span-2">
+							<span class="font-medium">Nombre / Razón social *</span>
+							<input class={inputCls} name="name" required minlength="2" value={prev('name')} />
+						</label>
+						<label class="flex flex-col gap-1 text-sm">
+							<span class="font-medium">Slug *</span>
+							<input
+								class="font-mono {inputCls}"
+								name="slug"
+								required
+								pattern="[a-z0-9-]+"
+								placeholder="empresa-abc"
+								title="Solo minúsculas, dígitos y guiones"
+								value={prev('slug')}
+							/>
+						</label>
+						<label class="flex flex-col gap-1 text-sm">
+							<span class="font-medium">Nombre para mostrar</span>
+							<input class={inputCls} name="display_name" value={prev('display_name')} />
+						</label>
+						<label class="flex flex-col gap-1 text-sm">
+							<span class="font-medium">Contacto (nombre)</span>
+							<input class={inputCls} name="contact_name" value={prev('contact_name')} />
+						</label>
+						<label class="flex flex-col gap-1 text-sm">
+							<span class="font-medium">Email de contacto *</span>
+							<input type="email" class={inputCls} name="contact_email" required value={prev('contact_email')} />
+						</label>
+						<label class="flex flex-col gap-1 text-sm">
+							<span class="font-medium">Teléfono de contacto</span>
+							<input class={inputCls} name="contact_phone" value={prev('contact_phone')} />
+						</label>
+						<label class="flex flex-col gap-1 text-sm">
+							<span class="font-medium">URL de la app (opcional)</span>
+							<input class={inputCls} name="app_url" placeholder="https://app.empresa-abc.com" value={prev('app_url')} />
+						</label>
+						<label class="flex items-center gap-2 text-sm sm:col-span-2">
+							<input type="checkbox" name="is_self_hosted" class="h-4 w-4 rounded border" />
+							<span>Cliente self-hosted (instalación propia)</span>
+						</label>
+					</div>
+
+					<div class="mt-6 flex justify-end border-t pt-4">
+						<Button type="submit" disabled={submitting}>
+							{submitting ? 'Creando…' : 'Crear organización'}
+						</Button>
+					</div>
+				</form>
+			</Card.Content>
+		</Card.Root>
+
+		<!-- Organizaciones existentes -->
+		<Card.Root>
+			<Card.Header>
+				<Card.Title>Organizaciones ({data.tenants.length})</Card.Title>
+				<Card.Description>Tenants activos en el workspace.</Card.Description>
+			</Card.Header>
+			<Card.Content>
+				{#if data.tenants.length === 0}
+					<p class="flex items-center gap-2 text-sm text-muted-foreground">
+						<RefreshCw class="h-4 w-4" /> Aún no hay organizaciones registradas.
+					</p>
+				{:else}
+					<div class="overflow-x-auto">
+						<table class="w-full text-sm">
+							<thead class="text-left text-muted-foreground">
+								<tr class="border-b">
+									<th class="py-2 pr-4 font-medium">Nombre</th>
+									<th class="py-2 pr-4 font-medium">Slug</th>
+									<th class="py-2 pr-4 font-medium">Contacto</th>
+									<th class="py-2 pr-4 font-medium">Estatus</th>
+									<th class="py-2 pr-4 font-medium">Licencia</th>
+								</tr>
+							</thead>
+							<tbody>
+								{#each data.tenants as t (t.id)}
+									<tr class="border-b last:border-0">
+										<td class="py-2 pr-4">{t.display_name || t.name}</td>
+										<td class="py-2 pr-4 font-mono text-xs">{t.slug}</td>
+										<td class="py-2 pr-4">{t.contact_email}</td>
+										<td class="py-2 pr-4">
+											<span
+												class="rounded-full px-2 py-0.5 text-xs {t.status === 'active'
+													? 'bg-emerald-500/15 text-emerald-600'
+													: 'bg-muted text-muted-foreground'}"
+											>
+												{t.status}
+											</span>
+										</td>
+										<td class="py-2 pr-4">{t.has_license ? 'Sí' : '—'}</td>
+									</tr>
+								{/each}
+							</tbody>
+						</table>
+					</div>
+				{/if}
+			</Card.Content>
+		</Card.Root>
+	{/if}
+</div>

frontend/src/routes/dashboard/workspace/usuarios/+page.server.ts

@@ -0,0 +1,60 @@
+import { fail } from '@sveltejs/kit';
+import type { PageServerLoad, Actions } from './$types';
+import { getUserCompanies } from '$lib/server/api';
+import { createWorkspaceInvite } from '$lib/server/workspace-provision';
+import { WORKSPACE_INVITE_ROLES } from '$lib/server/workspace-provision.shared';
+
+export const load: PageServerLoad = async ({ cookies, fetch }) => {
+	// La organización destino sale de las compañías del usuario (mismo origen que
+	// el switcher, vía /v1/auth/my-companies). Así no se escribe el slug a mano ni
+	// se depende de listar todos los tenants del Hub con un token KC que caduca.
+	const companiesRaw = await getUserCompanies(cookies, fetch);
+	const companies = (companiesRaw ?? [])
+		.filter((c) => c && c.tenant_slug)
+		.map((c) => ({
+			id: c.id as number,
+			name: c.name as string,
+			tenant_slug: c.tenant_slug as string,
+			tenant_name: (c.tenant_name as string) || (c.tenant_slug as string)
+		}));
+
+	return { companies, roles: WORKSPACE_INVITE_ROLES };
+};
+
+export const actions: Actions = {
+	invite: async ({ request, cookies, fetch }) => {
+		const accessToken = getKcAccessToken(cookies);
+		if (!accessToken) return fail(401, { error: 'Tu sesión expiró. Vuelve a entrar al CRM.' });
+
+		const data = await request.formData();
+		const email = String(data.get('email') ?? '').trim();
+		const tenant_slug = String(data.get('tenant_slug') ?? '')
+			.trim()
+			.toLowerCase();
+		const role = String(data.get('role') ?? 'user').trim();
+
+		const values = { email, tenant_slug, role };
+
+		if (!email || !email.includes('@')) {
+			return fail(422, { error: 'Ingresa un email válido para invitar.', values });
+		}
+		if (!tenant_slug) {
+			return fail(422, { error: 'Selecciona la compañía destino.', values });
+		}
+		if (!WORKSPACE_INVITE_ROLES.includes(role as (typeof WORKSPACE_INVITE_ROLES)[number])) {
+			return fail(422, { error: 'Rol inválido.', values });
+		}
+
+		const res = await createWorkspaceInvite(accessToken, fetch, { email, tenant_slug, role });
+		if (!res.ok) {
+			return fail(res.forbidden ? 403 : 422, { error: res.error, values });
+		}
+
+		return {
+			success: true,
+			email: res.data.email,
+			inviteUrl: res.data.invite_url,
+			expiresAt: res.data.expires_at
+		};
+	}
+};

frontend/src/routes/dashboard/workspace/usuarios/+page.svelte

@@ -0,0 +1,141 @@
+<script lang="ts">
+	import { UserPlus, Copy, Check, MailCheck } from '@lucide/svelte';
+	import { enhance } from '$app/forms';
+	import * as Card from '$lib/components/ui/card';
+	import { Button } from '$lib/components/ui/button';
+	import { toast } from 'svelte-sonner';
+	import type { PageData, ActionData } from './$types';
+
+	let { data, form }: { data: PageData; form: ActionData } = $props();
+
+	let submitting = $state(false);
+	let copied = $state(false);
+
+	const inputCls =
+		'rounded-md border bg-transparent px-3 py-2 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring';
+
+	const v = $derived((form && 'values' in form ? form.values : null) as Record<string, unknown> | null);
+	function prev(field: string): string {
+		const val = v?.[field];
+		return typeof val === 'string' ? val : '';
+	}
+
+	// Invitación recién creada (para copiar/compartir el enlace).
+	const created = $derived(
+		form && 'success' in form && form.success
+			? { email: form.email, inviteUrl: form.inviteUrl }
+			: null
+	);
+
+	async function copyInvite(url: string) {
+		try {
+			await navigator.clipboard.writeText(url);
+			copied = true;
+			toast.success('Enlace de invitación copiado');
+			setTimeout(() => (copied = false), 2000);
+		} catch {
+			toast.error('No se pudo copiar el enlace');
+		}
+	}
+</script>
+
+<div class="space-y-6">
+	<div>
+		<h1 class="flex items-center gap-2 text-2xl font-bold tracking-tight">
+			<UserPlus class="h-6 w-6" /> Alta de usuarios (invitaciones)
+		</h1>
+		<p class="mt-1 text-sm text-muted-foreground">
+			Invita a un usuario a una organización del workspace. Recibe un enlace de un solo uso para
+			fijar su contraseña y activarse.
+		</p>
+	</div>
+
+	{#if created}
+		<Card.Root class="border-emerald-500/40">
+			<Card.Content class="pt-6">
+				<div class="flex items-start gap-3">
+					<MailCheck class="mt-0.5 h-5 w-5 text-emerald-600" />
+					<div class="min-w-0 flex-1 text-sm">
+						<p class="font-medium">Invitación enviada a {created.email}</p>
+						<p class="mt-1 text-muted-foreground">
+							Si el correo no llega, comparte este enlace directamente:
+						</p>
+						<div class="mt-2 flex items-center gap-2">
+							<input class="flex-1 font-mono text-xs {inputCls}" readonly value={created.inviteUrl} />
+							<Button variant="outline" size="sm" onclick={() => copyInvite(String(created.inviteUrl))}>
+								{#if copied}<Check class="h-4 w-4" />{:else}<Copy class="h-4 w-4" />{/if}
+							</Button>
+						</div>
+					</div>
+				</div>
+			</Card.Content>
+		</Card.Root>
+	{/if}
+
+	<Card.Root>
+		<Card.Header>
+			<Card.Title>Nueva invitación</Card.Title>
+			<Card.Description>Elige la compañía destino y el rol del usuario.</Card.Description>
+		</Card.Header>
+		<Card.Content>
+			<form
+				method="POST"
+				action="?/invite"
+				use:enhance={() => {
+					submitting = true;
+					return async ({ result, update }) => {
+						submitting = false;
+						if (result.type === 'success') {
+							toast.success('Invitación creada');
+							await update({ reset: true });
+						} else if (result.type === 'failure') {
+							toast.error(String(result.data?.error ?? 'No se pudo crear la invitación'));
+							await update({ reset: false });
+						} else {
+							await update();
+						}
+					};
+				}}
+			>
+				<div class="grid gap-4 sm:grid-cols-2">
+					<label class="flex flex-col gap-1 text-sm sm:col-span-2">
+						<span class="font-medium">Email del usuario *</span>
+						<input type="email" class={inputCls} name="email" required value={prev('email')} />
+					</label>
+
+					<label class="flex flex-col gap-1 text-sm">
+						<span class="font-medium">Compañía destino *</span>
+						{#if data.companies.length > 0}
+							<select class={inputCls} name="tenant_slug" required value={prev('tenant_slug')}>
+								<option value="" disabled>Selecciona…</option>
+								{#each data.companies as c (c.id)}
+									<option value={c.tenant_slug}>{c.name} — {c.tenant_name}</option>
+								{/each}
+							</select>
+						{:else}
+							<span class="rounded-md border border-dashed px-3 py-2 text-xs text-muted-foreground">
+								No hay compañías disponibles en tu tenant. Crea una en Compañías.
+							</span>
+							<input type="hidden" name="tenant_slug" value="" />
+						{/if}
+					</label>
+
+					<label class="flex flex-col gap-1 text-sm">
+						<span class="font-medium">Rol *</span>
+						<select class={inputCls} name="role" required value={prev('role') || 'user'}>
+							{#each data.roles as r (r)}
+								<option value={r}>{r}</option>
+							{/each}
+						</select>
+					</label>
+				</div>
+
+				<div class="mt-6 flex justify-end border-t pt-4">
+					<Button type="submit" disabled={submitting || data.companies.length === 0}>
+						{submitting ? 'Enviando…' : 'Enviar invitación'}
+					</Button>
+				</div>
+			</form>
+		</Card.Content>
+	</Card.Root>
+</div>

frontend/src/routes/join/+page.server.ts

@@ -1,7 +1,7 @@
 import { redirect, fail } from '@sveltejs/kit';
 import type { PageServerLoad, Actions } from './$types';
 import { getServerApiUrl, getAuthTokens } from '$lib/server/api';
-import { redirectToKeycloakLogin } from '$lib/server/workspace-auth';
+import { redirectToWorkspaceLogin } from '$lib/server/workspace-auth';
 
 export const load: PageServerLoad = async ({ url, cookies, fetch }) => {
 	const code = url.searchParams.get('code')?.toUpperCase().trim() ?? '';
@@ -13,7 +13,7 @@ export const load: PageServerLoad = async ({ url, cookies, fetch }) => {
 
 		if (!accessToken) {
 			// Sesión KC expiró entre redirecciones — volver a auth
-			redirectToKeycloakLogin(url.origin, `/join?code=${code}&step=consume`);
+			redirectToWorkspaceLogin(cookies, url);
 		}
 
 		const apiUrl = getServerApiUrl();
@@ -76,7 +76,7 @@ export const actions: Actions = {
 
 		if (!accessToken) {
 			// Redirigir a Keycloak; al volver, el callback irá a /join?code=XXX&step=consume
-			redirectToKeycloakLogin(url.origin, `/join?code=${code}&step=consume`);
+			redirectToWorkspaceLogin(cookies, url);
 		}
 
 		// Si ya hay sesión, consumir directamente vía redirect a step=consume

frontend/src/routes/login/+page.server.ts

@@ -4,12 +4,9 @@ import type { Actions, PageServerLoad } from './$types';
 import { clearAuthTokens, getAuthTokens } from '$lib/server/api';
 import { setAccessTokenCookies } from '$lib/server/access-token-cookie';
 import {
-	getWorkspaceLoginUrl,
 	readWorkspaceReturnPath,
 	clearWorkspaceReturnPath,
-	storeReturnPath,
-	redirectToKeycloakAuthorization,
-	redirectToKeycloakLogin,
+	redirectToWorkspaceLogin,
 	getHubBackendUrl,
 	isSecureContext,
 } from '$lib/server/workspace-auth';
@@ -65,29 +62,17 @@ export const load: PageServerLoad = async ({ cookies, url }) => {
 
 	clearAuthTokens(cookies);
 
+	// Vuelta desde el Workspace tras autenticarse: el CRM NO inicia ningún flujo
+	// OIDC contra Keycloak. La sesión se obtiene por relay del App Launcher
+	// (→ /auth/sso). Si el usuario llega aquí ya autenticado en el Hub, se le
+	// manda al dashboard; si no hay sesión local, el layout lo reenvía al
+	// Workspace (App Launcher) para re-entrar por relay.
 	if (url.searchParams.get('sso_verified') === '1') {
-		const existingReturnPath = readWorkspaceReturnPath(cookies, '');
-		const intendedPath =
-			existingReturnPath && existingReturnPath !== '/login'
-				? existingReturnPath
-				: (url.searchParams.get('redirect') || '/dashboard');
-		storeReturnPath(cookies, intendedPath);
-		redirectToKeycloakAuthorization(url.origin, intendedPath);
+		throw redirect(303, '/dashboard');
 	}
 
-	const redirectParam = url.searchParams.get('redirect');
-	if (redirectParam) {
-		const existingReturnPath = readWorkspaceReturnPath(cookies, '');
-		const intendedPath =
-			existingReturnPath && existingReturnPath !== '/login'
-				? existingReturnPath
-				: redirectParam;
-		storeReturnPath(cookies, intendedPath);
-		redirectToKeycloakLogin(url.origin, intendedPath);
-	}
-
-	storeReturnPath(cookies, '/dashboard');
-	throw redirect(303, getWorkspaceLoginUrl(url.origin));
+	// Sin sesión → App Launcher del Workspace (relay). Nunca Keycloak directo.
+	redirectToWorkspaceLogin(cookies, url);
 };
 
 export const actions: Actions = {

frontend/src/routes/logout/+server.ts

@@ -1,37 +1,28 @@
 import { redirect } from '@sveltejs/kit';
 import { env } from '$env/dynamic/private';
 import type { RequestHandler } from './$types';
-import { clearAccessTokenCookies } from '$lib/server/access-token-cookie';
-import {
-	buildKeycloakLogoutUrl,
-	clearWorkspaceReturnPath,
-	getWorkspaceLoginUrl
-} from '$lib/server/workspace-auth';
+import { clearAuthTokens } from '$lib/server/api';
+import { clearWorkspaceReturnPath, getWorkspaceLoginUrl } from '$lib/server/workspace-auth';
 
-export const POST: RequestHandler = async ({ cookies, url }) => {
-	const systemBaseUrl = url.origin;
-
-	const idToken = cookies.get('id_token');
-
-	// Eliminar todas las cookies de autenticación
-	clearAccessTokenCookies(cookies);
-	cookies.delete('refresh_token', { path: '/' });
+/**
+ * Logout del CRM. Limpia la sesión LOCAL (cookies) y devuelve al Workspace.
+ * NO habla directo a Keycloak: el cierre de sesión completo (Hub/KC) se hace
+ * desde el Workspace. Patrón SIWEB.
+ */
+export const POST: RequestHandler = async ({ cookies }) => {
+	// Eliminar todas las cookies de autenticación (incluye sesión local + token KC)
+	clearAuthTokens(cookies);
 	cookies.delete('id_token', { path: '/' });
-	cookies.delete('active_company_id', { path: '/' });
-	cookies.delete('active_system', { path: '/' });
 	cookies.delete('sso_tenant_id', { path: '/' });
 	cookies.delete('sso_tenant_pub', { path: '/' });
 	clearWorkspaceReturnPath(cookies);
 
-	// En modo local no hay Keycloak ni Hub — ir directo al login local.
+	// Modo local: no hay Workspace — ir al login local.
 	if ((env.DEV_LOCAL_AUTH ?? '').toLowerCase() === 'true') {
 		throw redirect(303, '/login');
 	}
 
-	// Sin id_token_hint KC rechaza post_logout_redirect_uri no registrado.
-	if (!idToken) {
-		throw redirect(303, getWorkspaceLoginUrl(systemBaseUrl, { forPostLogout: true }));
-	}
-
-	throw redirect(303, buildKeycloakLogoutUrl(systemBaseUrl, idToken));
+	// Volver al Workspace (App Launcher). Para cerrar la sesión del Hub por
+	// completo, el usuario cierra sesión desde el Workspace.
+	throw redirect(303, getWorkspaceLoginUrl());
 };