Merge pull request 'feature/AS-timbrado-cfdi-ingreso' (#10) from feature/AS-timbrado-cfdi-ingreso into main

Reviewed-on: #10

.env.example

@@ -112,3 +112,27 @@ SYNC_SECRET_TOKEN=change-this-sync-token-in-production
 
 # Lista de spokes (Solo si es HUB y desea retransmitir a otros - Opcional)
 SPOKE_URLS=""
+
+# ==================================
+# PAC COMERCIO DIGITAL (timbrado CFDI)
+# ==================================
+# El modo de timbrado se decide POR FACTURA, en fin.invoices.stamping_mode.
+# Esta variable solo fija con qué valor nacen las facturas que no lo especifican.
+# pruebas -> pruebas.comercio-digital.mx | produccion -> ws.comercio-digital.mx
+# Una factura en "produccion" emite un CFDI con validez fiscal real ante el SAT.
+PAC_DEFAULT_MODE=pruebas
+# Credenciales del web service (headers usrws / pwdws). NO commitear valores reales:
+# van en .env, que está en .gitignore.
+PAC_USER=
+PAC_PASSWORD=
+# Opcional: correo al que el PAC notifica el comprobante (header email).
+PAC_NOTIFICATION_EMAIL=
+# Clave maestra que cifra las contraseñas de los CSD en la base de datos. OBLIGATORIA para
+# poder cargar certificados desde Configuración de Facturación. Generarla con:
+#   python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
+# Si se cambia, las contraseñas ya guardadas dejan de poder descifrarse y hay que recargar
+# los certificados.
+CSD_ENCRYPTION_KEY=
+# LEGADO: contraseña global del CSD. Sólo se usa como respaldo si una empresa no tiene la
+# suya guardada. Lo correcto es cargar el CSD por empresa desde la interfaz.
+CSD_PASSWORD=

.gitignore

@@ -84,3 +84,8 @@ celerybeat-schedule.*
 celerybeat.pid
 backend/api/v1/modules/reports/generated/
 docker-compose.override.yml
+
+SUNRISE/
+# Corredor de la corrida autonoma continua: vive local, no se versiona.
+automatizacion/
+docker-compose.dev.yml

backend/alembic/versions/a0b1c2d3e4f5_quote_settings_and_pdf.py

@@ -0,0 +1,60 @@
+"""crm quote_settings (marca por tenant) + quotes.pdf_file_key
+
+Revision ID: a0b1c2d3e4f5
+Revises: f8a9b0c1d2e3
+Create Date: 2026-07-29 00:00:00.000000
+
+PDF de cotización con formato maestro + branding por tenant + envío por correo.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "a0b1c2d3e4f5"
+down_revision: Union[str, None] = "f8a9b0c1d2e3"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+SCHEMA = "crm"
+
+
+def upgrade() -> None:
+    op.add_column("quotes", sa.Column("pdf_file_key", sa.String(length=512), nullable=True), schema=SCHEMA)
+
+    op.create_table(
+        "quote_settings",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("emitter_name", sa.String(length=255), nullable=True),
+        sa.Column("emitter_rfc", sa.String(length=13), nullable=True),
+        sa.Column("emitter_address", sa.Text(), nullable=True),
+        sa.Column("emitter_phone", sa.String(length=60), nullable=True),
+        sa.Column("emitter_email", sa.String(length=255), nullable=True),
+        sa.Column("emitter_website", sa.String(length=255), nullable=True),
+        sa.Column("logo_file_key", sa.String(length=512), nullable=True),
+        sa.Column("accent_color", sa.String(length=9), nullable=True, server_default=sa.text("'#2f6bf0'")),
+        sa.Column("quote_prefix", sa.String(length=12), nullable=True, server_default=sa.text("'COT'")),
+        sa.Column("default_terms", sa.Text(), nullable=True),
+        sa.Column("footer_note", sa.Text(), nullable=True),
+        sa.Column("tenant_id", sa.Integer(), nullable=False),
+        sa.Column("company_id", sa.Integer(), nullable=False),
+        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.Column("deleted_at", sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+        sa.ForeignKeyConstraint(["tenant_id"], ["core.tenants.id"]),
+        schema=SCHEMA,
+    )
+    op.create_index("ix_crm_quote_settings_id", "quote_settings", ["id"], schema=SCHEMA)
+    op.create_index("ix_crm_quote_settings_tenant_id", "quote_settings", ["tenant_id"], schema=SCHEMA)
+    op.create_index("ix_crm_quote_settings_company_id", "quote_settings", ["company_id"], schema=SCHEMA)
+    # Una configuración por compañía
+    op.create_index(
+        "uq_crm_quote_settings_company", "quote_settings", ["tenant_id", "company_id"],
+        unique=True, schema=SCHEMA, postgresql_where=sa.text("deleted_at IS NULL"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("quote_settings", schema=SCHEMA)
+    op.drop_column("quotes", "pdf_file_key", schema=SCHEMA)

backend/alembic/versions/b1c2d3e4f5a6_service_request_quote_fields.py

@@ -0,0 +1,158 @@
+"""Campos del documento maestro de cotización en la solicitud + folios del ciclo comercial
+
+Revision ID: b1c2d3e4f5a6
+Revises: a0b1c2d3e4f5
+Create Date: 2026-08-03 00:00:00.000000
+
+Amplía crm.service_requests con los campos que exige el documento maestro de
+cotización, agrega los back-links y la dirección impo/expo del ciclo
+Oportunidad→Solicitud→Cotización→Operación, y crea crm.folio_counters para los
+folios auto-generados ({LETRA}{AAAA}-{MM}-{NNN}-{DIR}).
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "b1c2d3e4f5a6"
+down_revision: Union[str, None] = "a0b1c2d3e4f5"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+SCHEMA = "crm"
+
+# Columnas nuevas de crm.service_requests (nombre, tipo, kwargs).
+_SR_COLUMNS = [
+    ("contact_id", sa.Integer(), {}),
+    ("request_date", sa.Date(), {}),
+    ("currency", sa.String(length=3), {}),
+    ("priority", sa.String(length=20), {}),
+    ("origin_country", sa.String(length=3), {}),
+    ("origin_city", sa.String(length=120), {}),
+    ("origin_port", sa.String(length=20), {}),
+    ("destination_country", sa.String(length=3), {}),
+    ("destination_city", sa.String(length=120), {}),
+    ("destination_port", sa.String(length=20), {}),
+    ("pickup_location", sa.String(length=255), {}),
+    ("delivery_location", sa.String(length=255), {}),
+    ("estimated_shipment_date", sa.Date(), {}),
+    ("cargo_value", sa.Numeric(14, 2), {}),
+    ("insurance_required", sa.Boolean(), {"server_default": sa.text("false")}),
+    ("hs_code", sa.String(length=20), {}),
+    ("goods_origin_country", sa.String(length=3), {}),
+    ("hazardous_imo", sa.Boolean(), {"server_default": sa.text("false")}),
+    ("refrigerated", sa.Boolean(), {"server_default": sa.text("false")}),
+    ("stackable", sa.Boolean(), {"server_default": sa.text("false")}),
+    ("pieces_count", sa.Integer(), {}),
+    ("boxes_count", sa.Integer(), {}),
+    ("pallets_count", sa.Integer(), {}),
+    ("net_weight", sa.Numeric(14, 3), {}),
+    ("length_cm", sa.Numeric(10, 2), {}),
+    ("width_cm", sa.Numeric(10, 2), {}),
+    ("height_cm", sa.Numeric(10, 2), {}),
+    ("measurement_unit", sa.String(length=20), {}),
+    ("container_count", sa.Integer(), {}),
+    ("packaging_type", sa.String(length=20), {}),
+    ("oversized", sa.Boolean(), {"server_default": sa.text("false")}),
+    ("weight_per_pallet", sa.Numeric(14, 3), {}),
+    ("volume_per_pallet", sa.Numeric(14, 3), {}),
+    ("additional_services", sa.JSON(), {}),
+    ("payment_method", sa.String(length=20), {}),
+    ("client_notes", sa.Text(), {}),
+    ("internal_notes", sa.Text(), {}),
+]
+
+
+def upgrade() -> None:
+    # ----- crm.service_requests: campos del documento maestro de cotización -----
+    for name, col_type, kwargs in _SR_COLUMNS:
+        nullable = "server_default" not in kwargs  # los boolean quedan NOT NULL con default false
+        op.add_column(
+            "service_requests",
+            sa.Column(name, col_type, nullable=nullable, **kwargs),
+            schema=SCHEMA,
+        )
+    op.create_foreign_key(
+        "fk_crm_service_requests_contact_id", "service_requests", "contacts",
+        ["contact_id"], ["id"], source_schema=SCHEMA, referent_schema=SCHEMA,
+    )
+    op.create_index(
+        "ix_crm_service_requests_contact_id", "service_requests", ["contact_id"], schema=SCHEMA
+    )
+
+    # ----- crm.documents: adjuntos de una solicitud -----
+    op.add_column(
+        "documents", sa.Column("service_request_id", sa.Integer(), nullable=True), schema=SCHEMA
+    )
+    op.create_foreign_key(
+        "fk_crm_documents_service_request_id", "documents", "service_requests",
+        ["service_request_id"], ["id"], source_schema=SCHEMA, referent_schema=SCHEMA,
+    )
+    op.create_index(
+        "ix_crm_documents_service_request_id", "documents", ["service_request_id"], schema=SCHEMA
+    )
+
+    # ----- crm.opportunities: dirección impo/expo + folio + back-link a la solicitud -----
+    op.add_column("opportunities", sa.Column("operation_type", sa.String(length=20), nullable=True), schema=SCHEMA)
+    op.add_column("opportunities", sa.Column("reference", sa.String(length=40), nullable=True), schema=SCHEMA)
+    op.add_column(
+        "opportunities",
+        sa.Column("converted_service_request_id", sa.Integer(), nullable=True),
+        schema=SCHEMA,
+    )
+    op.create_foreign_key(
+        "fk_crm_opportunities_converted_sr", "opportunities", "service_requests",
+        ["converted_service_request_id"], ["id"], source_schema=SCHEMA, referent_schema=SCHEMA,
+    )
+    op.create_index(
+        "ix_crm_opportunities_reference", "opportunities", ["reference"], schema=SCHEMA
+    )
+
+    # ----- crm.quotes: variante FCL/LCL para la comparación "Ambas" -----
+    op.add_column("quotes", sa.Column("load_type", sa.String(length=10), nullable=True), schema=SCHEMA)
+
+    # ----- crm.folio_counters: consecutivo mensual por compañía y entidad -----
+    op.create_table(
+        "folio_counters",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("entity", sa.String(length=4), nullable=False),
+        sa.Column("period", sa.String(length=7), nullable=False),
+        sa.Column("last_number", sa.Integer(), nullable=False, server_default=sa.text("0")),
+        sa.Column("tenant_id", sa.Integer(), nullable=False),
+        sa.Column("company_id", sa.Integer(), nullable=False),
+        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"),
+        sa.ForeignKeyConstraint(["tenant_id"], ["core.tenants.id"]),
+        sa.UniqueConstraint(
+            "tenant_id", "company_id", "entity", "period", name="uq_crm_folio_counters_scope"
+        ),
+        schema=SCHEMA,
+    )
+    op.create_index("ix_crm_folio_counters_id", "folio_counters", ["id"], schema=SCHEMA)
+    op.create_index("ix_crm_folio_counters_tenant_id", "folio_counters", ["tenant_id"], schema=SCHEMA)
+    op.create_index("ix_crm_folio_counters_company_id", "folio_counters", ["company_id"], schema=SCHEMA)
+
+
+def downgrade() -> None:
+    op.drop_index("ix_crm_folio_counters_company_id", table_name="folio_counters", schema=SCHEMA)
+    op.drop_index("ix_crm_folio_counters_tenant_id", table_name="folio_counters", schema=SCHEMA)
+    op.drop_index("ix_crm_folio_counters_id", table_name="folio_counters", schema=SCHEMA)
+    op.drop_table("folio_counters", schema=SCHEMA)
+
+    op.drop_column("quotes", "load_type", schema=SCHEMA)
+
+    op.drop_index("ix_crm_opportunities_reference", table_name="opportunities", schema=SCHEMA)
+    op.drop_constraint("fk_crm_opportunities_converted_sr", "opportunities", schema=SCHEMA, type_="foreignkey")
+    op.drop_column("opportunities", "converted_service_request_id", schema=SCHEMA)
+    op.drop_column("opportunities", "reference", schema=SCHEMA)
+    op.drop_column("opportunities", "operation_type", schema=SCHEMA)
+
+    op.drop_index("ix_crm_documents_service_request_id", table_name="documents", schema=SCHEMA)
+    op.drop_constraint("fk_crm_documents_service_request_id", "documents", schema=SCHEMA, type_="foreignkey")
+    op.drop_column("documents", "service_request_id", schema=SCHEMA)
+
+    op.drop_index("ix_crm_service_requests_contact_id", table_name="service_requests", schema=SCHEMA)
+    op.drop_constraint("fk_crm_service_requests_contact_id", "service_requests", schema=SCHEMA, type_="foreignkey")
+    for name, _col_type, _kwargs in reversed(_SR_COLUMNS):
+        op.drop_column("service_requests", name, schema=SCHEMA)

backend/alembic/versions/c2d3e4f5a6b7_service_request_additional_service_costs.py

@@ -0,0 +1,33 @@
+"""Costo estimado por servicio adicional en la solicitud de servicio
+
+Revision ID: c2d3e4f5a6b7
+Revises: b1c2d3e4f5a6
+Create Date: 2026-08-04 00:00:00.000000
+
+Agrega crm.service_requests.additional_service_costs (JSON: {codigo_servicio: costo})
+para capturar el costo estimado de cada servicio adicional marcado; ese costo se
+usa como punto de partida al sembrar los conceptos de la cotización.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "c2d3e4f5a6b7"
+down_revision: Union[str, None] = "b1c2d3e4f5a6"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+SCHEMA = "crm"
+
+
+def upgrade() -> None:
+    op.add_column(
+        "service_requests",
+        sa.Column("additional_service_costs", sa.JSON(), nullable=True),
+        schema=SCHEMA,
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("service_requests", "additional_service_costs", schema=SCHEMA)

backend/alembic/versions/c5d6e7f8a9b0_crm_carril_efc.py

@@ -0,0 +1,180 @@
+"""Carril CRM -> EFC: columnas efc_* en crm.cases + outbox transaccional (dos tablas).
+
+El expediente NO se crea aquí: ya existe como ``crm.cases`` (ver d4e5f6a7b8c9), con su folio
+en ``reference`` y su consecutivo en ``crm.folio_counters``. Esta migración solo le cuelga lo
+que el carril hacia EFC necesita y crea el outbox. Es aditiva a propósito: la estructura del
+expediente es de quien la definió, nosotros aportamos la conexión.
+
+Las seis columnas ``efc_*`` son un ESPEJO de lo que hay en EFC, nunca el handle. El handle con
+el que el CRM habla de un expediente es su ``id`` y su ``reference``: ``efc_pedimento_id`` es
+un caché de la resolución y el ``pedimento_app`` del lado de EFC es mutable —se reescribe al
+completar el provisional—, así que apoyarse en él rompería en cuanto llegue la data real.
+
+``efc_storage_token`` es INMUTABLE una vez asignado: es la carpeta de MinIO donde EFC guarda
+los objetos de este expediente. Que no cambie nunca es lo que permite completar el pedimento
+sin mover un solo archivo.
+
+``efc_link_state`` nace en 'PENDING' para las filas que ya existen. Eso es deliberado: al
+encender el carril, el barrido de respaldo replica el histórico. Mientras ``EFC_API_URL`` esté
+vacía el carril está apagado y no se encola nada.
+
+Revision ID: c5d6e7f8a9b0
+Revises: d4e5f6a7b8c9
+Create Date: 2026-08-10 00:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "c5d6e7f8a9b0"
+down_revision: Union[str, None] = "d4e5f6a7b8c9"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ---------- crm.cases: el espejo de EFC ----------
+    op.add_column("cases", sa.Column("efc_organizacion_id", sa.String(length=36), nullable=True), schema="crm")
+    op.add_column("cases", sa.Column("efc_pedimento_id", sa.String(length=36), nullable=True), schema="crm")
+    op.add_column("cases", sa.Column("efc_storage_token", sa.String(length=25), nullable=True), schema="crm")
+    op.add_column(
+        "cases",
+        # PENDING | LINKED | FAILED
+        sa.Column("efc_link_state", sa.String(length=20), nullable=False, server_default=sa.text("'PENDING'")),
+        schema="crm",
+    )
+    # El diagnóstico se guarda en la fila para que se vea en la ficha del expediente, sin
+    # obligar a nadie a ir a los logs del worker.
+    op.add_column("cases", sa.Column("efc_error_code", sa.String(length=60), nullable=True), schema="crm")
+    op.add_column("cases", sa.Column("efc_error_detail", sa.Text(), nullable=True), schema="crm")
+    op.create_index("ix_crm_cases_efc_link_state", "cases", ["efc_link_state"], schema="crm")
+
+    # Relleno del token para los expedientes que ya existían. Sin esto, el barrido de
+    # reconciliación los encola, EFC los rechaza con
+    # {'storage_token': ['This field may not be null.']} y agotan sus 8 intentos hasta
+    # quedar en `failed`: ruido permanente por un dato que se podía derivar.
+    #
+    # La condición de longitud replica la guarda de storage_token(): en los 25 caracteres de
+    # `pedimento_app` caben hasta 6 dígitos de company. Lo que no cabe se queda NULL a
+    # propósito y el encolado lo salta avisando, porque un token recortado apuntaría a la
+    # carpeta de otro expediente y mezclaría documentos en silencio.
+    #
+    # `reference IS NOT NULL` porque el folio es nullable en crm.cases: un expediente sin
+    # folio no tiene con qué identificarse ante EFC.
+    op.execute(
+        """
+        UPDATE crm.cases
+           SET efc_storage_token = 'CRM-' || company_id::text || '-' || reference
+         WHERE efc_storage_token IS NULL
+           AND reference IS NOT NULL
+           AND length('CRM-' || company_id::text || '-' || reference) <= 25
+        """
+    )
+
+    # ---------- crm.efc_sync_outbox: metadatos (alta del provisional y completado) ----------
+    op.create_table(
+        "efc_sync_outbox",
+        sa.Column("id", sa.Integer(), nullable=False, autoincrement=True),
+        sa.Column("kind", sa.String(length=20), nullable=False),
+        sa.Column("payload", sa.JSON(), nullable=False),
+        sa.Column("expediente_ref", sa.Integer(), nullable=True),
+        sa.Column("status", sa.String(length=10), nullable=False, server_default=sa.text("'pending'")),
+        sa.Column("attempts", sa.Integer(), nullable=False, server_default=sa.text("0")),
+        sa.Column("last_error", sa.Text(), nullable=True),
+        sa.Column("sent_at", sa.DateTime(), nullable=True),
+        sa.Column("efc_pedimento_id", sa.String(length=36), nullable=True),
+        sa.Column("tenant_id", sa.Integer(), nullable=False),
+        sa.Column("company_id", sa.Integer(), nullable=False),
+        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.Column("deleted_at", sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+        schema="crm",
+    )
+    op.create_index("ix_crm_efc_sync_outbox_status", "efc_sync_outbox", ["status"], schema="crm")
+    op.create_index("ix_crm_efc_sync_outbox_kind_status", "efc_sync_outbox", ["kind", "status"], schema="crm")
+    op.create_index("ix_crm_efc_sync_outbox_expediente_ref", "efc_sync_outbox", ["expediente_ref"], schema="crm")
+    op.create_index("ix_crm_efc_sync_outbox_tenant_id", "efc_sync_outbox", ["tenant_id"], schema="crm")
+    op.create_index("ix_crm_efc_sync_outbox_company_id", "efc_sync_outbox", ["company_id"], schema="crm")
+    op.create_foreign_key(
+        "fk_crm_efc_sync_outbox_tenant_id", "efc_sync_outbox", "tenants",
+        ["tenant_id"], ["id"], source_schema="crm", referent_schema="core",
+    )
+
+    # ---------- crm.efc_file_outbox: archivos ----------
+    op.create_table(
+        "efc_file_outbox",
+        sa.Column("id", sa.Integer(), nullable=False, autoincrement=True),
+        sa.Column("kind", sa.String(length=30), nullable=False),
+        sa.Column("s3_key", sa.String(length=1024), nullable=False),
+        sa.Column("file_name", sa.String(length=255), nullable=False),
+        sa.Column("content_type", sa.String(length=100), nullable=True),
+        sa.Column("efc_tipo", sa.String(length=40), nullable=False),
+        # La pareja (tabla, id) desambigua entre las DOS secuencias de documentos del CRM:
+        # crm.documents.id = 5 y ops.shipment_documents.id = 5 coexisten.
+        sa.Column("source_table", sa.String(length=30), nullable=False),
+        sa.Column("source_id", sa.Integer(), nullable=True),
+        sa.Column("crm_document_ref", sa.String(length=64), nullable=True),
+        sa.Column("expediente_ref", sa.Integer(), nullable=False),
+        sa.Column("delete_local", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+        sa.Column("status", sa.String(length=10), nullable=False, server_default=sa.text("'pending'")),
+        sa.Column("attempts", sa.Integer(), nullable=False, server_default=sa.text("0")),
+        sa.Column("last_error", sa.Text(), nullable=True),
+        sa.Column("sent_at", sa.DateTime(), nullable=True),
+        sa.Column("efc_document_id", sa.String(length=36), nullable=True),
+        sa.Column("tenant_id", sa.Integer(), nullable=False),
+        sa.Column("company_id", sa.Integer(), nullable=False),
+        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.Column("deleted_at", sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+        schema="crm",
+    )
+    op.create_index("ix_crm_efc_file_outbox_status", "efc_file_outbox", ["status"], schema="crm")
+    op.create_index("ix_crm_efc_file_outbox_kind_status", "efc_file_outbox", ["kind", "status"], schema="crm")
+    # Índice de la guarda _ya_entregado, que es lo que se consulta en cada encolado.
+    op.create_index("ix_crm_efc_file_outbox_source", "efc_file_outbox", ["source_table", "source_id"], schema="crm")
+    op.create_index("ix_crm_efc_file_outbox_expediente_ref", "efc_file_outbox", ["expediente_ref"], schema="crm")
+    op.create_index("ix_crm_efc_file_outbox_tenant_id", "efc_file_outbox", ["tenant_id"], schema="crm")
+    op.create_index("ix_crm_efc_file_outbox_company_id", "efc_file_outbox", ["company_id"], schema="crm")
+    op.create_foreign_key(
+        "fk_crm_efc_file_outbox_tenant_id", "efc_file_outbox", "tenants",
+        ["tenant_id"], ["id"], source_schema="crm", referent_schema="core",
+    )
+    # expediente_ref -> crm.cases.id. El nombre de la columna conserva el término del dominio:
+    # crm.cases ES el expediente (así lo nombra su propio docstring), y el carril, EFC y el
+    # ticket hablan de expedientes. Renombrarlo a case_ref solo movería la ambigüedad de sitio.
+    op.create_foreign_key(
+        "fk_crm_efc_file_outbox_expediente_ref", "efc_file_outbox", "cases",
+        ["expediente_ref"], ["id"], source_schema="crm", referent_schema="crm",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint("fk_crm_efc_file_outbox_expediente_ref", "efc_file_outbox", schema="crm", type_="foreignkey")
+    op.drop_constraint("fk_crm_efc_file_outbox_tenant_id", "efc_file_outbox", schema="crm", type_="foreignkey")
+    op.drop_index("ix_crm_efc_file_outbox_company_id", table_name="efc_file_outbox", schema="crm")
+    op.drop_index("ix_crm_efc_file_outbox_tenant_id", table_name="efc_file_outbox", schema="crm")
+    op.drop_index("ix_crm_efc_file_outbox_expediente_ref", table_name="efc_file_outbox", schema="crm")
+    op.drop_index("ix_crm_efc_file_outbox_source", table_name="efc_file_outbox", schema="crm")
+    op.drop_index("ix_crm_efc_file_outbox_kind_status", table_name="efc_file_outbox", schema="crm")
+    op.drop_index("ix_crm_efc_file_outbox_status", table_name="efc_file_outbox", schema="crm")
+    op.drop_table("efc_file_outbox", schema="crm")
+
+    op.drop_constraint("fk_crm_efc_sync_outbox_tenant_id", "efc_sync_outbox", schema="crm", type_="foreignkey")
+    op.drop_index("ix_crm_efc_sync_outbox_company_id", table_name="efc_sync_outbox", schema="crm")
+    op.drop_index("ix_crm_efc_sync_outbox_tenant_id", table_name="efc_sync_outbox", schema="crm")
+    op.drop_index("ix_crm_efc_sync_outbox_expediente_ref", table_name="efc_sync_outbox", schema="crm")
+    op.drop_index("ix_crm_efc_sync_outbox_kind_status", table_name="efc_sync_outbox", schema="crm")
+    op.drop_index("ix_crm_efc_sync_outbox_status", table_name="efc_sync_outbox", schema="crm")
+    op.drop_table("efc_sync_outbox", schema="crm")
+
+    op.drop_index("ix_crm_cases_efc_link_state", table_name="cases", schema="crm")
+    op.drop_column("cases", "efc_error_detail", schema="crm")
+    op.drop_column("cases", "efc_error_code", schema="crm")
+    op.drop_column("cases", "efc_link_state", schema="crm")
+    op.drop_column("cases", "efc_storage_token", schema="crm")
+    op.drop_column("cases", "efc_pedimento_id", schema="crm")
+    op.drop_column("cases", "efc_organizacion_id", schema="crm")

backend/alembic/versions/d3e4f5a6b7c8_session_fixes_accounts_forma_pago.py

@@ -0,0 +1,56 @@
+"""Ajustes de sesión: país ISO-3 en accounts, giro "otro" y formas de pago SAT a 2 dígitos
+
+Revision ID: d3e4f5a6b7c8
+Revises: c2d3e4f5a6b7
+Create Date: 2026-08-04 01:00:00.000000
+
+- crm.accounts.country String(2)→String(3) (ISO alfa-3, alineado a catálogo pais).
+- crm.accounts.industry_other (especificar cuando el giro es "otro").
+- Normaliza formas de pago SAT de 1 dígito a 2 (01, 02, …) en el catálogo y en
+  los valores guardados en accounts/suppliers; y país 'MX'→'MEX'.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "d3e4f5a6b7c8"
+down_revision: Union[str, None] = "c2d3e4f5a6b7"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+SCHEMA = "crm"
+
+
+def upgrade() -> None:
+    # País a ISO alfa-3 en accounts (addresses ya es String(3)).
+    # Primero se amplía la columna; luego se normaliza el dato (evita truncamiento).
+    op.alter_column(
+        "accounts", "country", schema=SCHEMA,
+        existing_type=sa.String(length=2), type_=sa.String(length=3),
+        existing_nullable=True, server_default=sa.text("'MEX'"),
+    )
+    op.execute("UPDATE crm.accounts SET country = 'MEX' WHERE country = 'MX'")
+    op.execute("UPDATE crm.addresses SET country = 'MEX' WHERE country = 'MX'")
+    # Giro "otro" — campo para especificar
+    op.add_column("accounts", sa.Column("industry_other", sa.String(length=120), nullable=True), schema=SCHEMA)
+
+    # Formas de pago SAT: 1 dígito → 2 dígitos (catálogo + valores guardados)
+    op.execute(
+        "UPDATE crm.catalog_items SET code = lpad(code, 2, '0') "
+        "WHERE catalog = 'forma_pago' AND char_length(code) = 1"
+    )
+    op.execute("UPDATE crm.accounts SET payment_form = lpad(payment_form, 2, '0') WHERE char_length(payment_form) = 1")
+    op.execute("UPDATE crm.suppliers SET payment_form = lpad(payment_form, 2, '0') WHERE char_length(payment_form) = 1")
+
+
+def downgrade() -> None:
+    op.drop_column("accounts", "industry_other", schema=SCHEMA)
+    # Regresar país a String(2) sin truncar filas existentes
+    op.execute("UPDATE crm.accounts SET country = 'MX' WHERE country = 'MEX'")
+    op.alter_column(
+        "accounts", "country", schema=SCHEMA,
+        existing_type=sa.String(length=3), type_=sa.String(length=2),
+        existing_nullable=True, server_default=sa.text("'MX'"),
+    )
+    # La normalización de formas de pago no se revierte (evita romper códigos multi-dígito).

backend/alembic/versions/d4e5f6a7b8c9_case_expediente.py

@@ -0,0 +1,75 @@
+"""Expediente (crm.cases) + case_id en el ciclo comercial
+
+Revision ID: d4e5f6a7b8c9
+Revises: f0a1b2c3d4e5
+Create Date: 2026-08-07 02:00:00.000000
+
+Crea crm.cases (expediente, hilo maestro con folio EXP...) y agrega case_id a
+crm.opportunities/service_requests/quotes, ops.shipments y fin.invoices.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "d4e5f6a7b8c9"
+down_revision: Union[str, None] = "f0a1b2c3d4e5"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+# (schema, tabla) donde se agrega case_id
+_CASE_FK_TABLES = [
+    ("crm", "opportunities"),
+    ("crm", "service_requests"),
+    ("crm", "quotes"),
+    ("ops", "shipments"),
+    ("fin", "invoices"),
+]
+
+
+def upgrade() -> None:
+    op.create_table(
+        "cases",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("reference", sa.String(length=40), nullable=True),
+        sa.Column("account_id", sa.Integer(), nullable=True),
+        sa.Column("title", sa.String(length=255), nullable=True),
+        sa.Column("stage", sa.String(length=20), nullable=False, server_default=sa.text("'oportunidad'")),
+        sa.Column("status", sa.String(length=20), nullable=False, server_default=sa.text("'abierto'")),
+        sa.Column("created_by", sa.String(length=64), nullable=True),
+        sa.Column("updated_by", sa.String(length=64), nullable=True),
+        sa.Column("tenant_id", sa.Integer(), nullable=False),
+        sa.Column("company_id", sa.Integer(), nullable=False),
+        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.Column("deleted_at", sa.DateTime(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+        sa.ForeignKeyConstraint(["tenant_id"], ["core.tenants.id"]),
+        sa.ForeignKeyConstraint(["account_id"], ["crm.accounts.id"]),
+        schema="crm",
+    )
+    op.create_index("ix_crm_cases_id", "cases", ["id"], schema="crm")
+    op.create_index("ix_crm_cases_reference", "cases", ["reference"], schema="crm")
+    op.create_index("ix_crm_cases_tenant_id", "cases", ["tenant_id"], schema="crm")
+    op.create_index("ix_crm_cases_company_id", "cases", ["company_id"], schema="crm")
+    op.create_index("ix_crm_cases_account_id", "cases", ["account_id"], schema="crm")
+    op.create_index("ix_crm_cases_status", "cases", ["status"], schema="crm")
+
+    for schema, table in _CASE_FK_TABLES:
+        op.add_column(table, sa.Column("case_id", sa.Integer(), nullable=True), schema=schema)
+        op.create_index(f"ix_{schema}_{table}_case_id", table, ["case_id"], schema=schema)
+        op.create_foreign_key(
+            f"fk_{schema}_{table}_case_id", table, "cases",
+            ["case_id"], ["id"], source_schema=schema, referent_schema="crm",
+        )
+
+
+def downgrade() -> None:
+    for schema, table in _CASE_FK_TABLES:
+        op.drop_constraint(f"fk_{schema}_{table}_case_id", table, schema=schema, type_="foreignkey")
+        op.drop_index(f"ix_{schema}_{table}_case_id", table_name=table, schema=schema)
+        op.drop_column(table, "case_id", schema=schema)
+
+    for idx in ("status", "account_id", "company_id", "tenant_id", "reference", "id"):
+        op.drop_index(f"ix_crm_cases_{idx}", table_name="cases", schema="crm")
+    op.drop_table("cases", schema="crm")

backend/alembic/versions/e4f5a6b7c8d9_opportunity_won_lost_dates.py

@@ -0,0 +1,30 @@
+"""Fechas separadas de ganada/perdida en la oportunidad
+
+Revision ID: e4f5a6b7c8d9
+Revises: d3e4f5a6b7c8
+Create Date: 2026-08-04 02:00:00.000000
+
+Agrega crm.opportunities.won_date y lost_date (fechas de cierre separadas,
+editables) además de closed_at y lost_reason ya existentes.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "e4f5a6b7c8d9"
+down_revision: Union[str, None] = "d3e4f5a6b7c8"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+SCHEMA = "crm"
+
+
+def upgrade() -> None:
+    op.add_column("opportunities", sa.Column("won_date", sa.Date(), nullable=True), schema=SCHEMA)
+    op.add_column("opportunities", sa.Column("lost_date", sa.Date(), nullable=True), schema=SCHEMA)
+
+
+def downgrade() -> None:
+    op.drop_column("opportunities", "lost_date", schema=SCHEMA)
+    op.drop_column("opportunities", "won_date", schema=SCHEMA)

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/alembic/versions/f0a1b2c3d4e5_lead_preferred_contact_method.py

@@ -0,0 +1,25 @@
+"""Medio de contacto preferido en el prospecto (lead)
+
+Revision ID: f0a1b2c3d4e5
+Revises: e4f5a6b7c8d9
+Create Date: 2026-08-07 01:00:00.000000
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "f0a1b2c3d4e5"
+down_revision: Union[str, None] = "e4f5a6b7c8d9"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+SCHEMA = "crm"
+
+
+def upgrade() -> None:
+    op.add_column("leads", sa.Column("preferred_contact_method", sa.String(length=20), nullable=True), schema=SCHEMA)
+
+
+def downgrade() -> None:
+    op.drop_column("leads", "preferred_contact_method", schema=SCHEMA)

backend/alembic/versions/f7a8b9c0d1e2_sat_cfdi_uses_and_account_fiscal_fks.py

@@ -0,0 +1,88 @@
+"""Catálogo c_UsoCFDI y claves fiscales del receptor en crm.accounts.
+
+Cierra las decisiones pendientes 1 y 5 del ticket de catálogos SAT: agrega
+``sat.cfdi_uses`` y amarra el régimen fiscal y el uso de CFDI de la cuenta a los
+catálogos, conservando las columnas de texto libre que ya existían.
+
+Re-encadenada al integrar main: esta rama y la del CRM habían salido las dos de
+d5e6f7a8b9c0, y con dos cabezas ``alembic upgrade head`` falla. La historia queda lineal,
+con las migraciones de facturación detrás de las del CRM.
+
+Revision ID: f7a8b9c0d1e2
+Revises: g1h2i3j4k5l6
+Create Date: 2026-08-07 00:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+from api.v1.modules.fin.catalogs.seed_data import sync_catalogs
+
+revision: str = "f7a8b9c0d1e2"
+down_revision: Union[str, None] = "g1h2i3j4k5l6"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ---------- sat.cfdi_uses ----------
+    op.create_table(
+        "cfdi_uses",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("code", sa.String(length=4), nullable=False),
+        sa.Column("description", sa.String(length=500), nullable=False),
+        sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.text("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="sat",
+    )
+    op.create_index("ix_sat_cfdi_uses_id", "cfdi_uses", ["id"], schema="sat")
+    op.create_index("ix_sat_cfdi_uses_code", "cfdi_uses", ["code"], unique=True, schema="sat")
+
+    # sync_catalogs es idempotente: siembra c_UsoCFDI y deja intactos los catálogos
+    # que ya sembró la migración anterior.
+    sync_catalogs(op.get_bind())
+
+    # ---------- crm.accounts: claves fiscales del receptor ----------
+    # Nullables: las cuentas existentes solo tienen el texto libre.
+    op.add_column("accounts", sa.Column("tax_regime_id", sa.Integer(), nullable=True), schema="crm")
+    op.add_column("accounts", sa.Column("cfdi_use_id", sa.Integer(), nullable=True), schema="crm")
+    op.create_foreign_key(
+        "fk_crm_accounts_tax_regime_id", "accounts", "tax_regimes",
+        ["tax_regime_id"], ["id"], source_schema="crm", referent_schema="sat",
+    )
+    op.create_foreign_key(
+        "fk_crm_accounts_cfdi_use_id", "accounts", "cfdi_uses",
+        ["cfdi_use_id"], ["id"], source_schema="crm", referent_schema="sat",
+    )
+
+    # Backfill conservador: solo resuelve lo inequívoco. Se compara el texto libre
+    # contra la clave del catálogo (p. ej. "601", "G03") y contra la descripción
+    # exacta, sin distinguir mayúsculas ni espacios sobrantes. Lo que no case así se
+    # queda en NULL para que lo revise el usuario: adivinar el régimen de un receptor
+    # a partir de texto libre provoca CFDI rechazados.
+    for column, catalog in [("tax_regime", "tax_regimes"), ("cfdi_use", "cfdi_uses")]:
+        op.execute(
+            f"""
+            UPDATE crm.accounts AS a
+               SET {column}_id = c.id
+              FROM sat.{catalog} AS c
+             WHERE a.{column}_id IS NULL
+               AND a.{column} IS NOT NULL
+               AND (
+                     upper(btrim(a.{column})) = upper(c.code)
+                  OR upper(btrim(a.{column})) = upper(c.description)
+               )
+            """
+        )
+
+
+def downgrade() -> None:
+    op.drop_constraint("fk_crm_accounts_cfdi_use_id", "accounts", schema="crm", type_="foreignkey")
+    op.drop_constraint("fk_crm_accounts_tax_regime_id", "accounts", schema="crm", type_="foreignkey")
+    op.drop_column("accounts", "cfdi_use_id", schema="crm")
+    op.drop_column("accounts", "tax_regime_id", schema="crm")
+    op.drop_table("cfdi_uses", schema="sat")

backend/alembic/versions/f8a9b0c1d2e3_crm_rates.py

@@ -0,0 +1,131 @@
+"""crm rates: tarifarios (rate_sheets/lanes/breaks/charges)
+
+Revision ID: f8a9b0c1d2e3
+Revises: e7f8a9b0c1d2
+Create Date: 2026-07-27 00:00:00.000000
+
+Módulo Tarifario: base de costos para Cotizaciones (import por Excel + motor de costeo).
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "f8a9b0c1d2e3"
+down_revision: Union[str, None] = "e7f8a9b0c1d2"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+SCHEMA = "crm"
+
+
+def _scoped() -> list[sa.Column]:
+    return [
+        sa.Column("tenant_id", sa.Integer(), nullable=False),
+        sa.Column("company_id", sa.Integer(), nullable=False),
+        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.Column("deleted_at", sa.DateTime(), nullable=True),
+    ]
+
+
+def _idx(table: str) -> None:
+    op.create_index(f"ix_{SCHEMA}_{table}_id", table, ["id"], schema=SCHEMA)
+    op.create_index(f"ix_{SCHEMA}_{table}_tenant_id", table, ["tenant_id"], schema=SCHEMA)
+    op.create_index(f"ix_{SCHEMA}_{table}_company_id", table, ["company_id"], schema=SCHEMA)
+
+
+def upgrade() -> None:
+    # ----- rate_sheets -----
+    op.create_table(
+        "rate_sheets",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("supplier_id", sa.Integer(), nullable=True),
+        sa.Column("mode", sa.String(length=20), nullable=False),
+        sa.Column("name", sa.String(length=255), nullable=False),
+        sa.Column("currency", sa.String(length=3), nullable=True, server_default=sa.text("'USD'")),
+        sa.Column("valid_from", sa.Date(), nullable=True),
+        sa.Column("valid_to", sa.Date(), nullable=True),
+        sa.Column("default_origin", sa.String(length=20), nullable=True),
+        sa.Column("status", sa.String(length=20), nullable=False, server_default=sa.text("'borrador'")),
+        sa.Column("source_file", sa.String(length=512), nullable=True),
+        sa.Column("source_url", sa.String(length=1024), nullable=True),
+        sa.Column("notes", sa.Text(), nullable=True),
+        sa.Column("created_by", sa.String(length=64), nullable=True),
+        sa.Column("updated_by", sa.String(length=64), nullable=True),
+        *_scoped(),
+        sa.PrimaryKeyConstraint("id"),
+        sa.ForeignKeyConstraint(["tenant_id"], ["core.tenants.id"]),
+        sa.ForeignKeyConstraint(["supplier_id"], [f"{SCHEMA}.suppliers.id"]),
+        schema=SCHEMA,
+    )
+    _idx("rate_sheets")
+    op.create_index("ix_crm_rate_sheets_mode", "rate_sheets", ["mode"], schema=SCHEMA)
+    op.create_index("ix_crm_rate_sheets_supplier_id", "rate_sheets", ["supplier_id"], schema=SCHEMA)
+
+    # ----- rate_lanes -----
+    op.create_table(
+        "rate_lanes",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("rate_sheet_id", sa.Integer(), nullable=False),
+        sa.Column("origin", sa.String(length=20), nullable=True),
+        sa.Column("destination", sa.String(length=20), nullable=True),
+        sa.Column("region", sa.String(length=60), nullable=True),
+        sa.Column("equipment_type", sa.String(length=20), nullable=True),
+        sa.Column("rate_unit", sa.String(length=20), nullable=True),
+        sa.Column("min_charge", sa.Numeric(precision=14, scale=4), nullable=True),
+        sa.Column("flat_rate", sa.Numeric(precision=14, scale=4), nullable=True),
+        sa.Column("transit_days", sa.Integer(), nullable=True),
+        sa.Column("notes", sa.Text(), nullable=True),
+        *_scoped(),
+        sa.PrimaryKeyConstraint("id"),
+        sa.ForeignKeyConstraint(["tenant_id"], ["core.tenants.id"]),
+        sa.ForeignKeyConstraint(["rate_sheet_id"], [f"{SCHEMA}.rate_sheets.id"]),
+        schema=SCHEMA,
+    )
+    _idx("rate_lanes")
+    op.create_index("ix_crm_rate_lanes_rate_sheet_id", "rate_lanes", ["rate_sheet_id"], schema=SCHEMA)
+    op.create_index("ix_crm_rate_lanes_origin", "rate_lanes", ["origin"], schema=SCHEMA)
+    op.create_index("ix_crm_rate_lanes_destination", "rate_lanes", ["destination"], schema=SCHEMA)
+
+    # ----- rate_breaks -----
+    op.create_table(
+        "rate_breaks",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("rate_lane_id", sa.Integer(), nullable=False),
+        sa.Column("from_qty", sa.Numeric(precision=12, scale=3), nullable=False, server_default=sa.text("0")),
+        sa.Column("rate", sa.Numeric(precision=14, scale=4), nullable=False, server_default=sa.text("0")),
+        *_scoped(),
+        sa.PrimaryKeyConstraint("id"),
+        sa.ForeignKeyConstraint(["tenant_id"], ["core.tenants.id"]),
+        sa.ForeignKeyConstraint(["rate_lane_id"], [f"{SCHEMA}.rate_lanes.id"]),
+        schema=SCHEMA,
+    )
+    _idx("rate_breaks")
+    op.create_index("ix_crm_rate_breaks_rate_lane_id", "rate_breaks", ["rate_lane_id"], schema=SCHEMA)
+
+    # ----- rate_charges -----
+    op.create_table(
+        "rate_charges",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("rate_sheet_id", sa.Integer(), nullable=True),
+        sa.Column("rate_lane_id", sa.Integer(), nullable=True),
+        sa.Column("concept", sa.String(length=60), nullable=False),
+        sa.Column("charge_type", sa.String(length=20), nullable=False, server_default=sa.text("'fijo'")),
+        sa.Column("value", sa.Numeric(precision=14, scale=4), nullable=True),
+        sa.Column("condition", sa.Text(), nullable=True),
+        *_scoped(),
+        sa.PrimaryKeyConstraint("id"),
+        sa.ForeignKeyConstraint(["tenant_id"], ["core.tenants.id"]),
+        sa.ForeignKeyConstraint(["rate_sheet_id"], [f"{SCHEMA}.rate_sheets.id"]),
+        sa.ForeignKeyConstraint(["rate_lane_id"], [f"{SCHEMA}.rate_lanes.id"]),
+        schema=SCHEMA,
+    )
+    _idx("rate_charges")
+
+
+def downgrade() -> None:
+    op.drop_table("rate_charges", schema=SCHEMA)
+    op.drop_table("rate_breaks", schema=SCHEMA)
+    op.drop_table("rate_lanes", schema=SCHEMA)
+    op.drop_table("rate_sheets", schema=SCHEMA)

backend/alembic/versions/g1h2i3j4k5l6_fin_sat_catalogs_concepts_issuer.py

@@ -0,0 +1,274 @@
+"""Catálogos SAT (schema sat), conceptos de facturación, datos fiscales del emisor
+y amarre de facturas y partidas a los catálogos.
+
+Renumerada al integrar main: nació como e6f7a8b9c0d1, el mismo identificador que la
+migración de catálogos del CRM, porque ambas ramas salieron de d5e6f7a8b9c0 sin verse. Se
+renumera ésta y no la del CRM porque aquélla ya está en main y hay otra migración que la
+referencia por id.
+
+Revision ID: g1h2i3j4k5l6
+Revises: c5d6e7f8a9b0
+Create Date: 2026-08-07 00:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+from api.v1.modules.fin.catalogs.seed_data import sync_catalogs
+
+revision: str = "g1h2i3j4k5l6"
+down_revision: Union[str, None] = "c5d6e7f8a9b0"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+# Índices únicos parciales: la baja lógica (deleted_at) libera la clave.
+_ALIVE = "deleted_at IS NULL"
+
+# Catálogos del SAT: (tabla, longitud de code, columnas propias del catálogo).
+_SAT_CATALOGS: list[tuple[str, int, list[sa.Column]]] = [
+    ("tax_regimes", 3, [
+        sa.Column("applies_to_individual", sa.Boolean(), nullable=False, server_default=sa.text("false")),
+        sa.Column("applies_to_legal_entity", sa.Boolean(), nullable=False, server_default=sa.text("false")),
+    ]),
+    ("taxes", 3, [
+        sa.Column("is_withholding", sa.Boolean(), nullable=False, server_default=sa.text("false")),
+        sa.Column("is_transferred", sa.Boolean(), nullable=False, server_default=sa.text("false")),
+        sa.Column("is_local", sa.Boolean(), nullable=False, server_default=sa.text("false")),
+    ]),
+    ("payment_forms", 2, []),
+    ("units_of_measure", 20, [
+        sa.Column("name", sa.String(length=255), nullable=False),
+        sa.Column("symbol", sa.String(length=20), nullable=True),
+    ]),
+    ("products_services", 8, []),
+    ("voucher_types", 1, []),
+    ("payment_methods", 3, []),
+    ("tax_objects", 2, []),
+]
+
+# units_of_measure guarda el nombre corto aparte, así que su description es opcional.
+_NULLABLE_DESCRIPTION = {"units_of_measure"}
+
+
+def _timestamp_columns(with_soft_delete: bool) -> list[sa.Column]:
+    columns = [
+        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()")),
+    ]
+    if with_soft_delete:
+        columns.append(sa.Column("deleted_at", sa.DateTime(), nullable=True))
+    return columns
+
+
+def upgrade() -> None:
+    # ---------- Schema y catálogos globales del SAT ----------
+    op.execute("CREATE SCHEMA IF NOT EXISTS sat")
+
+    for table, code_length, extra_columns in _SAT_CATALOGS:
+        op.create_table(
+            table,
+            sa.Column("id", sa.Integer(), nullable=False),
+            sa.Column("code", sa.String(length=code_length), nullable=False),
+            sa.Column(
+                "description",
+                sa.String(length=500),
+                nullable=table in _NULLABLE_DESCRIPTION,
+            ),
+            sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+            *extra_columns,
+            *_timestamp_columns(with_soft_delete=False),
+            sa.PrimaryKeyConstraint("id"),
+            schema="sat",
+        )
+        op.create_index(f"ix_sat_{table}_id", table, ["id"], schema="sat")
+        # La clave oficial del SAT es única dentro de su catálogo.
+        op.create_index(f"ix_sat_{table}_code", table, ["code"], unique=True, schema="sat")
+
+    # Semillas de los catálogos (idempotente: puede volver a correrse sin duplicar).
+    sync_catalogs(op.get_bind())
+
+    # ---------- fin.concepts ----------
+    op.create_table(
+        "concepts",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("tenant_id", sa.Integer(), nullable=False),
+        sa.Column("company_id", sa.Integer(), nullable=False),
+        sa.Column("code", sa.String(length=40), nullable=False),
+        sa.Column("description", sa.String(length=500), nullable=False),
+        sa.Column("product_service_id", sa.Integer(), nullable=False),
+        sa.Column("unit_of_measure_id", sa.Integer(), nullable=True),
+        sa.Column("tax_object_id", sa.Integer(), nullable=True),
+        sa.Column("unit_price", sa.Numeric(precision=14, scale=2), nullable=True),
+        sa.Column("currency", sa.String(length=3), nullable=False, server_default=sa.text("'MXN'")),
+        sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+        sa.Column("notes", sa.Text(), nullable=True),
+        sa.Column("created_by", sa.String(length=64), nullable=True),
+        sa.Column("updated_by", sa.String(length=64), nullable=True),
+        *_timestamp_columns(with_soft_delete=True),
+        sa.PrimaryKeyConstraint("id"),
+        sa.ForeignKeyConstraint(["tenant_id"], ["core.tenants.id"], name="fk_fin_concepts_tenant_id"),
+        sa.ForeignKeyConstraint(
+            ["product_service_id"], ["sat.products_services.id"], name="fk_fin_concepts_product_service_id"
+        ),
+        sa.ForeignKeyConstraint(
+            ["unit_of_measure_id"], ["sat.units_of_measure.id"], name="fk_fin_concepts_unit_of_measure_id"
+        ),
+        sa.ForeignKeyConstraint(
+            ["tax_object_id"], ["sat.tax_objects.id"], name="fk_fin_concepts_tax_object_id"
+        ),
+        schema="fin",
+    )
+    op.create_index("ix_fin_concepts_id", "concepts", ["id"], schema="fin")
+    op.create_index("ix_fin_concepts_tenant_id", "concepts", ["tenant_id"], schema="fin")
+    op.create_index("ix_fin_concepts_company_id", "concepts", ["company_id"], schema="fin")
+    op.create_index("ix_fin_concepts_product_service_id", "concepts", ["product_service_id"], schema="fin")
+    # La clave interna del concepto es única por empresa.
+    op.create_index(
+        "uq_fin_concepts_code", "concepts", ["tenant_id", "company_id", "code"],
+        unique=True, schema="fin", postgresql_where=sa.text(_ALIVE),
+    )
+    # Relación 1:1 con c_ClaveProdServ: una clave del SAT no puede repetirse entre
+    # los conceptos vigentes de la misma empresa.
+    op.create_index(
+        "uq_fin_concepts_product_service", "concepts", ["tenant_id", "company_id", "product_service_id"],
+        unique=True, schema="fin", postgresql_where=sa.text(_ALIVE),
+    )
+
+    # ---------- fin.issuer_settings ----------
+    op.create_table(
+        "issuer_settings",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("tenant_id", sa.Integer(), nullable=False),
+        sa.Column("company_id", sa.Integer(), nullable=False),
+        sa.Column("legal_name", sa.String(length=255), nullable=False),
+        sa.Column("rfc", sa.String(length=13), nullable=False),
+        sa.Column("tax_regime_id", sa.Integer(), nullable=False),
+        sa.Column("zip_code", sa.String(length=5), nullable=True),
+        sa.Column("updated_by", sa.String(length=64), nullable=True),
+        *_timestamp_columns(with_soft_delete=True),
+        sa.PrimaryKeyConstraint("id"),
+        sa.ForeignKeyConstraint(["tenant_id"], ["core.tenants.id"], name="fk_fin_issuer_settings_tenant_id"),
+        sa.ForeignKeyConstraint(
+            ["tax_regime_id"], ["sat.tax_regimes.id"], name="fk_fin_issuer_settings_tax_regime_id"
+        ),
+        schema="fin",
+    )
+    op.create_index("ix_fin_issuer_settings_id", "issuer_settings", ["id"], schema="fin")
+    op.create_index("ix_fin_issuer_settings_tenant_id", "issuer_settings", ["tenant_id"], schema="fin")
+    op.create_index("ix_fin_issuer_settings_company_id", "issuer_settings", ["company_id"], schema="fin")
+    op.create_index("ix_fin_issuer_settings_tax_regime_id", "issuer_settings", ["tax_regime_id"], schema="fin")
+    # Una sola configuración fiscal vigente por empresa.
+    op.create_index(
+        "uq_fin_issuer_settings_company", "issuer_settings", ["tenant_id", "company_id"],
+        unique=True, schema="fin", postgresql_where=sa.text(_ALIVE),
+    )
+
+    # ---------- fin.invoice_item_taxes ----------
+    op.create_table(
+        "invoice_item_taxes",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("tenant_id", sa.Integer(), nullable=False),
+        sa.Column("company_id", sa.Integer(), nullable=False),
+        sa.Column("invoice_item_id", sa.Integer(), nullable=False),
+        sa.Column("tax_id", sa.Integer(), nullable=False),
+        sa.Column("is_withholding", sa.Boolean(), nullable=False, server_default=sa.text("false")),
+        sa.Column("rate", sa.Numeric(precision=8, scale=6), nullable=True),
+        sa.Column("amount", sa.Numeric(precision=14, scale=2), nullable=False, server_default=sa.text("0")),
+        *_timestamp_columns(with_soft_delete=True),
+        sa.PrimaryKeyConstraint("id"),
+        sa.ForeignKeyConstraint(["tenant_id"], ["core.tenants.id"], name="fk_fin_invoice_item_taxes_tenant_id"),
+        sa.ForeignKeyConstraint(
+            ["invoice_item_id"], ["fin.invoice_items.id"], name="fk_fin_invoice_item_taxes_invoice_item_id"
+        ),
+        sa.ForeignKeyConstraint(["tax_id"], ["sat.taxes.id"], name="fk_fin_invoice_item_taxes_tax_id"),
+        schema="fin",
+    )
+    op.create_index("ix_fin_invoice_item_taxes_id", "invoice_item_taxes", ["id"], schema="fin")
+    op.create_index("ix_fin_invoice_item_taxes_tenant_id", "invoice_item_taxes", ["tenant_id"], schema="fin")
+    op.create_index("ix_fin_invoice_item_taxes_company_id", "invoice_item_taxes", ["company_id"], schema="fin")
+    op.create_index(
+        "ix_fin_invoice_item_taxes_invoice_item_id", "invoice_item_taxes", ["invoice_item_id"], schema="fin"
+    )
+    # Un mismo impuesto no puede declararse dos veces con el mismo rol en la partida.
+    op.create_index(
+        "uq_fin_invoice_item_taxes", "invoice_item_taxes", ["invoice_item_id", "tax_id", "is_withholding"],
+        unique=True, schema="fin", postgresql_where=sa.text(_ALIVE),
+    )
+
+    # ---------- fin.invoices: claves fiscales del comprobante ----------
+    # Todas nullable: las facturas ya emitidas no tienen estos datos.
+    op.add_column("invoices", sa.Column("voucher_type_id", sa.Integer(), nullable=True), schema="fin")
+    op.add_column("invoices", sa.Column("payment_form_id", sa.Integer(), nullable=True), schema="fin")
+    op.add_column("invoices", sa.Column("payment_method_id", sa.Integer(), nullable=True), schema="fin")
+    op.add_column("invoices", sa.Column("expedition_zip_code", sa.String(length=5), nullable=True), schema="fin")
+    op.create_foreign_key(
+        "fk_fin_invoices_voucher_type_id", "invoices", "voucher_types",
+        ["voucher_type_id"], ["id"], source_schema="fin", referent_schema="sat",
+    )
+    op.create_foreign_key(
+        "fk_fin_invoices_payment_form_id", "invoices", "payment_forms",
+        ["payment_form_id"], ["id"], source_schema="fin", referent_schema="sat",
+    )
+    op.create_foreign_key(
+        "fk_fin_invoices_payment_method_id", "invoices", "payment_methods",
+        ["payment_method_id"], ["id"], source_schema="fin", referent_schema="sat",
+    )
+
+    # ---------- fin.invoice_items: claves fiscales de la partida ----------
+    # La columna de texto libre `concept` se conserva intacta y obligatoria: la usa el
+    # PDF actual de la factura.
+    op.add_column("invoice_items", sa.Column("concept_id", sa.Integer(), nullable=True), schema="fin")
+    op.add_column("invoice_items", sa.Column("product_service_id", sa.Integer(), nullable=True), schema="fin")
+    op.add_column("invoice_items", sa.Column("unit_of_measure_id", sa.Integer(), nullable=True), schema="fin")
+    op.add_column("invoice_items", sa.Column("tax_object_id", sa.Integer(), nullable=True), schema="fin")
+    op.create_index("ix_fin_invoice_items_concept_id", "invoice_items", ["concept_id"], schema="fin")
+    op.create_foreign_key(
+        "fk_fin_invoice_items_concept_id", "invoice_items", "concepts",
+        ["concept_id"], ["id"], source_schema="fin", referent_schema="fin",
+    )
+    op.create_foreign_key(
+        "fk_fin_invoice_items_product_service_id", "invoice_items", "products_services",
+        ["product_service_id"], ["id"], source_schema="fin", referent_schema="sat",
+    )
+    op.create_foreign_key(
+        "fk_fin_invoice_items_unit_of_measure_id", "invoice_items", "units_of_measure",
+        ["unit_of_measure_id"], ["id"], source_schema="fin", referent_schema="sat",
+    )
+    op.create_foreign_key(
+        "fk_fin_invoice_items_tax_object_id", "invoice_items", "tax_objects",
+        ["tax_object_id"], ["id"], source_schema="fin", referent_schema="sat",
+    )
+
+
+def downgrade() -> None:
+    # fin.invoice_items
+    for constraint in (
+        "fk_fin_invoice_items_tax_object_id",
+        "fk_fin_invoice_items_unit_of_measure_id",
+        "fk_fin_invoice_items_product_service_id",
+        "fk_fin_invoice_items_concept_id",
+    ):
+        op.drop_constraint(constraint, "invoice_items", schema="fin", type_="foreignkey")
+    op.drop_index("ix_fin_invoice_items_concept_id", table_name="invoice_items", schema="fin")
+    for column in ("tax_object_id", "unit_of_measure_id", "product_service_id", "concept_id"):
+        op.drop_column("invoice_items", column, schema="fin")
+
+    # fin.invoices
+    for constraint in (
+        "fk_fin_invoices_payment_method_id",
+        "fk_fin_invoices_payment_form_id",
+        "fk_fin_invoices_voucher_type_id",
+    ):
+        op.drop_constraint(constraint, "invoices", schema="fin", type_="foreignkey")
+    for column in ("expedition_zip_code", "payment_method_id", "payment_form_id", "voucher_type_id"):
+        op.drop_column("invoices", column, schema="fin")
+
+    # Tablas nuevas (los índices caen con la tabla).
+    op.drop_table("invoice_item_taxes", schema="fin")
+    op.drop_table("issuer_settings", schema="fin")
+    op.drop_table("concepts", schema="fin")
+
+    # Catálogos del SAT: se va el schema completo.
+    op.execute("DROP SCHEMA IF EXISTS sat CASCADE")

backend/alembic/versions/h3i4j5k6l7m8_fin_invoice_stamping.py

@@ -0,0 +1,91 @@
+"""Timbrado de CFDI: ``fin.invoice_stamps`` y ``fin.invoices.stamping_mode``.
+
+Escrita a mano y no con ``--autogenerate``: el autogenerate de este proyecto arrastra
+drift preexistente entre los modelos y la base (llaves foráneas de ``core``, cambios de
+tipo en ``invite_tokens``), y generaba 1,516 operaciones ajenas a este ticket. Aquí van
+sólo los dos cambios del timbrado.
+
+Revision ID: h3i4j5k6l7m8
+Revises: f7a8b9c0d1e2
+Create Date: 2026-08-07 00:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "h3i4j5k6l7m8"
+down_revision: Union[str, None] = "f7a8b9c0d1e2"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ---------- fin.invoices: modo de timbrado por factura ----------
+    # NOT NULL con server_default: las facturas existentes quedan en 'pruebas', que es el
+    # valor seguro. Marcar como 'produccion' es siempre una decisión explícita.
+    op.add_column(
+        "invoices",
+        sa.Column(
+            "stamping_mode",
+            sa.String(length=12),
+            nullable=False,
+            server_default=sa.text("'pruebas'"),
+        ),
+        schema="fin",
+    )
+
+    # ---------- fin.invoice_stamps ----------
+    op.create_table(
+        "invoice_stamps",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("tenant_id", sa.Integer(), nullable=False),
+        sa.Column("company_id", sa.Integer(), nullable=False),
+        sa.Column("invoice_id", sa.Integer(), nullable=False),
+        sa.Column("mode", sa.String(length=12), nullable=False),
+        sa.Column("status", sa.String(length=12), nullable=False, server_default=sa.text("'pendiente'")),
+        # Timbre Fiscal Digital
+        sa.Column("uuid", sa.String(length=36), nullable=True),
+        sa.Column("stamped_at", sa.DateTime(), nullable=True),
+        sa.Column("pac_rfc", sa.String(length=13), nullable=True),
+        sa.Column("sat_cert_number", sa.String(length=20), nullable=True),
+        sa.Column("sat_seal", sa.Text(), nullable=True),
+        sa.Column("cfd_seal", sa.Text(), nullable=True),
+        # Respuesta del PAC
+        sa.Column("pac_code", sa.Integer(), nullable=True),
+        sa.Column("pac_balance", sa.Integer(), nullable=True),
+        sa.Column("error_message", sa.Text(), nullable=True),
+        sa.Column("xml_file_key", sa.String(length=512), nullable=True),
+        sa.Column("created_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.Column("deleted_at", sa.DateTime(), nullable=True),
+        sa.ForeignKeyConstraint(["invoice_id"], ["fin.invoices.id"]),
+        sa.PrimaryKeyConstraint("id"),
+        schema="fin",
+    )
+    op.create_index("ix_fin_invoice_stamps_id", "invoice_stamps", ["id"], schema="fin")
+    op.create_index("ix_fin_invoice_stamps_invoice_id", "invoice_stamps", ["invoice_id"], schema="fin")
+    op.create_index("ix_fin_invoice_stamps_status", "invoice_stamps", ["status"], schema="fin")
+    op.create_index("ix_fin_invoice_stamps_uuid", "invoice_stamps", ["uuid"], schema="fin")
+    # Un UUID lo emite el SAT una sola vez. Parcial sobre uuid IS NOT NULL porque los intentos
+    # fallidos no traen UUID y colisionarían entre sí bajo un único convencional.
+    op.create_index(
+        "uq_fin_invoice_stamps_uuid",
+        "invoice_stamps",
+        ["uuid"],
+        unique=True,
+        schema="fin",
+        postgresql_where=sa.text("uuid IS NOT NULL AND deleted_at IS NULL"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("uq_fin_invoice_stamps_uuid", table_name="invoice_stamps", schema="fin")
+    op.drop_index("ix_fin_invoice_stamps_uuid", table_name="invoice_stamps", schema="fin")
+    op.drop_index("ix_fin_invoice_stamps_status", table_name="invoice_stamps", schema="fin")
+    op.drop_index("ix_fin_invoice_stamps_invoice_id", table_name="invoice_stamps", schema="fin")
+    op.drop_index("ix_fin_invoice_stamps_id", table_name="invoice_stamps", schema="fin")
+    op.drop_table("invoice_stamps", schema="fin")
+    op.drop_column("invoices", "stamping_mode", schema="fin")

backend/alembic/versions/i4j5k6l7m8n9_fin_issuer_csd.py

@@ -0,0 +1,43 @@
+"""CSD por empresa en ``fin.issuer_settings``.
+
+Cierra el hueco de que el certificado de sello digital tuviera que dejarse a mano en el
+almacenamiento y de que su contraseña fuera una variable de entorno global: con varias
+empresas emisoras eso no funciona, porque cada una tiene su propio certificado.
+
+La contraseña se guarda cifrada (``core.crypto``); la clave maestra vive en el entorno.
+
+Escrita a mano, no con ``--autogenerate``: ver la nota de la migración h3i4j5k6l7m8.
+
+Revision ID: i4j5k6l7m8n9
+Revises: h3i4j5k6l7m8
+Create Date: 2026-08-10 00:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "i4j5k6l7m8n9"
+down_revision: Union[str, None] = "h3i4j5k6l7m8"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+_COLUMNAS = (
+    ("csd_cer_file_key", sa.String(length=512)),
+    ("csd_key_file_key", sa.String(length=512)),
+    ("csd_password_enc", sa.Text()),
+    ("csd_cert_number", sa.String(length=20)),
+    ("csd_uploaded_at", sa.DateTime()),
+)
+
+
+def upgrade() -> None:
+    for nombre, tipo in _COLUMNAS:
+        op.add_column("issuer_settings", sa.Column(nombre, tipo, nullable=True), schema="fin")
+
+
+def downgrade() -> None:
+    # Al revés, para que el orden de la tabla quede como estaba.
+    for nombre, _ in reversed(_COLUMNAS):
+        op.drop_column("issuer_settings", nombre, schema="fin")

backend/alembic/versions/j5k6l7m8n9o0_fin_stamp_attempt_xml.py

@@ -0,0 +1,40 @@
+"""XML enviado y recibido de cada intento de timbrado, en ``fin.invoice_stamps``.
+
+Hasta ahora sólo se guardaba el XML del timbrado exitoso, que es justo el caso en el que
+menos falta hace. Cuando el PAC rechaza el comprobante no queda rastro de qué se le mandó
+ni de qué contestó: el XML sellado vive en memoria durante la petición y desaparece con
+ella, y el cuerpo de la respuesta también. Estas dos columnas apuntan al par enviado/recibido
+que se guarda en el almacenamiento por cada intento.
+
+Escrita a mano, no con ``--autogenerate``: ver la nota de la migración h3i4j5k6l7m8.
+
+Revision ID: j5k6l7m8n9o0
+Revises: i4j5k6l7m8n9
+Create Date: 2026-08-11 00:00:00.000000
+
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "j5k6l7m8n9o0"
+down_revision: Union[str, None] = "i4j5k6l7m8n9"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+_COLUMNAS = (
+    ("request_xml_file_key", sa.String(length=512)),
+    ("response_xml_file_key", sa.String(length=512)),
+)
+
+
+def upgrade() -> None:
+    for nombre, tipo in _COLUMNAS:
+        op.add_column("invoice_stamps", sa.Column(nombre, tipo, nullable=True), schema="fin")
+
+
+def downgrade() -> None:
+    # Al revés, para que el orden de la tabla quede como estaba.
+    for nombre, _ in reversed(_COLUMNAS):
+        op.drop_column("invoice_stamps", nombre, schema="fin")

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/permissions/service.py

@@ -8,7 +8,7 @@ from datetime import datetime
 from typing import Set, Optional, List
 
 from sqlalchemy.orm import Session
-from sqlalchemy import and_, or_
+from sqlalchemy import and_, or_, text
 
 from core.database import RLS_TENANT_KEY
 from .cache import PermissionCache
@@ -51,8 +51,18 @@ class PermissionService:
                 return None
 
         try:
-            # Sin modelo de compañía en la plantilla — implementa la consulta aquí.
-            pass
+            # La tabla de compañías del CRM es ``a76.company`` (esquema legado). No tiene modelo
+            # ORM en este proyecto, así que se consulta con SQL crudo, igual que ``seed_crm.py``.
+            #
+            # Sin este respaldo la función devolvía None siempre que la sesión no traía contexto
+            # RLS, y con ella se scopean las consultas de permisos de los cinco llamadores de
+            # abajo: el efecto neto era que nadie resolvía permisos.
+            row = self.db.execute(
+                text("SELECT tenant_id FROM a76.company WHERE id = :company_id"),
+                {"company_id": company_id},
+            ).first()
+            if row is not None and row[0] is not None:
+                return int(row[0])
         except Exception as exc:
             logger.warning(
                 "resolve_tenant_id_for_company_failed",
@@ -470,8 +480,35 @@ class PermissionService:
             sync_res = self.sync_permissions()
             logger.info(f"Bootstrap: Sincronización completa. {sync_res.get('synced', 0)} nuevos, {sync_res.get('total_registered', 0)} totales.")
 
-            # 1. Obtener el tenant_id (implementa con tu modelo de compañía)
-            tenant_id = self.db.info.get(RLS_TENANT_KEY) or 1
+            # 1. tenant_id del rol: se toma de la COMPAÑÍA, que es su fuente autoritativa.
+            #    ``company_roles`` referencia a la vez a ``a76.company`` y a ``core.tenants``, así
+            #    que el tenant del rol tiene que ser el de su compañía o la fila queda cruzada
+            #    entre dos tenants.
+            #
+            #    Antes esto era ``self.db.info.get(RLS_TENANT_KEY) or 1``. Cuando la sesión no
+            #    traía contexto RLS —justo el caso de ``/permissions/me`` en el primer acceso— el
+            #    rol se creaba con ``tenant_id=1``; en una instalación real ese tenant no existe y
+            #    el INSERT moría con ForeignKeyViolation. El bootstrap quedaba a medias, sin rol
+            #    ni permisos, toda la API respondía 403 y ``/permissions/me`` seguía devolviendo
+            #    200 con la lista vacía: el fallo se leía en pantalla como "no tienes permisos"
+            #    en lugar de como el error de configuración que era.
+            #    Se consulta la compañía DIRECTAMENTE y no vía ``_resolve_tenant_id_for_company``:
+            #    ese helper prefiere el contexto RLS, que es el tenant del REQUEST y puede no ser
+            #    el de la compañía. Para leer permisos esa preferencia está bien y ahorra una
+            #    consulta en el camino caliente; para escribir una fila atada por FK a las dos
+            #    tablas, no: si difirieran, el rol nacería cruzado.
+            _row = self.db.execute(
+                text("SELECT tenant_id FROM a76.company WHERE id = :company_id"),
+                {"company_id": company_id},
+            ).first()
+            if _row is None or _row[0] is None:
+                logger.error(
+                    "Bootstrap: la compañía %s no existe en a76.company, no hay tenant al que "
+                    "colgar el rol. Se aborta sin crear nada.",
+                    company_id,
+                )
+                return False
+            tenant_id = int(_row[0])
 
             # 2. Buscar si ya existe el rol "super_admin"
             admin_role = self.db.query(CompanyRole).filter(

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

@@ -13,18 +13,24 @@ class AccountBase(BaseModel):
     record_type: str = Field("cliente", max_length=20)  # cliente | prospecto
     person_type: str | None = Field(None, max_length=10)  # fisica | moral
     industry: str | None = Field(None, max_length=120)
+    industry_other: str | None = Field(None, max_length=120)
     account_type: str | None = Field(None, max_length=40)
     status: str = Field("active", max_length=20)  # active | inactive
     # 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)
+    # Claves contra los catálogos del SAT; sustituyen al texto libre de arriba al timbrar.
+    tax_regime_id: int | None = Field(None, description="c_RegimenFiscal del receptor")
+    cfdi_use_id: int | None = Field(None, description="c_UsoCFDI del receptor")
     payment_method: str | None = Field(None, max_length=60)
     payment_form: str | None = Field(None, max_length=60)
     currency: str | None = Field(None, max_length=3)
@@ -36,7 +42,7 @@ class AccountBase(BaseModel):
     address: str | None = None
     city: str | None = Field(None, max_length=120)
     state: str | None = Field(None, max_length=120)
-    country: str | None = Field("MX", max_length=2)
+    country: str | None = Field("MEX", max_length=3)
     # Observaciones
     notes: str | None = None
     internal_notes: str | None = None
@@ -55,16 +61,21 @@ class AccountUpdate(BaseModel):
     record_type: str | None = Field(None, max_length=20)
     person_type: str | None = Field(None, max_length=10)
     industry: str | None = Field(None, max_length=120)
+    industry_other: str | None = Field(None, max_length=120)
     account_type: str | None = Field(None, max_length=40)
     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)
+    tax_regime_id: int | None = None
+    cfdi_use_id: int | None = None
     payment_method: str | None = Field(None, max_length=60)
     payment_form: str | None = Field(None, max_length=60)
     currency: str | None = Field(None, max_length=3)
@@ -75,7 +86,7 @@ class AccountUpdate(BaseModel):
     address: str | None = None
     city: str | None = Field(None, max_length=120)
     state: str | None = Field(None, max_length=120)
-    country: str | None = Field(None, max_length=2)
+    country: str | None = Field(None, max_length=3)
     notes: str | None = None
     internal_notes: str | None = None
     owner_user_id: str | None = Field(None, max_length=64)

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

@@ -1,9 +1,10 @@
 from decimal import Decimal
 
-from sqlalchemy import Integer, Numeric, String, Text, text
+from sqlalchemy import ForeignKey, Integer, Numeric, String, Text, text
 from sqlalchemy.orm import Mapped, mapped_column
 
 from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
+from api.v1.modules.fin.catalogs.models import CfdiUse, TaxRegime  # noqa: F401  (resuelve las FK)
 from core.database import Base
 
 
@@ -31,6 +32,7 @@ class Account(Base, TenantScopedMixin, TimestampMixin):
     # Tipo de persona: fisica | moral
     person_type: Mapped[str | None] = mapped_column(String(10), nullable=True)
     industry: Mapped[str | None] = mapped_column(String(120), nullable=True)  # giro / industria
+    industry_other: Mapped[str | None] = mapped_column(String(120), nullable=True)  # especificar cuando giro = "otro"
     # Tipo operativo (immex | agencia_aduanal | importador | exportador | transportista | otro)
     account_type: Mapped[str | None] = mapped_column(String(40), nullable=True)
     # Estatus: active | inactive
@@ -39,16 +41,28 @@ 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 -----
+    # Régimen fiscal y uso de CFDI en texto libre: se conservan como capturó el usuario
+    # para no perder lo ya registrado, pero lo que vale al timbrar son las FK de abajo.
     tax_regime: Mapped[str | None] = mapped_column(String(120), nullable=True)  # régimen fiscal
     cfdi_use: Mapped[str | None] = mapped_column(String(60), nullable=True)  # uso de CFDI
+    # Claves del receptor contra los catálogos del SAT (c_RegimenFiscal y c_UsoCFDI).
+    tax_regime_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("sat.tax_regimes.id"), nullable=True
+    )
+    cfdi_use_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("sat.cfdi_uses.id"), nullable=True
+    )
     payment_method: Mapped[str | None] = mapped_column(String(60), nullable=True)  # método de pago
     payment_form: Mapped[str | None] = mapped_column(String(60), nullable=True)  # forma de pago
     currency: Mapped[str | None] = mapped_column(String(3), nullable=True)  # moneda
@@ -62,7 +76,7 @@ class Account(Base, TenantScopedMixin, TimestampMixin):
     address: Mapped[str | None] = mapped_column(Text, nullable=True)
     city: Mapped[str | None] = mapped_column(String(120), nullable=True)
     state: Mapped[str | None] = mapped_column(String(120), nullable=True)
-    country: Mapped[str | None] = mapped_column(String(2), nullable=True, server_default=text("'MX'"))
+    country: Mapped[str | None] = mapped_column(String(3), nullable=True, server_default=text("'MEX'"))
 
     # ----- Observaciones y auditoría -----
     notes: Mapped[str | None] = mapped_column(Text, nullable=True)  # comentarios generales

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

@@ -3,10 +3,24 @@ from datetime import datetime, timezone
 from fastapi import HTTPException, status
 from sqlalchemy.orm import Session
 
+from api.v1.modules.fin.catalogs.models import CfdiUse, TaxRegime
+
 from .dto import AccountCreate, AccountUpdate
 from .models import Account
 
 
+def _validate_sat_refs(db: Session, data: dict) -> None:
+    """Verifica las claves del SAT del receptor antes de guardar la cuenta."""
+    for field, model, msg in [
+        ("tax_regime_id", TaxRegime, "El régimen fiscal indicado no existe en el catálogo del SAT"),
+        ("cfdi_use_id", CfdiUse, "El uso de CFDI indicado no existe en el catálogo del SAT"),
+    ]:
+        value = data.get(field)
+        if field in data and value is not None:
+            if db.query(model.id).filter(model.id == value).first() is None:
+                raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=msg)
+
+
 def get_accounts(
     db: Session,
     tenant_id: int,
@@ -53,8 +67,10 @@ def get_account(db: Session, account_id: int, tenant_id: int, company_id: int) -
 def create_account(
     db: Session, payload: AccountCreate, tenant_id: int, company_id: int, user_id: str | None = None
 ) -> Account:
+    data = payload.model_dump()
+    _validate_sat_refs(db, data)
     account = Account(
-        **payload.model_dump(),
+        **data,
         tenant_id=tenant_id,
         company_id=company_id,
         created_by=user_id,
@@ -75,7 +91,9 @@ def update_account(
     user_id: str | None = None,
 ) -> Account:
     account = get_account(db, account_id, tenant_id, company_id)
-    for field, value in payload.model_dump(exclude_unset=True).items():
+    data = payload.model_dump(exclude_unset=True)
+    _validate_sat_refs(db, data)
+    for field, value in data.items():
         setattr(account, field, value)
     account.updated_by = user_id
     db.commit()

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

@@ -14,7 +14,7 @@ class AddressBase(BaseModel):
     postal_code: str | None = Field(None, max_length=10)
     city: str | None = Field(None, max_length=120)
     state: str | None = Field(None, max_length=120)
-    country: str | None = Field("MX", max_length=2)
+    country: str | None = Field("MEX", max_length=3)  # ISO 3166-1 alfa-3 (alineado a catálogo pais)
     reference_notes: str | None = None
     is_primary: bool = False
 
@@ -32,7 +32,7 @@ class AddressUpdate(BaseModel):
     postal_code: str | None = Field(None, max_length=10)
     city: str | None = Field(None, max_length=120)
     state: str | None = Field(None, max_length=120)
-    country: str | None = Field(None, max_length=2)
+    country: str | None = Field(None, max_length=3)
     reference_notes: str | None = None
     is_primary: bool | None = None
 

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/cases/dto.py

@@ -0,0 +1,31 @@
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+
+
+class CaseResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    reference: str | None
+    account_id: int | None
+    title: str | None
+    stage: str
+    status: str
+    tenant_id: int
+    company_id: int
+    created_at: datetime
+    updated_at: datetime
+
+
+class CaseTimelineEvent(BaseModel):
+    kind: str            # oportunidad | solicitud | cotizacion | operacion | factura
+    id: int
+    reference: str | None = None
+    status: str | None = None
+    created_at: datetime
+    url: str
+
+
+class CaseWithTimeline(CaseResponse):
+    timeline: list[CaseTimelineEvent] = []

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

@@ -0,0 +1,52 @@
+from sqlalchemy import ForeignKey, Integer, String, Text, text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
+from core.database import Base
+
+
+class Case(Base, TenantScopedMixin, TimestampMixin):
+    """Expediente: hilo maestro de un trámite (Oportunidad → Solicitud → Cotización →
+    Operación → Factura). Una sola referencia (``EXP…``) que agrupa toda la historia.
+    Nace al crear la Oportunidad y se hereda a las entidades siguientes vía ``case_id``.
+    """
+
+    __tablename__ = "cases"
+    __table_args__ = {"schema": "crm"}
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    reference: Mapped[str | None] = mapped_column(String(40), nullable=True, index=True)  # folio EXP...
+    account_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("crm.accounts.id"), nullable=True, index=True
+    )
+    title: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    # Etapa más avanzada alcanzada: oportunidad|solicitud|cotizacion|operacion|facturacion|cerrado
+    stage: Mapped[str] = mapped_column(String(20), nullable=False, server_default=text("'oportunidad'"))
+    # abierto | cerrado
+    status: Mapped[str] = mapped_column(String(20), nullable=False, server_default=text("'abierto'"), index=True)
+    created_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    updated_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
+
+    # ── Espejo del carril hacia EFC (T2026-08-046) ──────────────────────────────────────────
+    # EFC es la fuente única de los documentos del expediente: cada expediente se refleja allá
+    # como un *pedimento provisional* y los archivos viven en su MinIO, no en el del CRM.
+    #
+    # Estas columnas son un ESPEJO, nunca el handle. El handle con el que el CRM habla de este
+    # expediente es su ``id`` y su ``reference``: ``efc_pedimento_id`` es un caché de la
+    # resolución, y del lado de EFC el ``pedimento_app`` es mutable —se reescribe al completar
+    # el provisional con la data aduanera real—, así que apoyarse en él rompería justo cuando
+    # llegue esa data. La liga vive en EFC, en la tabla desechable ``pedimento_expediente``.
+    efc_organizacion_id: Mapped[str | None] = mapped_column(String(36), nullable=True)
+    efc_pedimento_id: Mapped[str | None] = mapped_column(String(36), nullable=True)
+    # INMUTABLE una vez asignado: es la carpeta de MinIO donde EFC guarda los objetos de este
+    # expediente. Que no cambie nunca es lo que permite completar el pedimento sin mover ni un
+    # archivo.
+    efc_storage_token: Mapped[str | None] = mapped_column(String(25), nullable=True)
+    # PENDING | LINKED | FAILED
+    efc_link_state: Mapped[str] = mapped_column(
+        String(20), nullable=False, server_default=text("'PENDING'"), index=True
+    )
+    # El diagnóstico se guarda en la fila para que se vea en la ficha del expediente, sin
+    # obligar a nadie a ir a los logs del worker.
+    efc_error_code: Mapped[str | None] = mapped_column(String(60), nullable=True)
+    efc_error_detail: Mapped[str | None] = mapped_column(Text, nullable=True)

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

@@ -0,0 +1,51 @@
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.orm import Session
+
+from core.database import get_core_db
+from core.security import get_current_user
+
+from . import service
+from .dto import CaseResponse, CaseWithTimeline
+
+router = APIRouter()
+
+
+def _with_timeline(db, case) -> CaseWithTimeline:
+    data = CaseWithTimeline.model_validate(case)
+    data.timeline = service.build_timeline(db, case)  # type: ignore[assignment]
+    return data
+
+
+@router.get("/cases", response_model=list[CaseResponse])
+def list_cases(
+    company_id: int = Query(..., description="Company ID"),
+    search: str | None = Query(None),
+    account_id: int | None = Query(None),
+    stage: str | None = Query(None),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    return service.get_cases(db, current_user["tenant_id"], company_id, search, account_id, stage)
+
+
+@router.get("/cases/by-ref/{reference}", response_model=CaseWithTimeline)
+def get_case_by_ref(
+    reference: str,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Expediente + historia completa por su referencia (para UI y otros sistemas)."""
+    case = service.get_case_by_reference(db, reference, current_user["tenant_id"], company_id)
+    return _with_timeline(db, case)
+
+
+@router.get("/cases/{case_id}", response_model=CaseWithTimeline)
+def get_case(
+    case_id: int,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    case = service.get_case(db, case_id, current_user["tenant_id"], company_id)
+    return _with_timeline(db, case)

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

@@ -0,0 +1,130 @@
+"""Lógica del Expediente: minteo del folio, avance de etapa y armado del timeline."""
+
+from fastapi import HTTPException, status
+from sqlalchemy.orm import Session
+
+from ..common.folios import next_folio
+from .models import Case
+
+# Orden de etapas (solo se avanza, nunca retrocede)
+STAGE_ORDER = ["oportunidad", "solicitud", "cotizacion", "operacion", "facturacion", "cerrado"]
+
+
+def create_case(
+    db: Session, tenant_id: int, company_id: int, *, account_id: int | None = None,
+    title: str | None = None, stage: str = "oportunidad", user_id: str | None = None,
+) -> Case:
+    """Mintea un expediente con folio EXP... (sin commit; lo confirma quien lo invoca)."""
+    case = Case(
+        reference=next_folio(db, tenant_id, company_id, "EXP", None, with_direction=False),
+        account_id=account_id, title=title, stage=stage, status="abierto",
+        tenant_id=tenant_id, company_id=company_id, created_by=user_id, updated_by=user_id,
+    )
+    db.add(case)
+    db.flush()
+
+    # ── Carril hacia EFC (T2026-08-046) ──────────────────────────────────────────────────
+    # EFC es la fuente única de los documentos del expediente. El reflejo allá —un pedimento
+    # provisional— se pide AQUÍ, en el instante en que nace el folio, porque el folio es
+    # precisamente la llave con la que las dos mitades se reconocen.
+    #
+    # El token de almacenamiento se fija al nacer y NO cambia nunca: es la carpeta de MinIO
+    # del lado de EFC. Que sea inmutable es lo que permite completar el provisional con la
+    # data aduanera real sin mover un solo archivo.
+    #
+    # Todo es best-effort y va en la MISMA transacción que el expediente:
+    #   - con ``EFC_API_URL`` vacía es un no-op y el expediente vive igual, solo en el CRM;
+    #   - si el encolado o el despacho fallan, no se propaga el error: el barrido del beat
+    #     recoge lo pendiente. Un sistema de terceros caído no puede romper un alta.
+    # El import es diferido para no acoplar el arranque del módulo del expediente al carril.
+    from ..expediente_gateway import service as gateway
+    from ..expediente_gateway.storage import storage_token
+
+    case.efc_storage_token = storage_token(company_id, case.reference)
+    db.flush()
+    gateway.replicate_expediente_best_effort(db, case)
+    return case
+
+
+def advance_stage(db: Session, case_id: int | None, stage: str) -> None:
+    """Avanza la etapa del expediente si la nueva es posterior a la actual."""
+    if not case_id or stage not in STAGE_ORDER:
+        return
+    case = db.query(Case).filter(Case.id == case_id).first()
+    if not case:
+        return
+    current = case.stage if case.stage in STAGE_ORDER else "oportunidad"
+    if STAGE_ORDER.index(stage) > STAGE_ORDER.index(current):
+        case.stage = stage
+
+
+def get_cases(
+    db: Session, tenant_id: int, company_id: int, search: str | None = None,
+    account_id: int | None = None, stage: str | None = None,
+) -> list[Case]:
+    q = db.query(Case).filter(
+        Case.tenant_id == tenant_id, Case.company_id == company_id, Case.deleted_at.is_(None),
+    )
+    if account_id is not None:
+        q = q.filter(Case.account_id == account_id)
+    if stage:
+        q = q.filter(Case.stage == stage)
+    if search:
+        q = q.filter(Case.reference.ilike(f"%{search}%"))
+    return q.order_by(Case.created_at.desc()).all()
+
+
+def get_case(db: Session, case_id: int, tenant_id: int, company_id: int) -> Case:
+    obj = (
+        db.query(Case)
+        .filter(Case.id == case_id, Case.tenant_id == tenant_id, Case.company_id == company_id, Case.deleted_at.is_(None))
+        .first()
+    )
+    if not obj:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Expediente no encontrado")
+    return obj
+
+
+def get_case_by_reference(db: Session, reference: str, tenant_id: int, company_id: int) -> Case:
+    obj = (
+        db.query(Case)
+        .filter(Case.reference == reference, Case.tenant_id == tenant_id, Case.company_id == company_id,
+                Case.deleted_at.is_(None))
+        .first()
+    )
+    if not obj:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Expediente no encontrado")
+    return obj
+
+
+def build_timeline(db: Session, case: Case) -> list[dict]:
+    """Devuelve la historia del expediente: todas las entidades ligadas por case_id,
+    en orden cronológico. Un único lookup para la UI y para otros sistemas."""
+    # Import local para evitar ciclos de importación entre módulos.
+    from ..opportunities.models import Opportunity
+    from ..quotes.models import Quote
+    from ..service_requests.models import ServiceRequest
+    from api.v1.modules.fin.invoices.models import Invoice
+    from api.v1.modules.ops.shipments.models import Shipment
+
+    events: list[dict] = []
+    specs = [
+        ("oportunidad", Opportunity, "/dashboard/crm/oportunidades"),
+        ("solicitud", ServiceRequest, "/dashboard/crm/solicitudes"),
+        ("cotizacion", Quote, "/dashboard/crm/cotizaciones"),
+        ("operacion", Shipment, "/dashboard/ops/embarques"),
+        ("factura", Invoice, "/dashboard/fin/facturas"),
+    ]
+    for kind, model, base_url in specs:
+        rows = db.query(model).filter(model.case_id == case.id, model.deleted_at.is_(None)).all()
+        for r in rows:
+            events.append({
+                "kind": kind,
+                "id": r.id,
+                "reference": getattr(r, "reference", None),
+                "status": getattr(r, "status", None),
+                "created_at": r.created_at,
+                "url": f"{base_url}/{r.id}",
+            })
+    events.sort(key=lambda e: e["created_at"])
+    return events

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

@@ -0,0 +1,46 @@
+"""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
+    extra: dict | None = None  # metadata (ej. dimensiones de un tipo de equipo)
+
+
+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,69 @@
+"""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"),
+                    extra=item.get("extra"),
+                    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,874 @@
+"""Datos semilla de los catálogos de referencia del CRM.
+
+SAT/ISO + estándar + Medidas de Equipos (tipo_equipo con dimensiones en extra)
++ catálogos del módulo Tarifario. Globales con tenant_id NULL.
+"""
+
+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'}]},
+ 'tipo_equipo': {'label': 'Tipo de equipo / contenedor',
+                 'is_system': True,
+                 'items': [{'code': '40DC',
+                            'label': "40' Standard",
+                            'extra': {'modo': 'maritimo',
+                                      'largo_m': 12.035,
+                                      'ancho_m': 2.35,
+                                      'alto_m': 2.392,
+                                      'capacidad_m3': 67.7,
+                                      'tara_kg': 3700,
+                                      'carga_max_kg': 26790}},
+                           {'code': '20DC',
+                            'label': "20' Standard",
+                            'extra': {'modo': 'maritimo',
+                                      'largo_m': 5.9,
+                                      'ancho_m': 2.35,
+                                      'alto_m': 2.392,
+                                      'capacidad_m3': 33.2,
+                                      'tara_kg': 2230,
+                                      'carga_max_kg': 21770}},
+                           {'code': '20OT',
+                            'label': "20' Open Top",
+                            'extra': {'modo': 'maritimo',
+                                      'largo_m': 5.894,
+                                      'ancho_m': 2.311,
+                                      'alto_m': 2.354,
+                                      'capacidad_m3': 32.23,
+                                      'tara_kg': 2400,
+                                      'carga_max_kg': 30490}},
+                           {'code': '20FR',
+                            'label': "20' Flat Rack",
+                            'extra': {'modo': 'maritimo',
+                                      'largo_m': 5.62,
+                                      'ancho_m': 2.23,
+                                      'alto_m': 2.233,
+                                      'tara_kg': 2530,
+                                      'carga_max_kg': 21470}},
+                           {'code': '40HC',
+                            'label': "40' High Cube",
+                            'extra': {'modo': 'maritimo',
+                                      'largo_m': 12.036,
+                                      'ancho_m': 2.35,
+                                      'alto_m': 2.697,
+                                      'capacidad_m3': 76.3,
+                                      'tara_kg': 3970,
+                                      'carga_max_kg': 26510}},
+                           {'code': '20PL',
+                            'label': "20' Platform",
+                            'extra': {'modo': 'maritimo',
+                                      'largo_m': 6.058,
+                                      'ancho_m': 2.438,
+                                      'alto_m': 0.37,
+                                      'tara_kg': 2520,
+                                      'carga_max_kg': 27960}},
+                           {'code': '20FRC',
+                            'label': "20' Flat Rack Collapsible",
+                            'extra': {'modo': 'maritimo',
+                                      'largo_m': 5.618,
+                                      'ancho_m': 2.206,
+                                      'alto_m': 2.233,
+                                      'tara_kg': 2750,
+                                      'carga_max_kg': 27730}},
+                           {'code': '20BK',
+                            'label': "20' Bulk",
+                            'extra': {'modo': 'maritimo',
+                                      'largo_m': 5.93,
+                                      'ancho_m': 2.35,
+                                      'alto_m': 2.34,
+                                      'capacidad_m3': 32.0,
+                                      'tara_kg': 2450,
+                                      'carga_max_kg': 21350}},
+                           {'code': '20TK',
+                            'label': "20' Tank",
+                            'extra': {'modo': 'maritimo',
+                                      'largo_m': 6.058,
+                                      'ancho_m': 2.438,
+                                      'alto_m': 2.438,
+                                      'tara_kg': 4100,
+                                      'carga_max_kg': 26200}},
+                           {'code': 'LD2',
+                            'label': 'LD2',
+                            'extra': {'modo': 'aereo',
+                                      'capacidad_m3': 3.5,
+                                      'tara_kg': 30,
+                                      'carga_max_kg': 1225,
+                                      'nota': 'Aviones 767'}},
+                           {'code': 'LD3',
+                            'label': 'LD3',
+                            'extra': {'modo': 'aereo',
+                                      'capacidad_m3': 4.2,
+                                      'tara_kg': 80,
+                                      'carga_max_kg': 1587,
+                                      'nota': 'B747/B777/DC10/MD-11/A310/A330/A340'}},
+                           {'code': 'LBD',
+                            'label': 'LBD (Flex Door)',
+                            'extra': {'modo': 'aereo',
+                                      'capacidad_m3': 7.0,
+                                      'tara_kg': 123,
+                                      'carga_max_kg': 2449,
+                                      'nota': 'Aviones 767'}},
+                           {'code': 'LD6',
+                            'label': 'LD6',
+                            'extra': {'modo': 'aereo',
+                                      'capacidad_m3': 8.9,
+                                      'tara_kg': 175,
+                                      'carga_max_kg': 3175,
+                                      'nota': 'B747/B777/DC10/MD-11/A310/A330/A340'}},
+                           {'code': 'PAG',
+                            'label': 'PAP / PIP / PAG',
+                            'extra': {'modo': 'aereo',
+                                      'capacidad_m3': 10.0,
+                                      'tara_kg': 120,
+                                      'carga_max_kg': 6033,
+                                      'nota': 'Boeing 747/767/777/DC10'}},
+                           {'code': 'LD9',
+                            'label': 'LD9 AAP',
+                            'extra': {'modo': 'aereo',
+                                      'capacidad_m3': 10.0,
+                                      'tara_kg': 85,
+                                      'carga_max_kg': 1588,
+                                      'nota': 'Boeing 747/777/DC10'}},
+                           {'code': 'XAW',
+                            'label': 'XAW',
+                            'extra': {'modo': 'aereo',
+                                      'capacidad_m3': 14.0,
+                                      'tara_kg': 170,
+                                      'carga_max_kg': 5000,
+                                      'nota': 'Boeing 747/777/DC10'}},
+                           {'code': 'PMC',
+                            'label': 'PMC',
+                            'extra': {'modo': 'aereo',
+                                      'capacidad_m3': 12.7,
+                                      'tara_kg': 130,
+                                      'carga_max_kg': 6804,
+                                      'nota': 'Boeing 747/767/777'}},
+                           {'code': 'LD8',
+                            'label': 'LD8',
+                            'extra': {'modo': 'aereo', 'capacidad_m3': 7.2, 'tara_kg': 120, 'carga_max_kg': 2450}},
+                           {'code': 'DV48',
+                            'label': "Dry Van 48'",
+                            'extra': {'modo': 'terrestre',
+                                      'largo_m': 14.63,
+                                      'ancho_m': 2.59,
+                                      'alto_m': 2.3,
+                                      'capacidad_m3': 98.0,
+                                      'carga_max_kg': 20412,
+                                      'pallets': 22}},
+                           {'code': 'SD',
+                            'label': 'Legal Step Deck (Single Drop)',
+                            'extra': {'modo': 'terrestre',
+                                      'largo_m': 11.58,
+                                      'ancho_m': 2.59,
+                                      'alto_m': 3.05,
+                                      'carga_max_kg': 20865}},
+                           {'code': 'TANK',
+                            'label': 'Tanker',
+                            'extra': {'modo': 'terrestre',
+                                      'largo_m': 16.15,
+                                      'ancho_m': 2.59,
+                                      'alto_m': 2.3,
+                                      'capacidad_l': 22712}},
+                           {'code': 'DV53',
+                            'label': "Dry Van 53'",
+                            'extra': {'modo': 'terrestre',
+                                      'largo_m': 16.15,
+                                      'ancho_m': 2.59,
+                                      'alto_m': 2.3,
+                                      'capacidad_m3': 99.11,
+                                      'carga_max_kg': 20412,
+                                      'pallets': 26}},
+                           {'code': 'DD',
+                            'label': 'Double Drop (Low Boy)',
+                            'extra': {'modo': 'terrestre',
+                                      'largo_m': 8.53,
+                                      'ancho_m': 2.59,
+                                      'alto_m': 3.51,
+                                      'carga_max_kg': 18144}},
+                           {'code': 'RF48',
+                            'label': "48' Reefer Trailer",
+                            'extra': {'modo': 'terrestre',
+                                      'largo_m': 14.63,
+                                      'ancho_m': 2.4,
+                                      'alto_m': 2.3,
+                                      'capacidad_m3': 90.0,
+                                      'carga_max_kg': 19958,
+                                      'pallets': 20}},
+                           {'code': 'FB48',
+                            'label': "48' Legal Flatbed",
+                            'extra': {'modo': 'terrestre',
+                                      'largo_m': 14.63,
+                                      'ancho_m': 2.59,
+                                      'alto_m': 2.59,
+                                      'carga_max_kg': 21772}},
+                           {'code': 'PUP28',
+                            'label': "Pup Trailer 28'",
+                            'extra': {'modo': 'terrestre',
+                                      'largo_m': 8.53,
+                                      'ancho_m': 2.59,
+                                      'alto_m': 2.3,
+                                      'capacidad_m3': 57.45,
+                                      'carga_max_kg': 9979,
+                                      'pallets': 14}},
+                           {'code': 'IM53',
+                            'label': "Intermodal 53' Container",
+                            'extra': {'modo': 'terrestre',
+                                      'largo_m': 16.15,
+                                      'ancho_m': 2.59,
+                                      'alto_m': 2.3,
+                                      'capacidad_m3': 99.11,
+                                      'carga_max_kg': 19958,
+                                      'pallets': 24}}]},
+ 'modo_tarifario': {'label': 'Modo de tarifario',
+                    'is_system': True,
+                    'items': [{'code': 'aereo', 'label': 'Aéreo'},
+                              {'code': 'maritimo_fcl', 'label': 'Marítimo FCL'},
+                              {'code': 'maritimo_lcl', 'label': 'Marítimo LCL'},
+                              {'code': 'terrestre', 'label': 'Terrestre'}]},
+ 'unidad_tarifa': {'label': 'Unidad de tarifa',
+                   'is_system': True,
+                   'items': [{'code': 'per_kg', 'label': 'Por kg'},
+                             {'code': 'per_wm', 'label': 'Por peso/medida (W/M)'},
+                             {'code': 'per_container', 'label': 'Por contenedor'},
+                             {'code': 'flat', 'label': 'Tarifa plana'}]},
+ 'concepto_cargo': {'label': 'Concepto de cargo',
+                    'is_system': False,
+                    'items': [{'code': 'combustible', 'label': 'Combustible (BAF/FSC)'},
+                              {'code': 'dgr', 'label': 'Mercancía peligrosa (DGR)'},
+                              {'code': 'moc', 'label': 'MOC (mínimo origen)'},
+                              {'code': 'afs', 'label': 'AFS'},
+                              {'code': 'thc', 'label': 'THC (manejo en terminal)'},
+                              {'code': 'maniobras', 'label': 'Maniobras'},
+                              {'code': 'almacenaje', 'label': 'Almacenaje'},
+                              {'code': 'seguro', 'label': 'Seguro'},
+                              {'code': 'despacho', 'label': 'Despacho aduanal'},
+                              {'code': 'documentacion', 'label': 'Documentación'},
+                              {'code': 'custodia', 'label': 'Custodia'},
+                              {'code': 'otro', 'label': 'Otro'}]}}
+
+TENANT_CATALOG_LABELS = {'servicio': 'Servicios que ofrece',
+ 'puerto': 'Puertos donde opera',
+ 'aeropuerto': 'Aeropuertos donde opera',
+ 'aduana': 'Aduanas donde opera'}
+
+# ---------------------------------------------------------------------------
+# Catálogos del proceso comercial (Solicitud de servicio → Cotización).
+# Alimentan los selects de la solicitud y del ciclo Oportunidad→Cotización.
+# is_system = catálogos base que el cliente no puede borrar (sólo activar/desactivar).
+# ---------------------------------------------------------------------------
+GLOBAL_CATALOGS.update({
+    'tipo_operacion': {'label': 'Tipo de operación',
+                       'is_system': True,
+                       'items': [{'code': 'importacion', 'label': 'Importación'},
+                                 {'code': 'exportacion', 'label': 'Exportación'}]},
+    'medio_transporte': {'label': 'Medio de transporte',
+                         'is_system': True,
+                         'items': [{'code': 'maritimo', 'label': 'Marítimo'},
+                                   {'code': 'aereo', 'label': 'Aéreo'},
+                                   {'code': 'terrestre', 'label': 'Terrestre'},
+                                   {'code': 'ferroviario', 'label': 'Ferroviario'},
+                                   {'code': 'multimodal', 'label': 'Multimodal'}]},
+    'tipo_servicio': {'label': 'Tipo de servicio',
+                      'is_system': True,
+                      'items': [{'code': 'puerto_puerto', 'label': 'Puerto a puerto'},
+                                {'code': 'puerto_puerta', 'label': 'Puerto a puerta'},
+                                {'code': 'puerta_puerto', 'label': 'Puerta a puerto'},
+                                {'code': 'puerta_puerta', 'label': 'Puerta a puerta'}]},
+    'prioridad': {'label': 'Prioridad',
+                  'is_system': False,
+                  'items': [{'code': 'baja', 'label': 'Baja'},
+                            {'code': 'normal', 'label': 'Normal'},
+                            {'code': 'alta', 'label': 'Alta'},
+                            {'code': 'urgente', 'label': 'Urgente'}]},
+    'tipo_mercancia': {'label': 'Tipo de mercancía',
+                       'is_system': False,
+                       'items': [{'code': 'general', 'label': 'Carga general'},
+                                 {'code': 'perecedera', 'label': 'Perecedera'},
+                                 {'code': 'peligrosa', 'label': 'Peligrosa (IMO)'},
+                                 {'code': 'refrigerada', 'label': 'Refrigerada'},
+                                 {'code': 'granel', 'label': 'Granel'},
+                                 {'code': 'sobredimensionada', 'label': 'Sobredimensionada'},
+                                 {'code': 'valiosa', 'label': 'Valiosa'},
+                                 {'code': 'otro', 'label': 'Otro'}]},
+    'unidad_medida': {'label': 'Unidad de medida',
+                      'is_system': False,
+                      'items': [{'code': 'cm', 'label': 'Centímetros (cm)'},
+                                {'code': 'm', 'label': 'Metros (m)'},
+                                {'code': 'in', 'label': 'Pulgadas (in)'},
+                                {'code': 'ft', 'label': 'Pies (ft)'},
+                                {'code': 'kg', 'label': 'Kilogramos (kg)'},
+                                {'code': 'lb', 'label': 'Libras (lb)'},
+                                {'code': 'm3', 'label': 'Metros cúbicos (m³)'}]},
+    'tipo_embalaje': {'label': 'Tipo de embalaje',
+                      'is_system': False,
+                      'items': [{'code': 'caja', 'label': 'Caja'},
+                                {'code': 'pallet', 'label': 'Pallet'},
+                                {'code': 'tarima', 'label': 'Tarima'},
+                                {'code': 'huacal', 'label': 'Huacal'},
+                                {'code': 'saco', 'label': 'Saco'},
+                                {'code': 'tambor', 'label': 'Tambor'},
+                                {'code': 'rollo', 'label': 'Rollo'},
+                                {'code': 'atado', 'label': 'Atado'},
+                                {'code': 'granel', 'label': 'Granel'},
+                                {'code': 'otro', 'label': 'Otro'}]},
+    'servicio_adicional': {'label': 'Servicios adicionales',
+                           'is_system': False,
+                           'items': [{'code': 'seguro', 'label': 'Seguro de la mercancía'},
+                                     {'code': 'despacho_aduanal', 'label': 'Despacho aduanal'},
+                                     {'code': 'transporte_terrestre', 'label': 'Transporte terrestre'},
+                                     {'code': 'almacenaje', 'label': 'Almacenaje'},
+                                     {'code': 'maniobras', 'label': 'Maniobras'},
+                                     {'code': 'custodia', 'label': 'Custodia'},
+                                     {'code': 'revalidacion', 'label': 'Revalidación'},
+                                     {'code': 'inspeccion', 'label': 'Inspección'},
+                                     {'code': 'otro', 'label': 'Otro'}]},
+    'tipo_documento': {'label': 'Tipo de documento',
+                       'is_system': False,
+                       'items': [{'code': 'factura_comercial', 'label': 'Factura comercial'},
+                                 {'code': 'packing_list', 'label': 'Packing list'},
+                                 {'code': 'certificado_origen', 'label': 'Certificado de origen'},
+                                 {'code': 'hoja_seguridad_msds', 'label': 'Hoja de seguridad (MSDS)'},
+                                 {'code': 'ficha_tecnica', 'label': 'Ficha técnica'},
+                                 {'code': 'carta_instrucciones', 'label': 'Carta de instrucciones'},
+                                 {'code': 'otro', 'label': 'Otro'}]},
+    'incoterm': {'label': 'Incoterm (2020)',
+                 'is_system': True,
+                 'items': [{'code': 'EXW', 'label': 'EXW — Ex Works (en fábrica)'},
+                           {'code': 'FCA', 'label': 'FCA — Free Carrier (franco transportista)'},
+                           {'code': 'FAS', 'label': 'FAS — Free Alongside Ship (franco al costado del buque)'},
+                           {'code': 'FOB', 'label': 'FOB — Free On Board (franco a bordo)'},
+                           {'code': 'CFR', 'label': 'CFR — Cost and Freight (costo y flete)'},
+                           {'code': 'CIF', 'label': 'CIF — Cost, Insurance and Freight (costo, seguro y flete)'},
+                           {'code': 'CPT', 'label': 'CPT — Carriage Paid To (transporte pagado hasta)'},
+                           {'code': 'CIP', 'label': 'CIP — Carriage and Insurance Paid To (transporte y seguro pagados hasta)'},
+                           {'code': 'DAP', 'label': 'DAP — Delivered At Place (entregado en lugar)'},
+                           {'code': 'DPU', 'label': 'DPU — Delivered At Place Unloaded (entregado en lugar descargado)'},
+                           {'code': 'DDP', 'label': 'DDP — Delivered Duty Paid (entregado con derechos pagados)'}]},
+})
+
+# Formas de pago SAT de un dígito → dos dígitos (01, 02, 03, 04, 05, 06, 08).
+# El SAT exige dos posiciones; se corrige el catálogo base.
+for _fp in GLOBAL_CATALOGS.get('forma_pago', {}).get('items', []):
+    if len(_fp['code']) == 1:
+        _fp['code'] = _fp['code'].zfill(2)
+
+# Ubicaciones por país (ciudad/puerto/aeropuerto), dependientes de `pais`.
+from .seed_locations import LOCATION_CATALOGS  # noqa: E402
+
+GLOBAL_CATALOGS.update(LOCATION_CATALOGS)

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

@@ -0,0 +1,79 @@
+"""Catálogos de ubicaciones por país: ciudad, puerto (UN/LOCODE), aeropuerto (IATA).
+
+Dependientes de `pais` (`parent_catalog='pais'`, `parent_code=<ISO3>`). Curado a las
+rutas de comercio más usadas (extensible: agregar países/nodos según tarifarios).
+Los códigos de puerto/aeropuerto se alinean con los que usan las lanes del tarifario
+para que el Cotizador encuentre ruta.
+"""
+
+# (ISO3, ciudades[(code,label)], puertos[(code,label)], aeropuertos[(code,label)])
+_LOC = [
+    ("MEX",
+     [("MX-CDMX", "Ciudad de México"), ("MX-GDL", "Guadalajara"), ("MX-MTY", "Monterrey"),
+      ("MX-QRO", "Querétaro"), ("MX-TIJ", "Tijuana"), ("MX-VER", "Veracruz")],
+     [("MXZLO", "Manzanillo"), ("MXVER", "Veracruz"), ("MXATM", "Altamira"),
+      ("MXLZC", "Lázaro Cárdenas"), ("MXPGO", "Progreso"), ("MXESE", "Ensenada")],
+     [("MEX", "AICM Ciudad de México"), ("NLU", "AIFA Santa Lucía"), ("GDL", "Guadalajara"),
+      ("MTY", "Monterrey"), ("TIJ", "Tijuana"), ("CUN", "Cancún")]),
+    ("USA",
+     [("US-LAX", "Los Ángeles"), ("US-NYC", "Nueva York"), ("US-HOU", "Houston"),
+      ("US-CHI", "Chicago"), ("US-MIA", "Miami"), ("US-LRD", "Laredo")],
+     [("USLAX", "Los Angeles"), ("USLGB", "Long Beach"), ("USNYC", "Nueva York/NJ"),
+      ("USHOU", "Houston"), ("USSAV", "Savannah"), ("USSEA", "Seattle"), ("USOAK", "Oakland")],
+     [("LAX", "Los Ángeles"), ("JFK", "Nueva York JFK"), ("ORD", "Chicago O'Hare"),
+      ("MIA", "Miami"), ("DFW", "Dallas Fort Worth"), ("ATL", "Atlanta")]),
+    ("CHN",
+     [("CN-SHA", "Shanghái"), ("CN-SZX", "Shenzhen"), ("CN-CAN", "Guangzhou"),
+      ("CN-NGB", "Ningbo"), ("CN-TAO", "Qingdao"), ("CN-PEK", "Pekín")],
+     [("CNSHA", "Shanghái"), ("CNNGB", "Ningbo"), ("CNSZX", "Shenzhen"),
+      ("CNTAO", "Qingdao"), ("CNCAN", "Guangzhou"), ("CNXMN", "Xiamen"), ("CNTXG", "Tianjin")],
+     [("PVG", "Shanghái Pudong"), ("PEK", "Pekín Capital"), ("CAN", "Guangzhou"),
+      ("SZX", "Shenzhen"), ("HKG", "Hong Kong")]),
+    ("DEU",
+     [("DE-HAM", "Hamburgo"), ("DE-FRA", "Fráncfort"), ("DE-MUC", "Múnich"), ("DE-BER", "Berlín")],
+     [("DEHAM", "Hamburgo"), ("DEBRV", "Bremerhaven")],
+     [("FRA", "Fráncfort"), ("MUC", "Múnich"), ("HAM", "Hamburgo")]),
+    ("ESP",
+     [("ES-MAD", "Madrid"), ("ES-BCN", "Barcelona"), ("ES-VLC", "Valencia")],
+     [("ESVLC", "Valencia"), ("ESBCN", "Barcelona"), ("ESALG", "Algeciras")],
+     [("MAD", "Madrid Barajas"), ("BCN", "Barcelona")]),
+    ("NLD",
+     [("NL-RTM", "Róterdam"), ("NL-AMS", "Ámsterdam")],
+     [("NLRTM", "Róterdam")],
+     [("AMS", "Ámsterdam Schiphol")]),
+    ("BRA",
+     [("BR-SAO", "São Paulo"), ("BR-SSZ", "Santos"), ("BR-RIO", "Río de Janeiro")],
+     [("BRSSZ", "Santos"), ("BRPNG", "Paranaguá"), ("BRRIG", "Rio Grande")],
+     [("GRU", "São Paulo Guarulhos"), ("GIG", "Río de Janeiro")]),
+    ("CAN",
+     [("CA-YVR", "Vancouver"), ("CA-YYZ", "Toronto"), ("CA-YMQ", "Montreal")],
+     [("CAVAN", "Vancouver"), ("CAMTR", "Montreal"), ("CAHAL", "Halifax")],
+     [("YVR", "Vancouver"), ("YYZ", "Toronto Pearson")]),
+    ("JPN",
+     [("JP-TYO", "Tokio"), ("JP-OSA", "Osaka"), ("JP-YOK", "Yokohama")],
+     [("JPYOK", "Yokohama"), ("JPTYO", "Tokio"), ("JPNGO", "Nagoya"), ("JPKOB", "Kobe")],
+     [("NRT", "Tokio Narita"), ("HND", "Tokio Haneda"), ("KIX", "Osaka Kansai")]),
+    ("KOR",
+     [("KR-SEL", "Seúl"), ("KR-PUS", "Busan")],
+     [("KRPUS", "Busan"), ("KRINC", "Incheon")],
+     [("ICN", "Seúl Incheon")]),
+]
+
+
+def _build() -> dict:
+    ciudad, puerto, aeropuerto = [], [], []
+    for iso3, cities, ports, airports in _LOC:
+        for code, label in cities:
+            ciudad.append({"code": code, "label": label, "parent_catalog": "pais", "parent_code": iso3})
+        for code, label in ports:
+            puerto.append({"code": code, "label": f"{label} ({code})", "parent_catalog": "pais", "parent_code": iso3})
+        for code, label in airports:
+            aeropuerto.append({"code": code, "label": f"{label} ({code})", "parent_catalog": "pais", "parent_code": iso3})
+    return {
+        "ciudad": {"label": "Ciudad", "is_system": True, "items": ciudad},
+        "puerto": {"label": "Puerto", "is_system": True, "items": puerto},
+        "aeropuerto": {"label": "Aeropuerto", "is_system": True, "items": aeropuerto},
+    }
+
+
+LOCATION_CATALOGS = _build()

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/common/folios.py

@@ -0,0 +1,96 @@
+"""Folios auto-generados del ciclo comercial (Oportunidad → Solicitud → Cotización → Operación).
+
+Formato: ``{LETRA}{AAAA}-{MM}-{NNN}-{DIR}`` (ej. ``O2025-08-001-E``):
+- LETRA: entidad — ``O`` Oportunidad, ``S`` Solicitud, ``C`` Cotización, ``OP`` Operación/Embarque.
+- ``AAAA-MM``: año-mes de creación.
+- ``NNN``: consecutivo **mensual** por compañía y por entidad (reinicia cada mes).
+- ``DIR``: ``I`` importación / ``E`` exportación (``X`` si aún no se define la dirección).
+
+El consecutivo se toma de ``crm.folio_counters`` con bloqueo de fila para evitar
+duplicados por concurrencia. En SQLite (pruebas) el ``FOR UPDATE`` se ignora sin error;
+la unicidad la garantiza el índice único (tenant, company, entity, period).
+"""
+
+from __future__ import annotations
+
+from datetime import date
+
+from sqlalchemy import Integer, String, UniqueConstraint, text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from api.v1.common.base_models import BaseTimestampMixin, TenantScopedMixin
+from core.database import Base
+
+# Entidades válidas y su letra de folio (F = factura, EXP = expediente; sin dirección).
+ENTITIES = ("O", "S", "C", "OP", "F", "EXP")
+# Mapa dirección de operación → sufijo del folio.
+_DIRECTION_SUFFIX = {"importacion": "I", "exportacion": "E"}
+
+
+class FolioCounter(Base, TenantScopedMixin, BaseTimestampMixin):
+    """Consecutivo mensual por compañía y entidad para armar los folios del ciclo."""
+
+    __tablename__ = "folio_counters"
+    __table_args__ = (
+        UniqueConstraint(
+            "tenant_id", "company_id", "entity", "period", name="uq_crm_folio_counters_scope"
+        ),
+        {"schema": "crm"},
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    entity: Mapped[str] = mapped_column(String(4), nullable=False)  # O | S | C | OP
+    period: Mapped[str] = mapped_column(String(7), nullable=False)  # 'AAAA-MM'
+    last_number: Mapped[int] = mapped_column(Integer, nullable=False, server_default=text("0"))
+
+
+def direction_suffix(direction: str | None) -> str:
+    """Devuelve la letra de dirección del folio (I/E) o 'X' si no está definida."""
+    return _DIRECTION_SUFFIX.get(direction or "", "X")
+
+
+def next_folio(
+    db,
+    tenant_id: int,
+    company_id: int,
+    entity: str,
+    direction: str | None,
+    on_date: date | None = None,
+    with_direction: bool = True,
+) -> str:
+    """Genera el siguiente folio de una entidad, incrementando su consecutivo mensual.
+
+    Reserva el número dentro de la transacción activa (no hace commit): el ``create_*``
+    que lo invoca es quien confirma junto con la fila recién creada. ``with_direction=False``
+    omite el sufijo I/E (p. ej. facturas → ``F2026-08-001``).
+    """
+    if entity not in ENTITIES:
+        raise ValueError(f"Entidad de folio inválida: {entity!r}")
+    on_date = on_date or date.today()
+    period = on_date.strftime("%Y-%m")
+
+    counter = (
+        db.query(FolioCounter)
+        .filter(
+            FolioCounter.tenant_id == tenant_id,
+            FolioCounter.company_id == company_id,
+            FolioCounter.entity == entity,
+            FolioCounter.period == period,
+        )
+        .with_for_update()
+        .first()
+    )
+    if counter is None:
+        counter = FolioCounter(
+            tenant_id=tenant_id, company_id=company_id, entity=entity, period=period, last_number=0
+        )
+        db.add(counter)
+        db.flush()
+
+    counter.last_number = (counter.last_number or 0) + 1
+    db.flush()
+
+    sequence = f"{counter.last_number:03d}"
+    if not with_direction:
+        return f"{entity}{period}-{sequence}"
+    return f"{entity}{period}-{sequence}-{direction_suffix(direction)}"

backend/api/v1/modules/crm/common/pricing.py

@@ -0,0 +1,37 @@
+"""Cálculos de precio compartidos del proceso comercial.
+
+Peso volumétrico / a cobrar de carga aérea (doc maestro de cotización):
+    P/Vol = (Largo_cm × Ancho_cm × Alto_cm × cantidad) / 6000
+El peso a cobrar es el mayor entre el peso bruto y el P/Vol (estándar aéreo).
+6000 cm³/kg es el factor internacional (equivale a ~167 kg/m³).
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+
+# Factor internacional de peso volumétrico aéreo (cm³ por kg).
+AIR_VOLUMETRIC_DIVISOR = Decimal("6000")
+
+
+def _d(value) -> Decimal:
+    if value is None:
+        return Decimal(0)
+    return value if isinstance(value, Decimal) else Decimal(str(value))
+
+
+def air_volumetric_kg(length_cm, width_cm, height_cm, qty=1) -> Decimal:
+    """Peso volumétrico aéreo a partir de dimensiones (cm) y cantidad de bultos.
+
+    Devuelve 0 si falta alguna dimensión (no se puede calcular).
+    """
+    length, width, height = _d(length_cm), _d(width_cm), _d(height_cm)
+    if length <= 0 or width <= 0 or height <= 0:
+        return Decimal(0)
+    quantity = _d(qty) if _d(qty) > 0 else Decimal(1)
+    return (length * width * height * quantity) / AIR_VOLUMETRIC_DIVISOR
+
+
+def air_chargeable_kg(gross_kg, length_cm, width_cm, height_cm, qty=1) -> Decimal:
+    """Peso a cobrar aéreo: max(peso bruto, peso volumétrico por dimensiones)."""
+    return max(_d(gross_kg), air_volumetric_kg(length_cm, width_cm, height_cm, qty))

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

@@ -22,6 +22,10 @@ class Document(Base, TenantScopedMixin, TimestampMixin):
     supplier_id: Mapped[int | None] = mapped_column(
         Integer, ForeignKey("crm.suppliers.id"), nullable=True, index=True
     )
+    # Documento adjunto a una solicitud de servicio (factura, packing list, MSDS, etc.)
+    service_request_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("crm.service_requests.id"), nullable=True, index=True
+    )
     # constancia_fiscal | acta_constitutiva | identificacion | comprobante_domicilio |
     # contrato | presentacion | certificacion | licencia | convenio | tarifario | otro
     doc_type: Mapped[str] = mapped_column(String(60), nullable=False)

backend/api/v1/modules/crm/expediente_gateway/doc_types.py

@@ -0,0 +1,64 @@
+"""Catálogo CERRADO de tipos de documento que EFC acepta del CRM.
+
+Estas 22 claves son **exactamente** las de ``TIPOS_DOCUMENTO_CRM`` en
+``api/record/views_integrations_crm.py`` de EFC. La lista está duplicada a mano en dos repos con
+despliegue independiente, así que ``tests/test_doc_types_paridad.py`` la fija: si alguien agrega un
+tipo de un solo lado, ese test se pone rojo antes de que un documento se rechace en producción.
+
+Por qué es un conjunto cerrado y no texto libre, a diferencia del carril de Anexo22 —que manda el
+tipo suelto y deja que EFC lo resuelva por nombre—: en el CRM ``doc_type`` es ``String(60)`` /
+``String(30)`` **sin validación de backend**, los catálogos viven solo en TypeScript
+(``frontend/src/lib/api/crm/format.ts``). Un typo crearía un ``DocumentType`` basura en el catálogo
+**global** de EFC, que es compartido por todas las organizaciones y no se limpia solo.
+
+Las tres fuentes del CRM y su origen:
+
+- ``crm.documents``           → ``DOC_TYPES`` de ``format.ts``
+- ``ops.shipment_documents``  → ``SHIPMENT_DOC_TYPES`` del mismo archivo
+- ``fin.invoices``            → el PDF de factura (``factura_venta``)
+
+``otro`` existe en las dos listas del CRM y significa lo mismo en ambas: es una sola entrada.
+"""
+
+# --- crm.documents ---------------------------------------------------------------------------
+_TIPOS_DOCUMENTOS_CLIENTE = (
+    "constancia_fiscal",
+    "acta_constitutiva",
+    "identificacion",
+    "comprobante_domicilio",
+    "contrato",
+    "presentacion",
+    "certificacion",
+    "licencia",
+    "convenio",
+    "tarifario",
+)
+
+# --- ops.shipment_documents ------------------------------------------------------------------
+_TIPOS_DOCUMENTOS_EMBARQUE = (
+    "MBL",
+    "HBL",
+    "MAWB",
+    "HAWB",
+    "CMR",
+    "factura_comercial",
+    "packing_list",
+    "carta_encomienda",
+    "carta_garantia",
+    "certificado_permiso",
+)
+
+# --- fin.invoices ----------------------------------------------------------------------------
+_TIPOS_FACTURACION = ("factura_venta",)
+
+# --- común a varias fuentes -------------------------------------------------------------------
+_TIPOS_COMUNES = ("otro",)
+
+EFC_DOC_TYPES: frozenset[str] = frozenset(
+    _TIPOS_DOCUMENTOS_CLIENTE + _TIPOS_DOCUMENTOS_EMBARQUE + _TIPOS_FACTURACION + _TIPOS_COMUNES
+)
+
+
+def is_valid_doc_type(doc_type: str | None) -> bool:
+    """``True`` si EFC va a aceptar ese tipo. Se valida en el CRM para no gastar un viaje de red."""
+    return bool(doc_type) and doc_type in EFC_DOC_TYPES

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

@@ -0,0 +1,131 @@
+"""Outbox transaccional del carril CRM Agentes de Carga -> EFC.
+
+DOS tablas separadas POR PROPÓSITO, igual que en el carril de referencia de Anexo22: una para los
+expedientes (metadatos, JSON) y otra para los archivos (binarios que viven en MinIO y se referencian
+por su ``s3_key``). Un worker de Celery las drena hacia EFC con reintentos.
+
+**Diferencia con el original, y es necesaria:** aquí las filas se insertan en la MISMA transacción
+que el expediente o el documento, porque el CRM es mono-base. En Anexo22 el outbox vivía en otra
+base que el pedimento, y ese doble-commit es justamente lo que obligó a inventar el barrido de
+huecos. Aquí el barrido se conserva —cubre lo creado antes de activar la integración y cualquier
+crash— pero deja de ser el parche de una ventana estructural.
+"""
+from datetime import datetime
+from typing import Optional
+
+from sqlalchemy import JSON, Boolean, DateTime, ForeignKey, Index, Integer, String, Text, text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
+from core.database import Base
+
+# Tipo de trabajo (columna kind) del outbox de EXPEDIENTES.
+KIND_EXPEDIENTE = "expediente"
+KIND_COMPLETAR = "completar"
+
+# Tipos del outbox de ARCHIVOS (efc_file_outbox).
+FILE_KIND_DOCUMENTO = "documento"
+
+# Tablas de origen posibles de un archivo. El CRM tiene DOS tablas de documentos con secuencias
+# independientes, así que `source_id` por sí solo es ambiguo: crm.documents.id = 5 y
+# ops.shipment_documents.id = 5 coexisten.
+SOURCE_CRM_DOCUMENTS = "crm.documents"
+SOURCE_OPS_SHIPMENT_DOCUMENTS = "ops.shipment_documents"
+SOURCE_FIN_INVOICES = "fin.invoices"
+
+# Estados (columna status).
+STATUS_PENDING = "pending"
+STATUS_SENT = "sent"
+STATUS_FAILED = "failed"
+
+# Tope de reintentos antes de marcar 'failed' (reconciliación / reintento manual).
+# Heredado del carril de Anexo22. Con barridos de 120 s son ~17 minutos de insistencia antes de
+# rendirse y dejar la fila visible para que una persona la reintente a mano.
+MAX_ATTEMPTS = 8
+
+
+class EfcSyncOutbox(Base, TenantScopedMixin, TimestampMixin):
+    """Cola de metadatos hacia EFC: crear el expediente provisional y completarlo."""
+
+    __tablename__ = "efc_sync_outbox"
+    __table_args__ = (
+        Index("ix_crm_efc_sync_outbox_status", "status"),
+        Index("ix_crm_efc_sync_outbox_kind_status", "kind", "status"),
+        {"schema": "crm"},
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+
+    kind: Mapped[str] = mapped_column(String(20), nullable=False)
+
+    # Datos para construir el request a EFC (folio, storage_token, tenant slug, company, y la data
+    # aduanera si el kind es 'completar').
+    payload: Mapped[dict] = mapped_column(JSON, nullable=False)
+
+    # id local del expediente (crm.cases.id) que originó la fila.
+    expediente_ref: Mapped[Optional[int]] = mapped_column(Integer, nullable=True, index=True)
+
+    # Ciclo de vida.
+    status: Mapped[str] = mapped_column(String(10), nullable=False, server_default=text(f"'{STATUS_PENDING}'"))
+    attempts: Mapped[int] = mapped_column(Integer, nullable=False, server_default=text("0"))
+    last_error: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    sent_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+
+    # Acuse de EFC al confirmar (trazabilidad).
+    efc_pedimento_id: Mapped[Optional[str]] = mapped_column(String(36), nullable=True)
+
+
+class EfcFileOutbox(Base, TenantScopedMixin, TimestampMixin):
+    """Cola de ARCHIVOS hacia EFC.
+
+    El binario vive en el MinIO del CRM (durable); esta fila referencia su ``s3_key`` y el expediente
+    destino. El worker lo sube a EFC y, con ``delete_local`` (corte directo), BORRA la copia local al
+    confirmar la entrega.
+
+    ``delete_local`` **es el mecanismo de «EFC es la fuente única»**: "solo EFC" es el estado FINAL
+    (eventual), no el inmediato. Entre que el usuario sube el archivo y que EFC lo confirma, la copia
+    local es lo único que hay, y borrarla antes perdería el archivo si la entrega fallara.
+
+    ``source_table`` es un añadido necesario sobre el original de Anexo22, que solo llevaba
+    ``source_id``. El CRM tiene dos tablas de documentos con secuencias independientes, así que un
+    entero solo es ambiguo entre ellas. Es el mismo problema que Anexo22 resolvió con su mapa por
+    ``kind``, y su comentario dice qué pasa si se ignora: un UPDATE con el id de otra tabla **vacía la
+    columna de un documento ajeno** que tuviera ese mismo entero — daño en el dato de otro, sin un
+    solo error visible. Un ``(kind, source_table)`` que no esté en el mapa **no toca nada**, en vez
+    de caer por omisión.
+    """
+
+    __tablename__ = "efc_file_outbox"
+    __table_args__ = (
+        Index("ix_crm_efc_file_outbox_status", "status"),
+        Index("ix_crm_efc_file_outbox_kind_status", "kind", "status"),
+        Index("ix_crm_efc_file_outbox_source", "source_table", "source_id"),
+        {"schema": "crm"},
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    kind: Mapped[str] = mapped_column(String(30), nullable=False)
+
+    # Objeto en MinIO a subir + metadata para el upload a EFC.
+    s3_key: Mapped[str] = mapped_column(String(1024), nullable=False)
+    file_name: Mapped[str] = mapped_column(String(255), nullable=False)
+    content_type: Mapped[Optional[str]] = mapped_column(String(100), nullable=True)
+    efc_tipo: Mapped[str] = mapped_column(String(40), nullable=False)  # tipo de documento en EFC
+
+    # Origen: la pareja (tabla, id) desambigua entre las dos secuencias de documentos del CRM.
+    source_table: Mapped[str] = mapped_column(String(30), nullable=False)
+    source_id: Mapped[Optional[int]] = mapped_column(Integer, nullable=True)
+    # El handle autoritativo que viaja a EFC y garantiza la idempotencia del lado de allá.
+    crm_document_ref: Mapped[Optional[str]] = mapped_column(String(64), nullable=True)
+
+    expediente_ref: Mapped[int] = mapped_column(
+        Integer, ForeignKey("crm.cases.id"), nullable=False, index=True
+    )
+    delete_local: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("true"))
+
+    # Ciclo de vida.
+    status: Mapped[str] = mapped_column(String(10), nullable=False, server_default=text(f"'{STATUS_PENDING}'"))
+    attempts: Mapped[int] = mapped_column(Integer, nullable=False, server_default=text("0"))
+    last_error: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    sent_at: Mapped[Optional[datetime]] = mapped_column(DateTime, nullable=True)
+    efc_document_id: Mapped[Optional[str]] = mapped_column(String(36), nullable=True)

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

@@ -0,0 +1,58 @@
+"""Endpoints de operación y observabilidad del carril CRM -> EFC.
+
+Tablero mínimo para ver y reintentar la entrega de expedientes y documentos a EFC. Autenticado con
+el auth normal del CRM y acotado por tenant/company, como el resto del módulo.
+Montado bajo ``/v1/crm`` → ``/v1/crm/expediente-gateway/...``
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+
+from core.database import get_core_db
+from core.security import get_current_user
+
+from . import service
+
+router = APIRouter(prefix="/expediente-gateway", tags=["EFC Gateway (ops)"])
+
+
+@router.get("/outbox")
+def list_outbox(
+    company_id: int = Query(..., description="Company ID"),
+    tipo: str | None = Query(None, description="Filtrar por tabla: sync|file"),
+    status: str | None = Query(None, description="Filtrar por status: pending|sent|failed"),
+    limit: int = Query(100, ge=1, le=500),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Filas de los dos outbox, para ver los fallos y su ``last_error``."""
+    return service.list_outbox(db, current_user["tenant_id"], company_id, tipo, status, limit)
+
+
+@router.post("/outbox/{outbox_id}/retry")
+def retry_outbox(
+    outbox_id: int,
+    company_id: int = Query(..., description="Company ID"),
+    tipo: str = Query("file", description="Tabla de la fila: sync|file"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Reintento manual de una fila: la resetea a ``pending`` y la re-despacha.
+
+    Una fila inexistente devuelve **404 con mensaje específico**, no un 200 silencioso: el frontend
+    pinta el botón de reintento según lo que reciba, y un 200 le haría creer que la entrega volvió a
+    la cola cuando no hay nada que entregar.
+    """
+    ok = service.retry_outbox_row(db, outbox_id, current_user["tenant_id"], company_id, tipo)
+    if not ok:
+        raise HTTPException(status_code=404, detail="Fila de outbox no encontrada")
+    return {"status": "requeued", "id": outbox_id}
+
+
+@router.get("/metrics")
+def metrics(
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Conteo de los dos outbox por status (pending/sent/failed) para monitoreo."""
+    return service.outbox_metrics(db, current_user["tenant_id"], company_id)

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

@@ -0,0 +1,755 @@
+"""Carril CRM Agentes de Carga -> EFC: encolado, entrega y reconciliación.
+
+Clon del gateway de Anexo22 (``anexo22/.../pedimentos/pedimento_gateway/service.py``), que es el
+carril de referencia ya en producción. Quien conozca uno debe poder leer el otro, así que la tabla
+de equivalencias va aquí:
+
+======================================  ======================================
+Anexo22                                 CRM
+======================================  ======================================
+``replicate_pedimento_best_effort``     ``replicate_expediente_best_effort``
+``_enqueue_pedimento_outbox``           ``_enqueue_expediente_outbox``
+``_dispatch_delivery``                  igual
+``deliver_row`` / ``_deliver_pedimento``  ``deliver_row`` / ``_deliver_expediente``
+``_register_failure``                   **idéntico**
+``_ya_entregado(source_id, kind)``      ``_ya_entregado(source_table, source_id, kind)``
+``deliver_file_row``                    **idéntico**, con ensure-then-upload y ``delete_local``
+``_register_file_failure``              **idéntico**
+``_resolve_org_id`` + ``_org_id_cache``  igual — dict módulo-global, por worker, sin invalidación
+``list_outbox`` / ``retry_outbox_row`` / ``outbox_metrics``  igual, para las dos tablas
+``find_pedimento_gaps``                 ``find_expediente_gaps``
+======================================  ======================================
+
+**La máquina de reintentos tiene tres capas y las tres se conservan:**
+
+1. En el cliente HTTP: 3 intentos, backoff lineal ``0.15 * (attempt + 1)``, corte seco en 4xx.
+2. En el worker: ``deliver_row`` **nunca lanza**; registra el fallo en la propia fila.
+3. En el beat: barridos cada 120 s que re-despachan lo ``pending``.
+
+No hay ``autoretry_for``, ``retry_backoff`` ni ``max_retries`` en las tareas: duplicarían el
+mecanismo que ya está en el cliente y en el barrido.
+
+**Cuatro guardas de idempotencia**, en este orden:
+1. ``_ya_entregado(source_table, source_id, kind)`` antes de encolar.
+2. ``if row.status == STATUS_SENT: return`` al entrar a entregar.
+3. El ``crm_document_ref`` que viaja con la subida: EFC devuelve 200 con el que ya existía.
+4. El UNIQUE parcial del lado de EFC — la única que garantiza la base.
+
+**Por qué ``find_expediente_gaps`` sigue aquí aunque el CRM sea mono-base.** En Anexo22 el outbox se
+commitea aparte del pedimento (dos bases distintas) y ese doble-commit es lo que obligó a inventar el
+barrido de huecos. Aquí la fila del outbox va en la MISMA transacción que el expediente, así que esa
+ventana no existe. El barrido se conserva porque cubre otras dos cosas: los expedientes creados
+**antes** de activar la integración, y cualquier crash. Queda escrito para que el siguiente que lo
+lea no lo borre creyendo que es redundante.
+"""
+import logging
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from typing import Optional
+
+from sqlalchemy.orm import Session
+
+from core.config import settings
+from core.database import scoped_core_db
+from core.efc_client import EfcClient, EfcClientError, efc_client
+
+from ..cases.models import Case
+from .models import (
+    KIND_COMPLETAR,
+    KIND_EXPEDIENTE,
+    MAX_ATTEMPTS,
+    STATUS_FAILED,
+    STATUS_PENDING,
+    STATUS_SENT,
+    EfcFileOutbox,
+    EfcSyncOutbox,
+)
+
+logger = logging.getLogger(__name__)
+
+# Cache de organización EFC por slug de tenant. Dict módulo-global: vive por worker y NO se
+# invalida, igual que el del carril de Anexo22. Es correcto porque la organización de un tenant no
+# cambia de id: el resolver de EFC es idempotente y devuelve siempre la misma. Si algún día pudiera
+# cambiar, reiniciar el worker la vuelve a resolver.
+_org_id_cache: dict[str, str] = {}
+
+
+@contextmanager
+def _savepoint(db: Session):
+    """Aísla un encolado dentro de la transacción del usuario con un SAVEPOINT.
+
+    **Esto es lo único del encolado que NO se clona del carril de Anexo22, y la razón es de fondo.**
+    Allá el outbox vive en otra base que el pedimento, así que su ``except`` podía hacer
+    ``db.rollback()`` sin consecuencias: revertía la sesión del outbox y la del pedimento ni se
+    enteraba.
+
+    Aquí el CRM es mono-base y el encolado corre DENTRO de la transacción del usuario. Un
+    ``db.rollback()`` en el ``except`` se llevaría por delante la solicitud y el expediente que el
+    usuario acaba de crear — exactamente lo contrario de best-effort, y sin un solo error visible
+    para él. Con el SAVEPOINT, un fallo del encolado deshace **solo** la fila del outbox y la
+    operación local sigue en pie para que el llamador la commitee.
+    """
+    nested = db.begin_nested()
+    try:
+        yield nested
+    except Exception:
+        nested.rollback()
+        raise
+
+
+# ══ Expediente: encolado y entrega ══════════════════════════════════════════
+
+def replicate_expediente_best_effort(db: Session, expediente: Case) -> None:
+    """Encola la réplica del expediente a EFC y dispara la entrega inmediata.
+
+    Best-effort en todo: si EFC no está configurado, o si el encolado o el despacho fallan, **no se
+    propaga el error**. El expediente local ya existe y la operación del usuario no se puede romper
+    porque un sistema de terceros no conteste. El barrido periódico recoge lo que quede pendiente.
+    """
+    if not settings.EFC_API_URL:
+        return
+    row = _enqueue_expediente_outbox(db, expediente)
+    if row is None:
+        return
+    _dispatch_delivery(row.id, row.tenant_id, row.company_id)
+
+
+def _enqueue_expediente_outbox(db: Session, expediente: Case) -> Optional[EfcSyncOutbox]:
+    """Inserta la fila de outbox del expediente. Devuelve ``None`` si falla, sin romper nada.
+
+    A diferencia del original, **no commitea**: el CRM es mono-base, así que la fila viaja en la
+    misma transacción que el expediente. Eso cierra de raíz la ventana del doble-commit que en
+    Anexo22 obligó a inventar el barrido de huecos.
+    """
+    try:
+        if _expediente_ya_encolado(db, expediente.id):
+            return None
+        # Sin folio o sin token no hay nada que replicar: EFC exige los dos y responde
+        # {'storage_token': ['This field may not be null.']}, que NO es un fallo transitorio.
+        # Encolarlo de todos modos quemaría los 8 intentos para acabar en `failed`, ensuciando
+        # el tablero de ops con algo que ningún reintento puede arreglar.
+        #
+        # Pasa de verdad en dos casos: expedientes nacidos antes de que existiera el carril
+        # (los rellena la migración c5d6e7f8a9b0) y aquellos cuyo token no cabe en los 25
+        # caracteres de `pedimento_app`. Se avisa en WARNING porque es una omisión silenciosa:
+        # el expediente vive en el CRM y sus documentos nunca llegarán a EFC.
+        if not expediente.reference or not expediente.efc_storage_token:
+            logger.warning(
+                "expediente_gateway: expediente id=%s SIN replicar — folio=%r token=%r. "
+                "No se encola: EFC rechaza ambos nulos y el reintento no lo arregla.",
+                expediente.id, expediente.reference, expediente.efc_storage_token,
+            )
+            return None
+        # El slug del tenant NO se resuelve aquí: se rellena al ENTREGAR. Resolverlo ahora abriría
+        # una segunda sesión de base (``scoped_core_db``) dentro de la transacción del usuario, que
+        # es justo lo que el encolado debe evitar. Es además lo que hace el carril de referencia.
+        payload = {
+            "source": "crm",
+            "crm_company_id": expediente.company_id,
+            "crm_expediente_id": expediente.id,
+            "folio": expediente.reference,
+            "storage_token": expediente.efc_storage_token,
+        }
+        row = EfcSyncOutbox(
+            kind=KIND_EXPEDIENTE,
+            payload=payload,
+            expediente_ref=expediente.id,
+            status=STATUS_PENDING,
+            tenant_id=expediente.tenant_id,
+            company_id=expediente.company_id,
+        )
+        with _savepoint(db):
+            db.add(row)
+            db.flush()
+        return row
+    except Exception:
+        logger.warning(
+            "expediente_gateway: no se pudo encolar el expediente id=%s en el outbox",
+            getattr(expediente, "id", None), exc_info=True,
+        )
+        return None
+
+
+def _expediente_ya_encolado(db: Session, expediente_id: int) -> bool:
+    """¿Ya hay una fila viva de alta para este expediente? Evita encolar la misma réplica dos veces."""
+    return (
+        db.query(EfcSyncOutbox.id)
+        .filter(
+            EfcSyncOutbox.expediente_ref == expediente_id,
+            EfcSyncOutbox.kind == KIND_EXPEDIENTE,
+            EfcSyncOutbox.status.in_((STATUS_PENDING, STATUS_SENT)),
+        )
+        .first()
+        is not None
+    )
+
+
+def enqueue_completar_best_effort(db: Session, expediente: Case, campos: dict) -> None:
+    """Encola el completado del provisional en EFC con la data aduanera real."""
+    if not settings.EFC_API_URL:
+        return
+    try:
+        row = EfcSyncOutbox(
+            kind=KIND_COMPLETAR,
+            payload={
+                "source": "crm",
+                "crm_company_id": expediente.company_id,
+                "crm_expediente_id": expediente.id,
+                "folio": expediente.reference,
+                "pedimento": campos,
+            },
+            expediente_ref=expediente.id,
+            status=STATUS_PENDING,
+            tenant_id=expediente.tenant_id,
+            company_id=expediente.company_id,
+        )
+        with _savepoint(db):
+            db.add(row)
+            db.flush()
+    except Exception:
+        logger.warning(
+            "expediente_gateway: no se pudo encolar el completado del expediente id=%s",
+            getattr(expediente, "id", None), exc_info=True,
+        )
+        return
+    _dispatch_delivery(row.id, row.tenant_id, row.company_id)
+
+
+def _dispatch_delivery(outbox_id: int, tenant_id: int, company_id: int) -> None:
+    """Dispara la tarea de entrega propagando el contexto RLS por headers de Celery.
+
+    Best-effort: si el broker no responde, el barrido la recoge. Los headers son obligatorios —
+    ``core/celery_app.py`` materializa el contexto de RLS a partir de ellos, y sin ellos la tarea
+    corre sin tenant y no ve nada.
+    """
+    try:
+        from .tasks import deliver_outbox_row  # import diferido: evita ciclo con celery_app
+        deliver_outbox_row.apply_async(
+            args=[outbox_id, tenant_id, company_id],
+            headers={"rls_tenant_id": str(tenant_id), "rls_company_id": str(company_id)},
+        )
+    except Exception:
+        logger.warning(
+            "expediente_gateway: no se pudo despachar la entrega outbox_id=%s (lo tomará el sweep)",
+            outbox_id, exc_info=True,
+        )
+
+
+def deliver_row(db: Session, row: EfcSyncOutbox, client: Optional[EfcClient] = None) -> None:
+    """Entrega una fila del outbox de expedientes a EFC. Actualiza estado y ``attempts``.
+
+    **No lanza nunca**: los fallos se registran en la propia fila para reconciliación. Un fallo no
+    puede matar al worker ni perder la intención de entregar.
+    """
+    client = client or efc_client
+    if not client.is_configured:
+        logger.info("expediente_gateway: EFC no configurado; se deja pendiente row=%s", row.id)
+        return
+    if row.status == STATUS_SENT:
+        return
+    try:
+        if row.kind == KIND_EXPEDIENTE:
+            _deliver_expediente(db, row, client)
+        elif row.kind == KIND_COMPLETAR:
+            _deliver_completar(db, row, client)
+        else:
+            row.status = STATUS_FAILED
+            row.last_error = f"kind desconocido: {row.kind}"
+            db.commit()
+    except EfcClientError as exc:
+        _register_failure(db, row, exc, retryable=exc.retryable)
+    except Exception as exc:  # noqa: BLE001 — cualquier fallo se registra, no rompe el worker
+        _register_failure(db, row, exc, retryable=True)
+
+
+def _register_failure(db: Session, row: EfcSyncOutbox, exc: Exception, retryable: bool) -> None:
+    row.attempts = (row.attempts or 0) + 1
+    row.last_error = str(exc)[:2000]
+    if (not retryable) or row.attempts >= MAX_ATTEMPTS:
+        row.status = STATUS_FAILED
+    db.commit()
+    logger.warning(
+        "expediente_gateway: entrega falló row=%s attempts=%s retryable=%s status=%s: %s",
+        row.id, row.attempts, retryable, row.status, exc,
+    )
+
+
+def _deliver_expediente(db: Session, row: EfcSyncOutbox, client: EfcClient) -> None:
+    payload = dict(row.payload or {})
+    org_id = _resolve_org_id(client, row.tenant_id)
+    payload["organizacion"] = {"efc_organizacion_id": org_id}
+    payload["crm_tenant_slug"] = _tenant_slug(row.tenant_id)[0] or ""
+    resp = client.ingest_expediente(payload)
+    efc = (resp or {}).get("efc") or {}
+
+    row.status = STATUS_SENT
+    row.sent_at = datetime.now(timezone.utc)
+    row.efc_pedimento_id = efc.get("pedimento_id")
+    _stamp_expediente_link(db, row.expediente_ref, org_id, efc.get("pedimento_id"))
+    db.commit()
+    logger.info(
+        "expediente_gateway: expediente replicado row=%s efc_pedimento_id=%s",
+        row.id, row.efc_pedimento_id,
+    )
+
+
+def _deliver_completar(db: Session, row: EfcSyncOutbox, client: EfcClient) -> None:
+    payload = dict(row.payload or {})
+    org_id = _resolve_org_id(client, row.tenant_id)
+    payload["organizacion"] = {"efc_organizacion_id": org_id}
+    payload["crm_tenant_slug"] = _tenant_slug(row.tenant_id)[0] or ""
+    folio = payload.get("folio")
+    client.completar_expediente(folio, payload)
+    row.status = STATUS_SENT
+    row.sent_at = datetime.now(timezone.utc)
+    db.commit()
+    logger.info("expediente_gateway: expediente completado en EFC row=%s folio=%s", row.id, folio)
+
+
+def _stamp_expediente_link(db: Session, expediente_id: Optional[int], org_id: str,
+                           pedimento_id: Optional[str]) -> None:
+    """Refleja en la fila del expediente que EFC ya lo tiene, para que la UI lo pinte.
+
+    Es un espejo, no un handle: el CRM sigue hablando de este expediente por su ``folio``. Se guarda
+    porque el proxy de descarga necesita el ``organizacion_id`` para preguntarle a EFC.
+    """
+    if expediente_id is None:
+        return
+    expediente = db.query(Case).filter(Case.id == expediente_id).first()
+    if expediente is None:
+        return
+    expediente.efc_organizacion_id = org_id
+    if pedimento_id:
+        expediente.efc_pedimento_id = pedimento_id
+    expediente.efc_link_state = "LINKED"
+    expediente.efc_error_code = None
+    expediente.efc_error_detail = None
+
+
+# ══ Archivos: encolado y entrega ════════════════════════════════════════════
+
+def _ya_entregado(db: Session, source_table: str, source_id: int, kind: str) -> bool:
+    """¿Este archivo ya se entregó al expediente? Evita re-encolar lo que ya está allá.
+
+    Sin esta guarda, un reintento encolaba otra entrega del mismo archivo — que además **falla al
+    leer el objeto local, porque la primera entrega ya lo borró** con ``delete_local``. Ruido en el
+    log y una fila del outbox condenada a ``failed``.
+
+    Lleva ``source_table`` además de ``source_id``, a diferencia del original: el CRM tiene dos
+    tablas de documentos con secuencias independientes, así que el id solo es ambiguo y esta guarda
+    se dispararía de más, saltándose la entrega de un documento distinto que casualmente comparte
+    entero.
+    """
+    return (
+        db.query(EfcFileOutbox.id)
+        .filter(
+            EfcFileOutbox.source_table == source_table,
+            EfcFileOutbox.source_id == source_id,
+            EfcFileOutbox.kind == kind,
+            EfcFileOutbox.status == STATUS_SENT,
+        )
+        .first()
+        is not None
+    )
+
+
+def enqueue_file_best_effort(
+    db: Session,
+    *,
+    kind: str,
+    s3_key: str,
+    file_name: str,
+    content_type: Optional[str],
+    efc_tipo: str,
+    source_table: str,
+    source_id: int,
+    crm_document_ref: str,
+    expediente_ref: int,
+    tenant_id: int,
+    company_id: int,
+    delete_local: bool = True,
+) -> Optional[EfcFileOutbox]:
+    """Encola un archivo hacia el expediente de EFC. Devuelve la fila, o ``None`` si no se encoló.
+
+    **No commitea**: la fila va en la misma transacción que el documento que la origina, de modo que
+    no puede existir un documento sin su intención de entrega ni al revés.
+    """
+    if not settings.EFC_API_URL:
+        return None
+    if _ya_entregado(db, source_table, source_id, kind):
+        return None
+    try:
+        row = EfcFileOutbox(
+            kind=kind,
+            s3_key=s3_key,
+            file_name=file_name,
+            content_type=content_type,
+            efc_tipo=efc_tipo,
+            source_table=source_table,
+            source_id=source_id,
+            crm_document_ref=crm_document_ref,
+            expediente_ref=expediente_ref,
+            delete_local=delete_local,
+            status=STATUS_PENDING,
+            tenant_id=tenant_id,
+            company_id=company_id,
+        )
+        with _savepoint(db):
+            db.add(row)
+            db.flush()
+        return row
+    except Exception:
+        logger.warning(
+            "expediente_gateway: no se pudo encolar el archivo %s (%s:%s)",
+            s3_key, source_table, source_id, exc_info=True,
+        )
+        return None
+
+
+def _dispatch_file_delivery(outbox_id: int, tenant_id: int, company_id: int) -> None:
+    try:
+        from .tasks import deliver_file_outbox_row  # import diferido
+        deliver_file_outbox_row.apply_async(
+            args=[outbox_id, tenant_id, company_id],
+            headers={"rls_tenant_id": str(tenant_id), "rls_company_id": str(company_id)},
+        )
+    except Exception:
+        logger.warning(
+            "expediente_gateway: no se pudo despachar entrega de archivo outbox_id=%s (lo tomará el sweep)",
+            outbox_id, exc_info=True,
+        )
+
+
+def deliver_file_row(db: Session, row: EfcFileOutbox, client: Optional[EfcClient] = None) -> None:
+    """Sube el archivo de ``row.s3_key`` al expediente de EFC y, si ``delete_local``, borra la copia.
+
+    **Ensure-then-upload**: si EFC contesta 404 ``expediente_no_encontrado``, la creación del
+    provisional puede venir en camino (el outbox de expedientes y el de archivos son colas
+    distintas), así que se asegura el expediente y se reintenta el upload **una** vez.
+
+    **No lanza nunca**: como ``deliver_row``, registra el fallo en la propia fila.
+    """
+    client = client or efc_client
+    if not client.is_configured or row.status == STATUS_SENT:
+        return
+    try:
+        org_id = _resolve_org_id(client, row.tenant_id)
+        expediente = db.query(Case).filter(Case.id == row.expediente_ref).first()
+        if expediente is None:
+            raise EfcClientError(
+                f"expediente {row.expediente_ref} no encontrado para el archivo '{row.kind}'",
+                retryable=True,
+            )
+
+        from core.storage_s3 import get_object_bytes
+        content = get_object_bytes(row.s3_key)
+        ct = row.content_type or "application/octet-stream"
+
+        try:
+            resp = client.upload_documento(
+                org_id, row.company_id, expediente.id, row.efc_tipo,
+                row.file_name, content, ct, crm_document_ref=row.crm_document_ref,
+            )
+        except EfcClientError as exc:
+            if exc.status_code == 404 and exc.code == "expediente_no_encontrado":
+                # La creación del provisional puede venir en camino: se asegura y se reintenta UNA vez.
+                client.ingest_expediente({
+                    "source": "crm",
+                    "crm_tenant_slug": (_tenant_slug(row.tenant_id)[0] or ""),
+                    "crm_company_id": row.company_id,
+                    "crm_expediente_id": expediente.id,
+                    "folio": expediente.reference,
+                    "storage_token": expediente.efc_storage_token,
+                    "organizacion": {"efc_organizacion_id": org_id},
+                })
+                resp = client.upload_documento(
+                    org_id, row.company_id, expediente.id, row.efc_tipo,
+                    row.file_name, content, ct, crm_document_ref=row.crm_document_ref,
+                )
+            else:
+                raise
+
+        doc_id = resp.get("id") if isinstance(resp, dict) else None
+
+        if row.delete_local:
+            try:
+                from core.storage_s3 import delete_object_if_exists
+                delete_object_if_exists(row.s3_key)
+            except Exception:
+                # Ya está en EFC: no poder borrar la copia local no invalida la entrega.
+                logger.warning(
+                    "expediente_gateway: no se pudo borrar el archivo local %s (ya en EFC)",
+                    row.s3_key, exc_info=True,
+                )
+
+        row.status = STATUS_SENT
+        row.sent_at = datetime.now(timezone.utc)
+        row.efc_document_id = doc_id
+        db.commit()
+        _marcar_documento_entregado(db, row, doc_id)
+        logger.info(
+            "expediente_gateway: archivo entregado row=%s kind=%s efc_document_id=%s",
+            row.id, row.kind, doc_id,
+        )
+    except EfcClientError as exc:
+        _register_file_failure(db, row, exc, exc.retryable)
+    except Exception as exc:  # noqa: BLE001
+        _register_file_failure(db, row, exc, True)
+
+
+def _register_file_failure(db: Session, row: EfcFileOutbox, exc: Exception, retryable: bool) -> None:
+    row.attempts = (row.attempts or 0) + 1
+    row.last_error = str(exc)[:2000]
+    if (not retryable) or row.attempts >= MAX_ATTEMPTS:
+        row.status = STATUS_FAILED
+    db.commit()
+    _marcar_documento_fallido(db, row, exc)
+    logger.warning(
+        "expediente_gateway: entrega de archivo falló row=%s attempts=%s status=%s: %s",
+        row.id, row.attempts, row.status, exc,
+    )
+
+
+# El mapa (kind, source_table) -> modelo del documento de origen. Un par que NO esté aquí **no toca
+# nada**, en vez de caer por omisión sobre una tabla cualquiera: escribir con el id de otra tabla
+# vaciaría las columnas de un documento ajeno que tuviera ese mismo entero — daño en el dato de otro,
+# sin un solo error visible.
+def _modelo_de_origen(source_table: str):
+    if source_table == "crm.documents":
+        from ..documents.models import Document
+        return Document
+    if source_table == "ops.shipment_documents":
+        from api.v1.modules.ops.shipments.models import ShipmentDocument
+        return ShipmentDocument
+    return None
+
+
+def _fila_de_origen(db: Session, row: EfcFileOutbox):
+    modelo = _modelo_de_origen(row.source_table)
+    if modelo is None or row.source_id is None:
+        return None
+    return (
+        db.query(modelo)
+        .filter(
+            modelo.id == row.source_id,
+            modelo.tenant_id == row.tenant_id,
+            modelo.company_id == row.company_id,
+        )
+        .first()
+    )
+
+
+def _marcar_documento_entregado(db: Session, row: EfcFileOutbox, doc_id) -> None:
+    """Cierra la entrega en la fila del documento: el badge de la UI pasa a «En expediente»."""
+    documento = _fila_de_origen(db, row)
+    if documento is None:
+        return
+    documento.efc_document_id = str(doc_id) if doc_id else None
+    documento.efc_sync_state = "SYNCED"
+    documento.efc_synced_at = datetime.now(timezone.utc)
+    documento.efc_error_code = None
+    documento.efc_error_detail = None
+    if row.delete_local:
+        # El objeto local ya no está: dejar la key apuntaría a algo inexistente y la descarga se
+        # ramificaría por el camino equivocado.
+        documento.file_key = None
+    db.commit()
+
+
+def _marcar_documento_fallido(db: Session, row: EfcFileOutbox, exc: Exception) -> None:
+    """Refleja el fallo en la fila del documento para que la ficha lo muestre sin ir a los logs."""
+    documento = _fila_de_origen(db, row)
+    if documento is None:
+        return
+    documento.efc_attempts = row.attempts
+    documento.efc_error_detail = str(exc)[:2000]
+    documento.efc_error_code = getattr(exc, "code", None)
+    if row.status == STATUS_FAILED:
+        documento.efc_sync_state = "FAILED"
+    db.commit()
+
+
+# ══ Organización ════════════════════════════════════════════════════════════
+
+def _resolve_org_id(client: EfcClient, tenant_id: int) -> str:
+    slug, name = _tenant_slug(tenant_id)
+    if not slug:
+        raise EfcClientError(
+            f"tenant {tenant_id} sin slug; no se puede resolver la organización EFC.",
+            retryable=False,
+        )
+    if slug in _org_id_cache:
+        return _org_id_cache[slug]
+    resp = client.resolve_organizacion(slug, name)
+    org_id = resp.get("id") if isinstance(resp, dict) else None
+    if not org_id:
+        raise EfcClientError("El resolver de organización de EFC no devolvió id.", retryable=True)
+    _org_id_cache[slug] = org_id
+    return org_id
+
+
+def _tenant_slug(tenant_id: int) -> tuple[Optional[str], Optional[str]]:
+    from api.v1.modules.core.tenants.models import Tenant
+
+    with scoped_core_db(tenant_id=tenant_id) as db:
+        t = db.query(Tenant).filter(Tenant.id == tenant_id).first()
+        if t is None:
+            return None, None
+        return t.slug, t.name
+
+
+# ══ Tablero de ops ══════════════════════════════════════════════════════════
+
+def _outbox_to_dict(r: EfcSyncOutbox) -> dict:
+    return {
+        "id": r.id,
+        "tabla": "sync",
+        "kind": r.kind,
+        "status": r.status,
+        "attempts": r.attempts,
+        "last_error": r.last_error,
+        "expediente_ref": r.expediente_ref,
+        "efc_pedimento_id": r.efc_pedimento_id,
+        "created_at": r.created_at.isoformat() if r.created_at else None,
+        "sent_at": r.sent_at.isoformat() if r.sent_at else None,
+    }
+
+
+def _file_outbox_to_dict(r: EfcFileOutbox) -> dict:
+    return {
+        "id": r.id,
+        "tabla": "file",
+        "kind": r.kind,
+        "status": r.status,
+        "attempts": r.attempts,
+        "last_error": r.last_error,
+        "expediente_ref": r.expediente_ref,
+        "file_name": r.file_name,
+        "efc_tipo": r.efc_tipo,
+        "source_table": r.source_table,
+        "source_id": r.source_id,
+        "crm_document_ref": r.crm_document_ref,
+        "efc_document_id": r.efc_document_id,
+        "created_at": r.created_at.isoformat() if r.created_at else None,
+        "sent_at": r.sent_at.isoformat() if r.sent_at else None,
+    }
+
+
+def list_outbox(db: Session, tenant_id: int, company_id: int, tipo: Optional[str] = None,
+                status: Optional[str] = None, limit: int = 100) -> list[dict]:
+    """Lista filas de los DOS outbox para el tablero de ops. ``tipo`` ∈ ``sync`` | ``file``."""
+    salida: list[dict] = []
+
+    if tipo in (None, "", "sync"):
+        q = db.query(EfcSyncOutbox).filter(
+            EfcSyncOutbox.tenant_id == tenant_id, EfcSyncOutbox.company_id == company_id
+        )
+        if status:
+            q = q.filter(EfcSyncOutbox.status == status)
+        salida += [
+            _outbox_to_dict(r)
+            for r in q.order_by(EfcSyncOutbox.created_at.desc()).limit(limit).all()
+        ]
+
+    if tipo in (None, "", "file"):
+        q = db.query(EfcFileOutbox).filter(
+            EfcFileOutbox.tenant_id == tenant_id, EfcFileOutbox.company_id == company_id
+        )
+        if status:
+            q = q.filter(EfcFileOutbox.status == status)
+        salida += [
+            _file_outbox_to_dict(r)
+            for r in q.order_by(EfcFileOutbox.created_at.desc()).limit(limit).all()
+        ]
+
+    salida.sort(key=lambda d: (d.get("created_at") or ""), reverse=True)
+    return salida[:limit]
+
+
+def retry_outbox_row(db: Session, outbox_id: int, tenant_id: int, company_id: int,
+                     tipo: str = "file") -> bool:
+    """Reintento manual: resetea la fila a ``pending`` (``attempts=0``) y la re-despacha.
+
+    Devuelve ``False`` si no existe para ese tenant/company — el llamador lo traduce a **404 con
+    mensaje específico**, no a un 200 silencioso: es contrato con el frontend, que pinta el botón
+    según lo que reciba.
+    """
+    modelo = EfcSyncOutbox if tipo == "sync" else EfcFileOutbox
+    r = (
+        db.query(modelo)
+        .filter(modelo.id == outbox_id, modelo.tenant_id == tenant_id, modelo.company_id == company_id)
+        .first()
+    )
+    if r is None:
+        return False
+    r.status = STATUS_PENDING
+    r.attempts = 0
+    r.last_error = None
+    db.commit()
+    if tipo == "sync":
+        _dispatch_delivery(r.id, r.tenant_id, r.company_id)
+    else:
+        _reset_documento_pendiente(db, r)
+        _dispatch_file_delivery(r.id, r.tenant_id, r.company_id)
+    return True
+
+
+def _reset_documento_pendiente(db: Session, row: EfcFileOutbox) -> None:
+    documento = _fila_de_origen(db, row)
+    if documento is None:
+        return
+    documento.efc_sync_state = "PENDING"
+    documento.efc_error_code = None
+    documento.efc_error_detail = None
+    db.commit()
+
+
+def outbox_metrics(db: Session, tenant_id: int, company_id: int) -> dict:
+    """Conteo de los dos outbox por status (monitoreo). Los conteos suman las dos tablas."""
+    from sqlalchemy import func
+
+    counts = {STATUS_PENDING: 0, STATUS_SENT: 0, STATUS_FAILED: 0}
+    for modelo in (EfcSyncOutbox, EfcFileOutbox):
+        rows = (
+            db.query(modelo.status, func.count())
+            .filter(modelo.tenant_id == tenant_id, modelo.company_id == company_id)
+            .group_by(modelo.status)
+            .all()
+        )
+        for estado, n in rows:
+            counts[estado] = counts.get(estado, 0) + n
+    return {
+        "pending": counts.get(STATUS_PENDING, 0),
+        "sent": counts.get(STATUS_SENT, 0),
+        "failed": counts.get(STATUS_FAILED, 0),
+    }
+
+
+def find_expediente_gaps(db: Session, limit: int = 200) -> list:
+    """Expedientes (no borrados) SIN ninguna fila de outbox que los referencie.
+
+    Nunca se encolaron: expedientes creados **antes** de activar la integración, o un crash. Se
+    re-encolan para no perder la réplica.
+
+    Los ``failed`` **no son huecos** —existen como fila, son visibles y reintentables desde el
+    tablero—, así que la fila los excluye por estar presente, no por su estado. Corre sin contexto
+    de tenant (beat); cada expediente lleva el suyo.
+    """
+    from sqlalchemy import exists
+
+    ya_encolado = exists().where(EfcSyncOutbox.expediente_ref == Case.id)
+    return (
+        db.query(Case)
+        .filter(
+            Case.deleted_at.is_(None),
+            ~ya_encolado,
+            # Mismo criterio que el encolado: lo que le falta folio o token no es un hueco
+            # recuperable, es algo que EFC rechazaría siempre. Sin este filtro la
+            # reconciliación los reencola cada 5 minutos para verlos fallar de nuevo.
+            Case.reference.isnot(None),
+            Case.efc_storage_token.isnot(None),
+        )
+        .order_by(Case.id.desc())
+        .limit(limit)
+        .all()
+    )

backend/api/v1/modules/crm/expediente_gateway/storage.py

@@ -0,0 +1,39 @@
+"""La llave de almacenamiento del expediente en EFC.
+
+Vive en el carril y no en el módulo del expediente a propósito: el expediente (``crm.cases``) es
+del CRM y no sabe nada de EFC; esto es exclusivamente cómo EFC nombra su carpeta.
+
+El generador de folios NO está aquí. Es ``crm/common/folios.py::next_folio``, que ya reserva el
+consecutivo mensual por ``(tenant, company, entidad, periodo)`` con bloqueo de fila. El carril lo
+consume, no lo reimplementa.
+"""
+
+from __future__ import annotations
+
+# Longitud de ``Pedimento.pedimento_app`` en EFC (api/customs/models.py). El token se guarda ahí.
+PEDIMENTO_APP_MAX = 25
+
+
+def storage_token(company_id: int, folio: str) -> str:
+    """``CRM-{company_id}-{folio}`` — la llave del pedimento provisional en EFC.
+
+    Empieza con letras, así que es imposible que colisione con la llave de un pedimento real, que
+    es ``^\\d{2}-\\d{2}-\\d{4}-\\d{7}$``. El ``company_id`` va dentro porque el puente con EFC es
+    tenant → organización 1:1 pero un tenant tiene N companies: sin él, dos companies del mismo
+    tenant generarían el mismo ``EXP2026-08-001`` y chocarían en el ``unique_together`` de EFC.
+
+    PRESUPUESTO DE CARACTERES: ``CRM-`` (4) + company + ``-`` (1) + ``EXP2026-08-001`` (14) = 19 +
+    los dígitos del company. En los 25 de ``pedimento_app`` caben hasta **6 dígitos** de company,
+    no 7 como decía la primera versión de este docstring: con 7 salen 26 y el insert del lado de
+    EFC reventaría. Un consecutivo de 4 dígitos (mes con más de 999 expedientes) gasta uno más.
+
+    Se valida en vez de truncar: un token recortado apuntaría a la carpeta de OTRO expediente y
+    los documentos se mezclarían en silencio, que es peor que fallar aquí.
+    """
+    token = f"CRM-{company_id}-{folio}"
+    if len(token) > PEDIMENTO_APP_MAX:
+        raise ValueError(
+            f"storage_token de {len(token)} caracteres excede los {PEDIMENTO_APP_MAX} de "
+            f"pedimento_app en EFC: {token!r}. Revisa el largo del company_id o del consecutivo."
+        )
+    return token

backend/api/v1/modules/crm/expediente_gateway/tasks.py

@@ -0,0 +1,143 @@
+"""Tareas Celery del carril CRM Agentes de Carga -> EFC.
+
+- ``deliver_outbox_row`` / ``sweep_outbox``: expedientes (alta del provisional y completado).
+- ``deliver_file_outbox_row`` / ``sweep_file_outbox``: archivos.
+- ``sweep_expediente_gaps``: reconciliación de expedientes que nunca se encolaron.
+
+**La trampa de RLS, que es lo que más fácil se pasa por alto.** ``core/celery_app.py`` materializa el
+contexto desde los headers ``rls_tenant_id`` / ``rls_company_id``. Por tanto:
+
+- Las tareas **por fila** se despachan siempre con esos headers.
+- Los **barridos corren sin contexto de tenant**: leen los ids pendientes con una sesión sin scope y
+  despachan una tarea hija por fila con sus propios headers. Si un barrido abriera una sesión con
+  scope e iterara, o no vería nada o se saltaría el aislamiento.
+
+**Sin ``autoretry_for``, ``retry_backoff`` ni ``max_retries``**: duplicarían el mecanismo de
+reintento que ya está en el cliente (3 intentos con backoff lineal) y en el barrido (cada 120 s
+hasta ``MAX_ATTEMPTS``).
+"""
+import logging
+
+from core.celery_app import celery_app
+from core.config import settings
+from core.database import scoped_core_db
+
+from . import service
+from .models import STATUS_PENDING, EfcFileOutbox, EfcSyncOutbox
+
+# ── Registro de modelos: NO son imports decorativos, no los quites ──────────────────────
+# El worker de Celery NO carga la app: importa este módulo y sus dependencias, y nada más.
+# SQLAlchemy resuelve las ForeignKey por NOMBRE de tabla contra su registro global, así que
+# si la clase del otro extremo nunca se importó, la configuración de mappers falla con
+#
+#   Foreign key associated with column 'cases.account_id' could not find table 'crm.accounts'
+#
+# y la tarea muere con PendingRollbackError. El síntoma es cruel: la fila del outbox se
+# queda en `pending` con attempts=0 y SIN last_error —porque el fallo ocurre antes de poder
+# registrarlo—, así que el carril se ve encolando bien y no entrega nunca. En la app web no
+# pasa: `main.py` monta todos los routers y con ellos se importan todos los modelos.
+#
+# El juego es el mínimo verificado con `configure_mappers()` en un proceso limpio:
+#   - accounts : cierra la FK cases.account_id, que es la que rompía;
+#   - documents y ops.shipments : las dos fuentes del outbox de archivos;
+#   - tenants  : lo consulta el resolver de organización al entregar.
+from api.v1.modules.core.tenants import models as _m_tenants  # noqa: F401
+from api.v1.modules.crm.accounts import models as _m_accounts  # noqa: F401
+from api.v1.modules.crm.documents import models as _m_documents  # noqa: F401
+from api.v1.modules.ops.shipments import models as _m_shipments  # noqa: F401
+
+logger = logging.getLogger(__name__)
+
+
+# ── Expedientes ─────────────────────────────────────────────────────────────
+
+@celery_app.task(name="expediente_gateway.deliver_outbox_row")
+def deliver_outbox_row(outbox_id: int, tenant_id: int, company_id: int) -> None:
+    with scoped_core_db(tenant_id, company_id) as db:
+        row = db.query(EfcSyncOutbox).filter(EfcSyncOutbox.id == outbox_id).first()
+        if row is None:
+            logger.warning(
+                "expediente_gateway: outbox_id=%s no encontrado (tenant=%s)", outbox_id, tenant_id
+            )
+            return
+        service.deliver_row(db, row)
+
+
+@celery_app.task(name="expediente_gateway.sweep_outbox")
+def sweep_outbox(limit: int = 100) -> int:
+    """Re-despacha filas pendientes de expediente. Sin contexto de tenant: cada fila lleva el suyo."""
+    with scoped_core_db() as db:
+        rows = (
+            db.query(EfcSyncOutbox.id, EfcSyncOutbox.tenant_id, EfcSyncOutbox.company_id)
+            .filter(EfcSyncOutbox.status == STATUS_PENDING)
+            .order_by(EfcSyncOutbox.created_at.asc())
+            .limit(limit)
+            .all()
+        )
+
+    for rid, tid, cid in rows:
+        deliver_outbox_row.apply_async(
+            args=[rid, tid, cid],
+            headers={"rls_tenant_id": str(tid), "rls_company_id": str(cid) if cid is not None else ""},
+        )
+    if rows:
+        logger.info("expediente_gateway: sweep (expedientes) re-despachó %s filas pendientes", len(rows))
+    return len(rows)
+
+
+# ── Archivos ────────────────────────────────────────────────────────────────
+
+@celery_app.task(name="expediente_gateway.deliver_file_outbox_row")
+def deliver_file_outbox_row(outbox_id: int, tenant_id: int, company_id: int) -> None:
+    with scoped_core_db(tenant_id, company_id) as db:
+        row = db.query(EfcFileOutbox).filter(EfcFileOutbox.id == outbox_id).first()
+        if row is None:
+            logger.warning(
+                "expediente_gateway: file outbox_id=%s no encontrado (tenant=%s)", outbox_id, tenant_id
+            )
+            return
+        service.deliver_file_row(db, row)
+
+
+@celery_app.task(name="expediente_gateway.sweep_file_outbox")
+def sweep_file_outbox(limit: int = 100) -> int:
+    """Re-despacha archivos pendientes (EFC o el broker caídos cuando el usuario subió el archivo)."""
+    with scoped_core_db() as db:
+        rows = (
+            db.query(EfcFileOutbox.id, EfcFileOutbox.tenant_id, EfcFileOutbox.company_id)
+            .filter(EfcFileOutbox.status == STATUS_PENDING)
+            .order_by(EfcFileOutbox.created_at.asc())
+            .limit(limit)
+            .all()
+        )
+    for rid, tid, cid in rows:
+        deliver_file_outbox_row.apply_async(
+            args=[rid, tid, cid],
+            headers={"rls_tenant_id": str(tid), "rls_company_id": str(cid) if cid is not None else ""},
+        )
+    if rows:
+        logger.info("expediente_gateway: sweep (archivos) re-despachó %s archivos pendientes", len(rows))
+    return len(rows)
+
+
+# ── Reconciliación de huecos ────────────────────────────────────────────────
+
+@celery_app.task(name="expediente_gateway.sweep_expediente_gaps")
+def sweep_expediente_gaps(limit: int = 200) -> int:
+    """Detecta expedientes que nunca se encolaron a EFC y los re-encola.
+
+    No-op si la integración está apagada.
+    """
+    if not settings.EFC_API_URL:
+        return 0
+    n = 0
+    with scoped_core_db() as db:
+        gaps = service.find_expediente_gaps(db, limit=limit)
+        for expediente in gaps:
+            service.replicate_expediente_best_effort(db, expediente)
+            n += 1
+        if n:
+            db.commit()
+    if n:
+        logger.info("expediente_gateway: sweep de huecos re-encoló %s expedientes", n)
+    return n

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

@@ -11,6 +11,7 @@ class LeadCreate(BaseModel):
     phone: str | None = Field(None, max_length=40)
     company_name: str | None = Field(None, max_length=255)
     source: str | None = Field(None, max_length=60)
+    preferred_contact_method: str | None = Field(None, max_length=20)
     status: str = Field("new", max_length=20)
     estimated_value: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=2)
     owner_user_id: str | None = Field(None, max_length=64)
@@ -24,6 +25,7 @@ class LeadUpdate(BaseModel):
     phone: str | None = Field(None, max_length=40)
     company_name: str | None = Field(None, max_length=255)
     source: str | None = Field(None, max_length=60)
+    preferred_contact_method: str | None = Field(None, max_length=20)
     status: str | None = Field(None, max_length=20)
     estimated_value: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=2)
     owner_user_id: str | None = Field(None, max_length=64)
@@ -50,6 +52,7 @@ class LeadResponse(BaseModel):
     phone: str | None
     company_name: str | None
     source: str | None
+    preferred_contact_method: str | None = None
     status: str
     estimated_value: Decimal | None
     owner_user_id: str | None

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

@@ -19,6 +19,8 @@ class Lead(Base, TenantScopedMixin, TimestampMixin):
     company_name: Mapped[str | None] = mapped_column(String(255), nullable=True)
     # Origen: web | referido | evento | llamada | email | otro
     source: Mapped[str | None] = mapped_column(String(60), nullable=True)
+    # Medio de contacto preferido (catálogo medio_contacto): llamada|correo|whatsapp|…
+    preferred_contact_method: Mapped[str | None] = mapped_column(String(20), nullable=True)
     # Estado: new | contacted | qualified | unqualified | converted
     status: Mapped[str] = mapped_column(String(20), nullable=False, server_default=text("'new'"), index=True)
     estimated_value: Mapped[float | None] = mapped_column(Numeric(14, 2), nullable=True)

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

@@ -17,6 +17,7 @@ class OpportunityCreate(BaseModel):
     source: str | None = Field(None, max_length=60)
     owner_user_id: str | None = Field(None, max_length=64)
     notes: str | None = None
+    operation_type: str | None = Field(None, max_length=20)  # importacion | exportacion
 
 
 class OpportunityUpdate(BaseModel):
@@ -30,10 +31,13 @@ class OpportunityUpdate(BaseModel):
     probability: int | None = Field(None, ge=0, le=100)
     status: str | None = Field(None, max_length=20)
     expected_close_date: date | None = None
+    won_date: date | None = None
+    lost_date: date | None = None
     lost_reason: str | None = Field(None, max_length=255)
     source: str | None = Field(None, max_length=60)
     owner_user_id: str | None = Field(None, max_length=64)
     notes: str | None = None
+    operation_type: str | None = Field(None, max_length=20)
 
 
 class OpportunityMove(BaseModel):
@@ -57,10 +61,16 @@ class OpportunityResponse(BaseModel):
     status: str
     expected_close_date: date | None
     closed_at: datetime | None
+    won_date: date | None = None
+    lost_date: date | None = None
     lost_reason: str | None
     source: str | None
     owner_user_id: str | None
     notes: str | None
+    operation_type: str | None = None
+    reference: str | None = None
+    case_id: int | None = None
+    converted_service_request_id: int | None = None
     tenant_id: int
     company_id: int
     created_at: datetime

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

@@ -34,7 +34,18 @@ class Opportunity(Base, TenantScopedMixin, TimestampMixin):
     status: Mapped[str] = mapped_column(String(20), nullable=False, server_default=text("'open'"), index=True)
     expected_close_date: Mapped[date | None] = mapped_column(Date, nullable=True)
     closed_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    won_date: Mapped[date | None] = mapped_column(Date, nullable=True)   # fecha en que se ganó
+    lost_date: Mapped[date | None] = mapped_column(Date, nullable=True)  # fecha en que se perdió
     lost_reason: Mapped[str | None] = mapped_column(String(255), nullable=True)
     source: Mapped[str | None] = mapped_column(String(60), nullable=True)
     owner_user_id: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
     notes: Mapped[str | None] = mapped_column(Text, nullable=True)
+    # Dirección de la operación (importacion|exportacion): se hereda a Solicitud→Cotización→Embarque
+    operation_type: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    reference: Mapped[str | None] = mapped_column(String(40), nullable=True, index=True)  # folio O...
+    # Expediente (hilo maestro del trámite); nace aquí y se hereda hacia abajo
+    case_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("crm.cases.id"), nullable=True, index=True)
+    # Solicitud generada al convertir la oportunidad (back-link idempotente)
+    converted_service_request_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("crm.service_requests.id"), nullable=True
+    )

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

@@ -1,9 +1,11 @@
-from datetime import datetime, timezone
+from datetime import date, datetime, timezone
 
 from fastapi import HTTPException, status
 from sqlalchemy.orm import Session
 
 from ..accounts.models import Account
+from ..cases import service as cases_service
+from ..common.folios import next_folio
 from ..contacts.models import Contact
 from ..pipelines.models import Pipeline, PipelineStage
 from .dto import OpportunityCreate, OpportunityUpdate
@@ -46,14 +48,20 @@ def _apply_stage_state(opportunity: Opportunity, stage: PipelineStage) -> None:
         opportunity.status = "won"
         opportunity.probability = 100
         opportunity.closed_at = datetime.now(timezone.utc)
+        opportunity.won_date = opportunity.won_date or date.today()
+        opportunity.lost_date = None
     elif stage.is_lost:
         opportunity.status = "lost"
         opportunity.probability = 0
         opportunity.closed_at = datetime.now(timezone.utc)
+        opportunity.lost_date = opportunity.lost_date or date.today()
+        opportunity.won_date = None
     else:
         opportunity.status = "open"
         opportunity.probability = stage.probability
         opportunity.closed_at = None
+        opportunity.won_date = None
+        opportunity.lost_date = None
 
 
 def _validate_refs(db: Session, data: dict, tenant_id: int, company_id: int) -> None:
@@ -149,6 +157,15 @@ def create_opportunity(
     if opportunity.stage_id is not None:
         stage = _get_scoped_stage(db, opportunity.stage_id, tenant_id, company_id)
         _apply_stage_state(opportunity, stage)
+    # Folio O... auto-generado (mensual). La dirección impo/expo se hereda al ciclo.
+    if not opportunity.reference:
+        opportunity.reference = next_folio(db, tenant_id, company_id, "O", opportunity.operation_type)
+    # Expediente: nace con la oportunidad y se hereda a solicitud/cotización/operación/factura
+    if not opportunity.case_id:
+        case = cases_service.create_case(
+            db, tenant_id, company_id, account_id=opportunity.account_id, title=opportunity.name, stage="oportunidad",
+        )
+        opportunity.case_id = case.id
     db.add(opportunity)
     db.commit()
     db.refresh(opportunity)

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

@@ -56,6 +56,7 @@ class QuoteBase(BaseModel):
     service_request_id: int | None = None
     account_id: int | None = None
     currency: str = Field("USD", max_length=3)
+    load_type: str | None = Field(None, max_length=10)  # FCL | LCL (variante de la comparación "Ambas")
     issue_date: date | None = None
     valid_until: date | None = None
     notes: str | None = None
@@ -72,6 +73,7 @@ class QuoteUpdate(BaseModel):
     service_request_id: int | None = None
     account_id: int | None = None
     currency: str | None = Field(None, max_length=3)
+    load_type: str | None = Field(None, max_length=10)
     issue_date: date | None = None
     valid_until: date | None = None
     notes: str | None = None
@@ -83,9 +85,12 @@ class QuoteResponse(QuoteBase):
     model_config = ConfigDict(from_attributes=True)
 
     id: int
+    service_request_reference: str | None = None  # folio de la solicitud referenciada
+    case_id: int | None = None
     status: str
     total_cost: Decimal
     total_sale: Decimal
+    pdf_file_key: str | None = None
     sent_at: datetime | None = None
     accepted_at: datetime | None = None
     rejected_at: datetime | None = None
@@ -100,3 +105,30 @@ class QuoteResponse(QuoteBase):
     @property
     def margin(self) -> Decimal:
         return (self.total_sale or Decimal(0)) - (self.total_cost or Decimal(0))
+
+
+# ----- Configuración de marca del formato de cotización -----
+
+class QuoteSettingsInput(BaseModel):
+    emitter_name: str | None = Field(None, max_length=255)
+    emitter_rfc: str | None = Field(None, max_length=13)
+    emitter_address: str | None = None
+    emitter_phone: str | None = Field(None, max_length=60)
+    emitter_email: str | None = Field(None, max_length=255)
+    emitter_website: str | None = Field(None, max_length=255)
+    accent_color: str | None = Field(None, max_length=9)
+    quote_prefix: str | None = Field(None, max_length=12)
+    default_terms: str | None = None
+    footer_note: str | None = None
+
+
+class QuoteSettingsResponse(QuoteSettingsInput):
+    model_config = ConfigDict(from_attributes=True)
+    id: int | None = None
+    logo_file_key: str | None = None
+
+
+class SendQuoteEmailRequest(BaseModel):
+    to: str | None = None
+    subject: str | None = None
+    message: str | None = None

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

@@ -15,6 +15,7 @@ class Quote(Base, TenantScopedMixin, TimestampMixin):
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     reference: Mapped[str | None] = mapped_column(String(40), nullable=True, index=True)
+    case_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("crm.cases.id"), nullable=True, index=True)  # expediente
     service_request_id: Mapped[int | None] = mapped_column(
         Integer, ForeignKey("crm.service_requests.id"), nullable=True, index=True
     )
@@ -22,6 +23,8 @@ class Quote(Base, TenantScopedMixin, TimestampMixin):
         Integer, ForeignKey("crm.accounts.id"), nullable=True, index=True
     )
     currency: Mapped[str] = mapped_column(String(3), nullable=False, server_default=text("'USD'"))
+    # Variante de carga cuando la solicitud es "Ambas": FCL | LCL (NULL si no aplica)
+    load_type: Mapped[str | None] = mapped_column(String(10), nullable=True)
     # borrador | enviada | aceptada | rechazada
     status: Mapped[str] = mapped_column(String(20), nullable=False, server_default=text("'borrador'"), index=True)
     issue_date: Mapped[date | None] = mapped_column(Date, nullable=True)
@@ -34,10 +37,35 @@ class Quote(Base, TenantScopedMixin, TimestampMixin):
     notes: Mapped[str | None] = mapped_column(Text, nullable=True)
     terms: Mapped[str | None] = mapped_column(Text, nullable=True)
     owner_user_id: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
+    # Clave del PDF generado en MinIO (para regenerar/enviar)
+    pdf_file_key: Mapped[str | None] = mapped_column(String(512), nullable=True)
     created_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
     updated_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
 
 
+class QuoteSettings(Base, TenantScopedMixin, TimestampMixin):
+    """Configuración de marca del formato de cotización, por compañía (tenant).
+
+    Encabezado del emisor, logo y textos por defecto que se imprimen en el PDF.
+    """
+
+    __tablename__ = "quote_settings"
+    __table_args__ = {"schema": "crm"}
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    emitter_name: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    emitter_rfc: Mapped[str | None] = mapped_column(String(13), nullable=True)
+    emitter_address: Mapped[str | None] = mapped_column(Text, nullable=True)
+    emitter_phone: Mapped[str | None] = mapped_column(String(60), nullable=True)
+    emitter_email: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    emitter_website: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    logo_file_key: Mapped[str | None] = mapped_column(String(512), nullable=True)
+    accent_color: Mapped[str | None] = mapped_column(String(9), nullable=True, server_default=text("'#2f6bf0'"))
+    quote_prefix: Mapped[str | None] = mapped_column(String(12), nullable=True, server_default=text("'COT'"))
+    default_terms: Mapped[str | None] = mapped_column(Text, nullable=True)
+    footer_note: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+
 class QuoteItem(Base, TenantScopedMixin, TimestampMixin):
     """Concepto de una cotización (flete, transporte terrestre, despacho, gastos destino, otros)."""
 

backend/api/v1/modules/crm/quotes/pdf.py

@@ -0,0 +1,376 @@
+"""Generador del PDF de Cotización — diseño profesional, sin dependencias de sistema.
+
+Compone un PDF 1.4 byte a byte (Helvetica / Helvetica-Bold) con barras de sección,
+tabla de costos con bordes y filas alternadas, caja de totales y logo incrustado
+(JPEG /DCTDecode vía Pillow). El branding (emisor, color) viene de la config por tenant.
+"""
+
+from __future__ import annotations
+
+import io
+from decimal import Decimal
+
+_W = 612
+_H = 792
+_ML = 50           # margen izquierdo
+_MR = 562          # margen derecho (x)
+
+CONCEPT_LABELS = {
+    "flete_internacional": "Flete internacional",
+    "transporte_terrestre": "Transporte terrestre",
+    "despacho_aduanal": "Despacho aduanal",
+    "gastos_destino": "Gastos en destino",
+    "otros": "Otros cargos",
+}
+
+_TRANSLATE = str.maketrans({"—": "-", "–": "-", "“": '"', "”": '"', "‘": "'", "’": "'", "•": "-", "…": "...", "\t": " "})
+
+
+def _esc(text) -> str:
+    s = ("" if text is None else str(text)).translate(_TRANSLATE)
+    s = s.encode("latin-1", "replace").decode("latin-1")
+    return s.replace("\\", r"\\").replace("(", r"\(").replace(")", r"\)")
+
+
+def _money(value) -> str:
+    return f"{Decimal(str(value or 0)).quantize(Decimal('0.01')):,.2f}"
+
+
+def _num(value) -> str:
+    return f"{Decimal(str(value or 0)):,.2f}"
+
+
+# Ancho aprox de una cadena en Helvetica (para alinear a la derecha / truncar)
+def _text_w(s: str, size: float, bold: bool = False) -> float:
+    return len(s) * size * (0.56 if bold else 0.52)
+
+
+def _fit(s: str, size: float, max_w: float) -> str:
+    s = s or ""
+    if _text_w(s, size) <= max_w:
+        return s
+    while s and _text_w(s + "…", size) > max_w:
+        s = s[:-1]
+    return s + "…"
+
+
+def _wrap(text: str, width_chars: int) -> list[str]:
+    words = (text or "").split()
+    if not words:
+        return []
+    out, cur = [], ""
+    for w in words:
+        cand = f"{cur} {w}".strip()
+        if len(cand) > width_chars and cur:
+            out.append(cur)
+            cur = w
+        else:
+            cur = cand
+    if cur:
+        out.append(cur)
+    return out
+
+
+def _hex_rgb(hexs: str | None) -> tuple[float, float, float]:
+    try:
+        h = (hexs or "#12294c").lstrip("#")
+        return tuple(int(h[i : i + 2], 16) / 255 for i in (0, 2, 4))  # type: ignore[return-value]
+    except Exception:
+        return (0.07, 0.16, 0.30)
+
+
+def _prep_logo(logo_bytes: bytes | None):
+    if not logo_bytes:
+        return None
+    try:
+        from PIL import Image
+
+        im = Image.open(io.BytesIO(logo_bytes)).convert("RGB")
+        im.thumbnail((600, 300))
+        buf = io.BytesIO()
+        im.save(buf, format="JPEG", quality=88)
+        return buf.getvalue(), im.width, im.height
+    except Exception:
+        return None
+
+
+class _Canvas:
+    """Acumula operadores de contenido con paginación simple."""
+
+    def __init__(self):
+        self.pages: list[list[str]] = [[]]
+        self.y = _H
+
+    @property
+    def ops(self) -> list[str]:
+        return self.pages[-1]
+
+    def new_page(self):
+        self.pages.append([])
+        self.y = _H - 50
+
+    def ensure(self, needed: float):
+        if self.y - needed < 50:
+            self.new_page()
+
+    def rect(self, x, y, w, h, rgb):
+        r, g, b = rgb
+        self.ops.append(f"{r:.3f} {g:.3f} {b:.3f} rg {x:.1f} {y:.1f} {w:.1f} {h:.1f} re f")
+
+    def line(self, x1, y1, x2, y2, rgb, width=0.6):
+        r, g, b = rgb
+        self.ops.append(f"{width} w {r:.3f} {g:.3f} {b:.3f} RG {x1:.1f} {y1:.1f} m {x2:.1f} {y2:.1f} l S")
+
+    def text(self, x, y, s, size=10, rgb=(0, 0, 0), bold=False, right=False):
+        font = "F2" if bold else "F1"
+        r, g, b = rgb
+        tx = x - _text_w(str(s), size, bold) if right else x
+        self.ops.append(f"BT /{font} {size} Tf {r:.3f} {g:.3f} {b:.3f} rg 1 0 0 1 {tx:.1f} {y:.1f} Tm ({_esc(s)}) Tj ET")
+
+
+def build_quote_pdf(
+    *,
+    emitter: dict,
+    head: dict,
+    client: dict,
+    cargo: list[tuple[str, str]],
+    route: list[tuple[str, str]],
+    items: list[dict],
+    currency: str,
+    subtotal,
+    terms: str | None,
+    footer: str | None,
+    logo_bytes: bytes | None = None,
+    accent: str | None = "#12294c",
+) -> bytes:
+    ACC = _hex_rgb(accent)
+    INK = (0.10, 0.15, 0.24)
+    GRAY = (0.42, 0.47, 0.55)
+    LINE = (0.80, 0.84, 0.90)
+    ZEBRA = (0.955, 0.965, 0.980)
+    logo = _prep_logo(logo_bytes)
+
+    c = _Canvas()
+
+    # ---------------- Encabezado ----------------
+    c.rect(0, _H - 12, _W, 12, ACC)  # banda superior
+    logo_bottom = _H - 95
+    if logo:
+        _, lw, lh = logo
+        dw, dh = 150.0, 150.0 * lh / lw
+        if dh > 55:
+            dh, dw = 55.0, 55.0 * lw / lh
+        c.ops.append(f"q {dw:.1f} 0 0 {dh:.1f} {_ML} {logo_bottom:.1f} cm /Im0 Do Q")
+    else:
+        c.text(_ML, _H - 55, emitter.get("name") or "Emisor", 16, INK, bold=True)
+
+    # Emisor (derecha)
+    ex, ey = 320, _H - 42
+    c.text(ex, ey, emitter.get("name") or "Emisor", 12, INK, bold=True)
+    ey -= 14
+    em_lines = []
+    if emitter.get("rfc"):
+        em_lines.append(f"RFC: {emitter['rfc']}")
+    for a in (emitter.get("address") or "").splitlines():
+        if a.strip():
+            em_lines.append(a.strip())
+    contact = "   ".join([x for x in [emitter.get("phone"), emitter.get("email"), emitter.get("website")] if x])
+    if contact:
+        em_lines.append(contact)
+    for ln in em_lines[:5]:
+        c.text(ex, ey, _fit(ln, 8.5, _MR - ex), 8.5, GRAY)
+        ey -= 11
+
+    # Título + regla
+    c.text(_ML, _H - 150, "COTIZACIÓN", 26, INK, bold=True)
+    c.line(_ML, _H - 158, _ML + 190, _H - 158, ACC, 2)
+
+    # Panel de datos (derecha)
+    px, pw = 320, _MR - 320
+    py_top = _H - 128
+    ph = 74
+    c.rect(px, py_top - ph, pw, ph, ZEBRA)
+    c.line(px, py_top, px, py_top - ph, LINE)
+    hy = py_top - 15
+    info = [
+        ("No.", head.get("reference") or "-"),
+        ("Fecha", head.get("issue_date") or "-"),
+        ("Vigencia", head.get("valid_until") or "-"),
+        ("Ejecutivo", head.get("owner") or "-"),
+        ("Estatus", str(head.get("status") or "-").capitalize()),
+    ]
+    for k, v in info:
+        c.text(px + 10, hy, f"{k}:", 8.5, GRAY, bold=True)
+        c.text(px + 66, hy, _fit(str(v), 9, pw - 76), 9, INK)
+        hy -= 12.5
+
+    c.y = _H - 215
+
+    # ---------------- Helpers de sección ----------------
+    def section(title: str):
+        c.ensure(30)
+        c.rect(_ML, c.y - 18, _MR - _ML, 18, ACC)
+        c.text(_ML + 8, c.y - 13, title.upper(), 9.5, (1, 1, 1), bold=True)
+        c.y -= 26
+
+    def kv_block(pairs: list[tuple[str, str]]):
+        rows = [(k, v) for k, v in pairs if v not in (None, "", "None")]
+        if not rows:
+            return False
+        col_w = (_MR - _ML) / 2
+        i = 0
+        while i < len(rows):
+            c.ensure(16)
+            for col in range(2):
+                if i + col < len(rows):
+                    k, v = rows[i + col]
+                    x = _ML + 6 + col * col_w
+                    c.text(x, c.y - 11, f"{k}:", 9, GRAY, bold=True)
+                    c.text(x + _text_w(f"{k}: ", 9, True), c.y - 11, _fit(str(v), 9, col_w - 90), 9, INK)
+            c.y -= 16
+            i += 2
+        c.y -= 4
+        return True
+
+    # ---------------- Cliente ----------------
+    section("Cliente")
+    if not kv_block([
+        ("Cliente", client.get("name")), ("RFC", client.get("rfc")),
+        ("Correo", client.get("email")), ("Teléfono", client.get("phone")),
+    ]):
+        c.text(_ML + 6, c.y - 11, "—", 9, GRAY)
+        c.y -= 16
+
+    # ---------------- Carga / Ruta (solo si hay datos) ----------------
+    if [v for _, v in cargo if v not in (None, "", "None")]:
+        section("Información de la carga")
+        kv_block(cargo)
+    if [v for _, v in route if v not in (None, "", "None")]:
+        section("Ruta logística")
+        kv_block(route)
+
+    # ---------------- Costos ----------------
+    section("Costos cotizados")
+    x_con, x_cant, x_tar, x_imp = _ML, 372, 460, _MR - 6
+    row_h = 18
+    # encabezado de tabla
+    c.ensure(row_h)
+    c.rect(_ML, c.y - row_h, _MR - _ML, row_h, ACC)
+    c.text(x_con + 6, c.y - 13, "Concepto", 9, (1, 1, 1), bold=True)
+    c.text(x_cant, c.y - 13, "Cant.", 9, (1, 1, 1), bold=True, right=True)
+    c.text(x_tar, c.y - 13, "Tarifa", 9, (1, 1, 1), bold=True, right=True)
+    c.text(x_imp, c.y - 13, "Importe", 9, (1, 1, 1), bold=True, right=True)
+    c.y -= row_h
+    z = False
+    for it in items:
+        code = str(it.get("concept") or "")
+        label = CONCEPT_LABELS.get(code, code)
+        desc = str(it.get("description") or "")
+        if desc:
+            label = f"{label} - {desc}"
+        qty = Decimal(str(it.get("quantity") or 0))
+        unit = Decimal(str(it.get("unit_sale") or 0))
+        amount = (qty * unit).quantize(Decimal("0.01"))
+        c.ensure(row_h)
+        if z:
+            c.rect(_ML, c.y - row_h, _MR - _ML, row_h, ZEBRA)
+        c.text(x_con + 6, c.y - 13, _fit(label, 9, x_cant - x_con - 40), 9, INK)
+        c.text(x_cant, c.y - 13, _num(qty), 9, INK, right=True)
+        c.text(x_tar, c.y - 13, _money(unit), 9, INK, right=True)
+        c.text(x_imp, c.y - 13, _money(amount), 9, INK, right=True)
+        c.y -= row_h
+        z = not z
+    if not items:
+        c.text(_ML + 6, c.y - 13, "Sin conceptos.", 9, GRAY)
+        c.y -= row_h
+    # borde de la tabla
+    c.line(_ML, c.y, _MR, c.y, LINE)
+    c.y -= 12
+
+    # ---------------- Totales (caja derecha) ----------------
+    tb_x, tb_w = 360, _MR - 360
+    c.ensure(58)
+    c.rect(tb_x, c.y - 58, tb_w, 58, ZEBRA)
+    c.line(tb_x, c.y, tb_x, c.y - 58, LINE)
+    ty = c.y - 16
+    c.text(tb_x + 10, ty, "Subtotal", 9.5, GRAY, bold=True)
+    c.text(_MR - 8, ty, f"{currency} {_money(subtotal)}", 9.5, INK, right=True)
+    ty -= 15
+    c.text(tb_x + 10, ty, "IVA", 9.5, GRAY, bold=True)
+    c.text(_MR - 8, ty, "según aplique", 9, GRAY, right=True)
+    ty -= 6
+    c.rect(tb_x, ty - 20, tb_w, 20, ACC)
+    c.text(tb_x + 10, ty - 14, "TOTAL", 10, (1, 1, 1), bold=True)
+    c.text(_MR - 8, ty - 14, f"{currency} {_money(subtotal)} + IVA", 10, (1, 1, 1), bold=True, right=True)
+    c.y -= 70
+
+    # ---------------- Condiciones ----------------
+    if terms:
+        section("Condiciones comerciales")
+        for para in terms.splitlines():
+            for ln in (_wrap(para, 108) or [""]):
+                c.ensure(13)
+                c.text(_ML + 6, c.y - 10, ln, 8.8, GRAY)
+                c.y -= 12
+        c.y -= 4
+
+    # pie en todas las páginas
+    for ops in c.pages:
+        if footer:
+            r, g, b = GRAY
+            ops.append(f"BT /F1 8 Tf {r:.3f} {g:.3f} {b:.3f} rg 1 0 0 1 {_ML} 34 Tm ({_esc(_fit(footer, 8, _MR - _ML))}) Tj ET")
+        ops.append(f"{ACC[0]:.3f} {ACC[1]:.3f} {ACC[2]:.3f} rg 0 0 {_W} 6 re f")
+
+    # ---------------- Ensamblado ----------------
+    streams = ["\n".join(ops).encode("latin-1", "replace") for ops in c.pages]
+    objects: list[bytes] = []
+
+    def add(obj: bytes):
+        objects.append(obj)
+
+    n_pages = len(c.pages)
+    has_img = 1 if logo else 0
+    # numeración: 1 catalog, 2 pages, 3 F1, 4 F2, [5 img], luego páginas y streams
+    img_num = 5 if has_img else None
+    base = 6 if has_img else 5
+    page_nums = list(range(base, base + n_pages))
+    content_nums = list(range(base + n_pages, base + 2 * n_pages))
+
+    kids = " ".join(f"{n} 0 R" for n in page_nums)
+    add(b"<< /Type /Catalog /Pages 2 0 R >>")
+    add(f"<< /Type /Pages /Kids [{kids}] /Count {n_pages} >>".encode("latin-1"))
+    add(b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>")
+    add(b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >>")
+    if logo:
+        jpeg, lw, lh = logo
+        add(
+            (
+                f"<< /Type /XObject /Subtype /Image /Width {lw} /Height {lh} "
+                f"/ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length {len(jpeg)} >>\n"
+            ).encode("latin-1") + b"stream\n" + jpeg + b"\nendstream"
+        )
+    for i in range(n_pages):
+        res = "/Font << /F1 3 0 R /F2 4 0 R >>"
+        if has_img and i == 0:
+            res += f" /XObject << /Im0 {img_num} 0 R >>"
+        add(
+            (
+                f"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 {_W} {_H}] "
+                f"/Resources << {res} >> /Contents {content_nums[i]} 0 R >>"
+            ).encode("latin-1")
+        )
+    for stream in streams:
+        add(b"<< /Length " + str(len(stream)).encode() + b" >>\nstream\n" + stream + b"\nendstream")
+
+    out = bytearray(b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n")
+    offsets = []
+    for i, obj in enumerate(objects, start=1):
+        offsets.append(len(out))
+        out += f"{i} 0 obj\n".encode("latin-1") + obj + b"\nendobj\n"
+    xref_pos = len(out)
+    total = len(objects) + 1
+    out += f"xref\n0 {total}\n".encode("latin-1") + b"0000000000 65535 f \n"
+    for off in offsets:
+        out += f"{off:010d} 00000 n \n".encode("latin-1")
+    out += f"trailer\n<< /Size {total} /Root 1 0 R >>\nstartxref\n{xref_pos}\n%%EOF".encode("latin-1")
+    return bytes(out)

backend/api/v1/modules/crm/quotes/pdf_service.py

@@ -0,0 +1,250 @@
+"""PDF de cotización, configuración de marca por tenant y envío por correo."""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+
+from fastapi import HTTPException, status
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+
+from ..accounts.models import Account
+from ..service_requests.models import ServiceRequest
+from .models import Quote, QuoteItem, QuoteSettings
+from .pdf import build_quote_pdf
+from .service import get_quote
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_TERMS = (
+    "Tarifas sujetas a disponibilidad de espacio.\n"
+    "Cualquier variación en peso o volumen generará ajuste tarifario.\n"
+    "No incluye cargos extraordinarios, maniobras especiales o servicios no especificados.\n"
+    "Tarifas sujetas a revisión por parte de la línea transportista y autoridades correspondientes."
+)
+
+
+# ---------------- Configuración de marca ----------------
+def get_settings(db: Session, tenant_id: int, company_id: int) -> QuoteSettings | None:
+    return (
+        db.query(QuoteSettings)
+        .filter(QuoteSettings.tenant_id == tenant_id, QuoteSettings.company_id == company_id,
+                QuoteSettings.deleted_at.is_(None))
+        .first()
+    )
+
+
+def upsert_settings(db: Session, tenant_id: int, company_id: int, data: dict) -> QuoteSettings:
+    obj = get_settings(db, tenant_id, company_id)
+    if obj is None:
+        obj = QuoteSettings(tenant_id=tenant_id, company_id=company_id)
+        db.add(obj)
+    for field, value in data.items():
+        if value is not None:
+            setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def set_logo_key(db: Session, tenant_id: int, company_id: int, file_key: str) -> QuoteSettings:
+    obj = get_settings(db, tenant_id, company_id)
+    if obj is None:
+        obj = QuoteSettings(tenant_id=tenant_id, company_id=company_id)
+        db.add(obj)
+    obj.logo_file_key = file_key
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def _compose_place(city: str | None, country: str | None, port: str | None) -> str | None:
+    """Arma 'Ciudad, PAÍS (Puerto)' con las partes que existan (ruta estructurada)."""
+    head = ", ".join(p for p in (city, country) if p)
+    if port:
+        head = f"{head} ({port})" if head else port
+    return head or None
+
+
+def _company_row(db: Session, company_id: int) -> dict:
+    try:
+        row = db.execute(
+            text("SELECT name, rfc, logo FROM a76.company WHERE id = :c"), {"c": company_id}
+        ).first()
+        if row:
+            return {"name": row[0], "rfc": row[1], "logo": row[2]}
+    except Exception:
+        pass
+    return {}
+
+
+# ---------------- Construcción del PDF ----------------
+def build_pdf_bytes(db: Session, quote: Quote, tenant_id: int, company_id: int) -> bytes:
+    items = (
+        db.query(QuoteItem)
+        .filter(QuoteItem.quote_id == quote.id, QuoteItem.deleted_at.is_(None))
+        .order_by(QuoteItem.id.asc())
+        .all()
+    )
+    account = (
+        db.query(Account).filter(Account.id == quote.account_id).first() if quote.account_id else None
+    )
+    sr = (
+        db.query(ServiceRequest).filter(ServiceRequest.id == quote.service_request_id).first()
+        if quote.service_request_id else None
+    )
+    settings = get_settings(db, tenant_id, company_id)
+    company = _company_row(db, company_id)
+
+    # Emisor: config del tenant con respaldo en a76.company
+    emitter = {
+        "name": (settings.emitter_name if settings else None) or company.get("name") or "Emisor",
+        "rfc": (settings.emitter_rfc if settings else None) or company.get("rfc"),
+        "address": settings.emitter_address if settings else None,
+        "phone": settings.emitter_phone if settings else None,
+        "email": settings.emitter_email if settings else None,
+        "website": settings.emitter_website if settings else None,
+    }
+    accent = (settings.accent_color if settings else None) or "#12294c"
+    prefix = (settings.quote_prefix if settings else None) or "COT"
+    terms = quote.terms or (settings.default_terms if settings else None) or DEFAULT_TERMS
+    footer = settings.footer_note if settings else None
+
+    # Logo (MinIO)
+    logo_bytes = None
+    logo_key = settings.logo_file_key if settings else None
+    if logo_key:
+        try:
+            from core.storage_s3 import get_object_bytes
+            logo_bytes = get_object_bytes(logo_key)
+        except Exception as exc:
+            logger.warning("No se pudo leer el logo del tarifario: %s", exc)
+
+    reference = quote.reference or f"{prefix}-{datetime.now().strftime('%Y%m%d')}-{quote.id:03d}"
+    head = {
+        "reference": reference,
+        "issue_date": quote.issue_date.isoformat() if quote.issue_date else None,
+        "valid_until": quote.valid_until.isoformat() if quote.valid_until else None,
+        "owner": quote.owner_user_id or "-",
+        "status": quote.status,
+    }
+    client = {
+        "name": account.name if account else None,
+        "rfc": account.rfc if account else None,
+        "email": account.email if account else None,
+        "phone": account.phone if account else None,
+    }
+    cargo = []
+    route = []
+    if sr:
+        cargo = [
+            ("Tipo de mercancía", sr.cargo_type), ("Descripción", sr.commodity),
+            ("Peso", str(sr.weight) if sr.weight is not None else None),
+            ("Volumen", str(sr.volume) if sr.volume is not None else None),
+            ("Tipo de carga", sr.load_type), ("Equipo", sr.container_equipment),
+        ]
+        route = [
+            ("Operación", sr.operation_type), ("Modo", sr.transport_mode),
+            ("Servicio", sr.service_type), ("Incoterm", sr.incoterm),
+            ("Origen", sr.origin or _compose_place(sr.origin_city, sr.origin_country, sr.origin_port)),
+            ("Destino", sr.destination or _compose_place(sr.destination_city, sr.destination_country, sr.destination_port)),
+            ("Fecha requerida", sr.required_date.isoformat() if sr.required_date else None),
+        ]
+
+    return build_quote_pdf(
+        emitter=emitter, head=head, client=client, cargo=cargo, route=route,
+        items=[{"concept": i.concept, "description": i.description, "quantity": i.quantity, "unit_sale": i.unit_sale} for i in items],
+        currency=quote.currency, subtotal=quote.total_sale, terms=terms, footer=footer,
+        logo_bytes=logo_bytes, accent=accent,
+    )
+
+
+def _store_pdf(db: Session, quote: Quote, tenant_id: int, company_id: int, pdf_bytes: bytes) -> str:
+    from core.storage_s3 import put_object_bytes
+    ref = (quote.reference or f"cot-{quote.id}").replace("/", "-")
+    key = f"tenants/{tenant_id}/companies/{company_id}/crm-quotes/{quote.id}/cotizacion-{ref}.pdf"
+    put_object_bytes(key, pdf_bytes, content_type="application/pdf")
+    quote.pdf_file_key = key
+    db.commit()
+    return key
+
+
+def get_pdf_url(db: Session, quote_id: int, tenant_id: int, company_id: int) -> str:
+    from core.storage_s3 import presigned_get_url
+    quote = get_quote(db, quote_id, tenant_id, company_id)
+    pdf_bytes = build_pdf_bytes(db, quote, tenant_id, company_id)
+    key = _store_pdf(db, quote, tenant_id, company_id, pdf_bytes)
+    return presigned_get_url(key)
+
+
+# ---------------- Envío por correo ----------------
+async def send_quote_email(
+    db: Session, quote_id: int, tenant_id: int, company_id: int,
+    to: str | None, subject: str | None, message: str | None,
+) -> dict:
+    import ssl
+    from email import encoders
+    from email.mime.base import MIMEBase
+    from email.mime.multipart import MIMEMultipart
+    from email.mime.text import MIMEText
+
+    import aiosmtplib
+
+    from core.config import settings as cfg
+
+    quote = get_quote(db, quote_id, tenant_id, company_id)
+    account = db.query(Account).filter(Account.id == quote.account_id).first() if quote.account_id else None
+    recipient = to or (account.email if account else None)
+    if not recipient:
+        raise HTTPException(status_code=400, detail="No hay correo destino (captura uno o pon el correo del cliente).")
+
+    pdf_bytes = build_pdf_bytes(db, quote, tenant_id, company_id)
+    _store_pdf(db, quote, tenant_id, company_id, pdf_bytes)
+    ref = quote.reference or f"COT-{quote.id}"
+
+    msg = MIMEMultipart()
+    msg["From"] = f"{cfg.SMTP_FROM_NAME} <{cfg.SMTP_USER}>"
+    msg["To"] = recipient
+    msg["Subject"] = subject or f"Cotización {ref}"
+    html = (
+        "<div style='font-family:Arial,sans-serif;color:#333;max-width:600px'>"
+        f"<p>{(message or 'Adjunto la cotización solicitada. Quedamos atentos.').replace(chr(10), '<br>')}</p>"
+        f"<p style='color:#6b7280;font-size:12px'>Cotización {ref}</p></div>"
+    )
+    msg.attach(MIMEText(html, "html"))
+    part = MIMEBase("application", "pdf")
+    part.set_payload(pdf_bytes)
+    encoders.encode_base64(part)
+    part.add_header("Content-Disposition", f'attachment; filename="cotizacion-{ref}.pdf"')
+    msg.attach(part)
+
+    if not (cfg.SMTP_USER and cfg.SMTP_PASSWORD):
+        raise HTTPException(status_code=503, detail="El correo saliente (SMTP) no está configurado en el servidor.")
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    try:
+        # Puerto 465 = SSL implícito; los demás (587/2525/…) = STARTTLS.
+        await aiosmtplib.send(
+            msg,
+            hostname=cfg.SMTP_HOST,
+            port=cfg.SMTP_PORT,
+            username=cfg.SMTP_USER,
+            password=cfg.SMTP_PASSWORD,
+            use_tls=(cfg.SMTP_PORT == 465),
+            start_tls=(cfg.SMTP_PORT != 465),
+            tls_context=ctx,
+            validate_certs=False,
+            timeout=30,
+        )
+    except Exception as exc:
+        logger.error("Error enviando cotización %s: %s", quote_id, exc)
+        raise HTTPException(status_code=502, detail=f"No se pudo enviar el correo: {exc}")
+
+    # Marca como enviada
+    if quote.status == "borrador":
+        quote.status = "enviada"
+    quote.sent_at = datetime.now(timezone.utc)
+    db.commit()
+    return {"sent_to": recipient, "reference": ref}

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

@@ -1,22 +1,76 @@
-from fastapi import APIRouter, Depends, Query, status
+from fastapi import APIRouter, Depends, File, Query, Response, UploadFile, status
 from sqlalchemy.orm import Session
 
 from core.database import get_core_db
 from core.security import get_current_user
 
-from . import service
+from . import pdf_service, service
 from .dto import (
     QuoteCreate,
     QuoteItemCreate,
     QuoteItemResponse,
     QuoteItemUpdate,
     QuoteResponse,
+    QuoteSettingsInput,
+    QuoteSettingsResponse,
     QuoteUpdate,
+    SendQuoteEmailRequest,
 )
 
 router = APIRouter()
 
 
+# ----- Configuración de marca del formato de cotización -----
+
+@router.get("/quote-settings", response_model=QuoteSettingsResponse)
+def get_quote_settings(
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    obj = pdf_service.get_settings(db, current_user["tenant_id"], company_id)
+    return obj or QuoteSettingsResponse()
+
+
+@router.put("/quote-settings", response_model=QuoteSettingsResponse)
+def save_quote_settings(
+    payload: QuoteSettingsInput,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    return pdf_service.upsert_settings(db, current_user["tenant_id"], company_id, payload.model_dump(exclude_unset=True))
+
+
+@router.post("/quote-settings/logo", response_model=QuoteSettingsResponse)
+async def upload_quote_logo(
+    company_id: int = Query(...),
+    file: UploadFile = File(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    from core.storage_s3 import put_object_bytes
+    tenant_id = current_user["tenant_id"]
+    content = await file.read()
+    safe = (file.filename or "logo").replace("/", "-")
+    key = f"tenants/{tenant_id}/companies/{company_id}/crm-quote-logo/{safe}"
+    put_object_bytes(key, content, content_type=file.content_type or "image/png")
+    return pdf_service.set_logo_key(db, tenant_id, company_id, key)
+
+
+@router.get("/quote-settings/logo-url")
+def get_logo_url(
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    from core.storage_s3 import presigned_get_url
+    obj = pdf_service.get_settings(db, current_user["tenant_id"], company_id)
+    if not obj or not obj.logo_file_key:
+        return {"url": None}
+    return {"url": presigned_get_url(obj.logo_file_key)}
+
+
 def _user_id(current_user: dict) -> str | None:
     return current_user.get("sub") or current_user.get("id")
 
@@ -56,6 +110,24 @@ def create_quote(
     return service.create_quote(db, payload, tenant_id, company_id, _user_id(current_user))
 
 
+@router.post(
+    "/quotes/from-service-request",
+    response_model=list[QuoteResponse],
+    status_code=status.HTTP_201_CREATED,
+)
+def create_quotes_from_service_request(
+    service_request_id: int = Query(..., description="Solicitud de servicio a cotizar"),
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Genera la(s) cotización(es) desde una solicitud. Si es 'Ambas' devuelve 2 (FCL/LCL)."""
+    tenant_id = current_user["tenant_id"]
+    return service.create_quotes_from_service_request(
+        db, service_request_id, tenant_id, company_id, _user_id(current_user)
+    )
+
+
 @router.patch("/quotes/{quote_id}", response_model=QuoteResponse)
 def update_quote(
     quote_id: int,
@@ -98,6 +170,39 @@ def reject_quote(
     return service.reject_quote(db, quote_id, current_user["tenant_id"], company_id)
 
 
+@router.get("/quotes/{quote_id}/pdf")
+def quote_pdf(
+    quote_id: int,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Devuelve el PDF de la cotización directamente (vía backend, sin exponer MinIO)."""
+    tenant_id = current_user["tenant_id"]
+    quote = service.get_quote(db, quote_id, tenant_id, company_id)
+    pdf_bytes = pdf_service.build_pdf_bytes(db, quote, tenant_id, company_id)
+    ref = (quote.reference or f"cot-{quote.id}").replace("/", "-")
+    return Response(
+        content=pdf_bytes,
+        media_type="application/pdf",
+        headers={"Content-Disposition": f'inline; filename="cotizacion-{ref}.pdf"'},
+    )
+
+
+@router.post("/quotes/{quote_id}/send-email")
+async def quote_send_email(
+    quote_id: int,
+    payload: SendQuoteEmailRequest,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Genera el PDF y lo envía por correo (al cliente o al destinatario indicado)."""
+    return await pdf_service.send_quote_email(
+        db, quote_id, current_user["tenant_id"], company_id, payload.to, payload.subject, payload.message
+    )
+
+
 @router.post("/quotes/{quote_id}/clone", response_model=QuoteResponse, status_code=status.HTTP_201_CREATED)
 def clone_quote(
     quote_id: int,

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

@@ -1,4 +1,4 @@
-from datetime import datetime, timezone
+from datetime import date, datetime, timezone
 from decimal import Decimal
 
 from fastapi import HTTPException, status
@@ -6,7 +6,11 @@ from sqlalchemy import func
 from sqlalchemy.orm import Session
 
 from ..accounts.models import Account
-from ..service_requests.models import ServiceRequest
+from ..cases import service as cases_service
+from ..catalogs.models import CatalogItem
+from ..common.folios import next_folio
+from ..common.pricing import air_chargeable_kg
+from ..service_requests.models import RateRequest, ServiceRequest
 from ..suppliers.models import Supplier
 from .dto import QuoteCreate, QuoteItemCreate, QuoteItemUpdate, QuoteUpdate
 from .models import Quote, QuoteItem
@@ -70,7 +74,18 @@ def get_quotes(
         query = query.filter(Quote.account_id == account_id)
     if search:
         query = query.filter(Quote.reference.ilike(f"%{search}%"))
-    return query.order_by(Quote.created_at.desc()).all()
+    quotes = query.order_by(Quote.created_at.desc()).all()
+    # Enriquecer con el folio de la solicitud referenciada (para verlo en la lista)
+    sr_ids = {q.service_request_id for q in quotes if q.service_request_id}
+    if sr_ids:
+        refs = dict(
+            db.query(ServiceRequest.id, ServiceRequest.reference)
+            .filter(ServiceRequest.id.in_(sr_ids))
+            .all()
+        )
+        for q in quotes:
+            q.service_request_reference = refs.get(q.service_request_id)
+    return quotes
 
 
 def get_quote(db: Session, quote_id: int, tenant_id: int, company_id: int) -> Quote:
@@ -89,18 +104,142 @@ def get_quote(db: Session, quote_id: int, tenant_id: int, company_id: int) -> Qu
     return obj
 
 
+def _sr_direction(db: Session, service_request_id: int | None) -> str | None:
+    """Dirección impo/expo heredada de la solicitud asociada (para el folio)."""
+    if not service_request_id:
+        return None
+    sr = db.query(ServiceRequest).filter(ServiceRequest.id == service_request_id).first()
+    return sr.operation_type if sr else None
+
+
 def create_quote(
     db: Session, payload: QuoteCreate, tenant_id: int, company_id: int, user_id: str | None = None
 ) -> Quote:
     data = payload.model_dump()
     _validate_refs(db, data, tenant_id, company_id)
     obj = Quote(**data, tenant_id=tenant_id, company_id=company_id, created_by=user_id, updated_by=user_id)
+    # Fecha de la cotización: por defecto hoy si no se capturó
+    if obj.issue_date is None:
+        obj.issue_date = date.today()
+    # Folio C... auto-generado (mensual), con la dirección heredada de la solicitud
+    if not obj.reference:
+        obj.reference = next_folio(db, tenant_id, company_id, "C", _sr_direction(db, obj.service_request_id))
+    # Expediente heredado de la solicitud
+    if obj.service_request_id and not obj.case_id:
+        sr = db.query(ServiceRequest).filter(ServiceRequest.id == obj.service_request_id).first()
+        if sr:
+            obj.case_id = sr.case_id
+    cases_service.advance_stage(db, obj.case_id, "cotizacion")
     db.add(obj)
     db.commit()
     db.refresh(obj)
     return obj
 
 
+def create_quotes_from_service_request(
+    db: Session, service_request_id: int, tenant_id: int, company_id: int, user_id: str | None = None
+) -> list[Quote]:
+    """Genera cotización(es) a partir de una solicitud de servicio.
+
+    Si la solicitud es "Ambas" (FCL y LCL), genera **dos** cotizaciones (una por
+    variante) para comparar. Cada cotización toma su propio folio C... y hereda la
+    dirección impo/expo de la solicitud. Los conceptos se siembran desde las
+    solicitudes de tarifa (RateRequest) capturadas en la solicitud.
+    """
+    sr = (
+        db.query(ServiceRequest)
+        .filter(
+            ServiceRequest.id == service_request_id,
+            ServiceRequest.tenant_id == tenant_id,
+            ServiceRequest.company_id == company_id,
+            ServiceRequest.deleted_at.is_(None),
+        )
+        .first()
+    )
+    if not sr:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Solicitud no encontrada")
+
+    variants = ["FCL", "LCL"] if (sr.load_type or "").upper() == "AMBAS" else [sr.load_type or None]
+    rate_requests = (
+        db.query(RateRequest)
+        .filter(
+            RateRequest.service_request_id == sr.id,
+            RateRequest.tenant_id == tenant_id,
+            RateRequest.company_id == company_id,
+            RateRequest.deleted_at.is_(None),
+        )
+        .all()
+    )
+    # Etiquetas legibles de los servicios adicionales (global + tenant) para los conceptos
+    service_labels = {
+        code: label
+        for code, label in db.query(CatalogItem.code, CatalogItem.label).filter(
+            CatalogItem.catalog == "servicio_adicional"
+        )
+    }
+    service_costs = sr.additional_service_costs or {}
+
+    created: list[Quote] = []
+    for variant in variants:
+        quote = Quote(
+            account_id=sr.account_id,
+            service_request_id=sr.id,
+            currency=sr.currency or "USD",
+            load_type=variant,
+            status="borrador",
+            issue_date=date.today(),
+            notes=sr.client_notes or sr.notes,
+            owner_user_id=sr.owner_user_id,
+            reference=next_folio(db, tenant_id, company_id, "C", sr.operation_type),
+            case_id=sr.case_id,
+            tenant_id=tenant_id,
+            company_id=company_id,
+            created_by=user_id,
+            updated_by=user_id,
+        )
+        db.add(quote)
+        db.flush()
+        for rr in rate_requests:
+            amount = rr.rate_amount if rr.rate_amount is not None else Decimal(0)
+            db.add(QuoteItem(
+                quote_id=quote.id, concept=rr.concept, description=rr.description,
+                supplier_id=rr.supplier_id, quantity=Decimal(1),
+                unit_cost=amount, unit_sale=amount, currency=rr.currency,
+                tenant_id=tenant_id, company_id=company_id,
+            ))
+        # Servicios adicionales marcados en la solicitud → conceptos con su costo estimado
+        for code in (sr.additional_services or []):
+            amount = Decimal(str(service_costs.get(code) or 0))
+            db.add(QuoteItem(
+                quote_id=quote.id, concept=code[:60],
+                description=service_labels.get(code, "Servicio adicional"),
+                quantity=Decimal(1), unit_cost=amount, unit_sale=amount,
+                currency=sr.currency, tenant_id=tenant_id, company_id=company_id,
+            ))
+        # Carga aérea: concepto de flete con el peso a cobrar (P/Vol) como cantidad,
+        # para que el ejecutivo capture la tarifa por kg.
+        if (variant or "").upper() == "AEREO":
+            chargeable = air_chargeable_kg(
+                sr.weight, sr.length_cm, sr.width_cm, sr.height_cm,
+                sr.pallets_count or sr.pieces_count or 1,
+            )
+            db.add(QuoteItem(
+                quote_id=quote.id, concept="flete_internacional",
+                description=f"Flete aéreo — peso a cobrar {chargeable.quantize(Decimal('0.01'))} kg (P/Vol)",
+                quantity=chargeable, unit_cost=Decimal(0), unit_sale=Decimal(0),
+                currency=sr.currency, tenant_id=tenant_id, company_id=company_id,
+            ))
+        db.flush()
+        _recompute_totals(db, quote)
+        created.append(quote)
+
+    cases_service.advance_stage(db, sr.case_id, "cotizacion")
+    db.commit()
+    for quote in created:
+        db.refresh(quote)
+    return created
+
+
 def update_quote(
     db: Session, quote_id: int, payload: QuoteUpdate, tenant_id: int, company_id: int, user_id: str | None = None
 ) -> Quote:

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

@@ -0,0 +1,178 @@
+"""Schemas del módulo Tarifario."""
+
+from datetime import date, datetime
+from decimal import Decimal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+# ---------- Quiebres y cargos ----------
+class RateBreakDTO(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    from_qty: Decimal = Field(0)
+    rate: Decimal = Field(0)
+
+
+class RateChargeDTO(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    concept: str = Field(..., max_length=60)
+    charge_type: str = Field("fijo", max_length=20)
+    value: Decimal | None = None
+    condition: str | None = None
+
+
+class RateChargeCreate(BaseModel):
+    concept: str = Field(..., max_length=60)
+    charge_type: str = Field("fijo", max_length=20)
+    value: Decimal | None = None
+    condition: str | None = None
+    rate_lane_id: int | None = None
+
+
+class RateChargeUpdate(BaseModel):
+    concept: str | None = Field(None, max_length=60)
+    charge_type: str | None = Field(None, max_length=20)
+    value: Decimal | None = None
+    condition: str | None = None
+
+
+class RateChargeResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    id: int
+    rate_sheet_id: int | None
+    rate_lane_id: int | None
+    concept: str
+    charge_type: str
+    value: Decimal | None
+    condition: str | None
+
+
+# ---------- Rutas ----------
+class RateLaneBase(BaseModel):
+    origin: str | None = Field(None, max_length=20)
+    destination: str | None = Field(None, max_length=20)
+    region: str | None = Field(None, max_length=60)
+    equipment_type: str | None = Field(None, max_length=20)
+    rate_unit: str | None = Field(None, max_length=20)
+    min_charge: Decimal | None = None
+    flat_rate: Decimal | None = None
+    transit_days: int | None = None
+    notes: str | None = None
+
+
+class RateLaneCreate(RateLaneBase):
+    breaks: list[RateBreakDTO] = Field(default_factory=list)
+
+
+class RateLaneUpdate(RateLaneBase):
+    breaks: list[RateBreakDTO] | None = None
+
+
+class RateLaneResponse(RateLaneBase):
+    model_config = ConfigDict(from_attributes=True)
+    id: int
+    rate_sheet_id: int
+    breaks: list[RateBreakDTO] = Field(default_factory=list)
+
+
+# ---------- Tarifario (cabecera) ----------
+class RateSheetBase(BaseModel):
+    supplier_id: int | None = None
+    mode: str = Field(..., max_length=20)
+    name: str = Field(..., min_length=1, max_length=255)
+    currency: str | None = Field("USD", max_length=3)
+    valid_from: date | None = None
+    valid_to: date | None = None
+    default_origin: str | None = Field(None, max_length=20)
+    status: str = Field("borrador", max_length=20)
+    notes: str | None = None
+
+
+class RateSheetCreate(RateSheetBase):
+    pass
+
+
+class RateSheetUpdate(BaseModel):
+    supplier_id: int | None = None
+    mode: str | None = Field(None, max_length=20)
+    name: str | None = Field(None, max_length=255)
+    currency: str | None = Field(None, max_length=3)
+    valid_from: date | None = None
+    valid_to: date | None = None
+    default_origin: str | None = Field(None, max_length=20)
+    status: str | None = Field(None, max_length=20)
+    notes: str | None = None
+
+
+class RateSheetResponse(RateSheetBase):
+    model_config = ConfigDict(from_attributes=True)
+    id: int
+    tenant_id: int
+    company_id: int
+    source_file: str | None = None
+    created_by: str | None = None
+    updated_by: str | None = None
+    created_at: datetime
+    updated_at: datetime
+    lane_count: int | None = None
+
+
+# ---------- Importación ----------
+class ImportPreviewRow(BaseModel):
+    row: int
+    data: dict
+    ok: bool
+    warnings: list[str] = Field(default_factory=list)
+    errors: list[str] = Field(default_factory=list)
+
+
+class ImportPreview(BaseModel):
+    mode: str
+    total: int
+    valid: int
+    rows: list[ImportPreviewRow]
+    columns: list[str]
+
+
+class ImportConfirm(RateSheetCreate):
+    lanes: list[RateLaneCreate]
+
+
+# ---------- Costeo ----------
+class CostRequest(BaseModel):
+    mode: str
+    origin: str | None = None
+    destination: str | None = None
+    on_date: date | None = None
+    gross_weight_kg: Decimal | None = None
+    volume_m3: Decimal | None = None
+    # Dimensiones (cm) para el peso volumétrico aéreo (P/Vol = L×A×H×cant / 6000)
+    length_cm: Decimal | None = None
+    width_cm: Decimal | None = None
+    height_cm: Decimal | None = None
+    equipment_type: str | None = None
+    quantity: int = 1
+    dangerous: bool = False
+
+
+class CostChargeLine(BaseModel):
+    concept: str
+    amount: Decimal
+
+
+class CostOption(BaseModel):
+    rate_sheet_id: int
+    rate_sheet_name: str
+    supplier_id: int | None
+    currency: str | None
+    chargeable: Decimal | None = None  # peso/wm facturable usado
+    base_cost: Decimal
+    charges: list[CostChargeLine] = Field(default_factory=list)
+    total_cost: Decimal
+    transit_days: int | None = None
+    detail: str | None = None
+
+
+class CostResult(BaseModel):
+    request: CostRequest
+    options: list[CostOption]

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

@@ -0,0 +1,93 @@
+"""Modelos del módulo Tarifario (base de costos para Cotizaciones).
+
+Un ``RateSheet`` (tarifario) pertenece a un proveedor y agrupa muchas
+``RateLane`` (rutas origen→destino). Cada ruta tiene, según el modo:
+- Aéreo / LCL: varios ``RateBreak`` (quiebres de peso/volumen con su tarifa).
+- FCL / terrestre: una tarifa plana por contenedor/unidad (``flat_rate``).
+Los ``RateCharge`` son cargos adicionales a nivel tarifario o ruta.
+"""
+
+from datetime import date
+from decimal import Decimal
+
+from sqlalchemy import Date, ForeignKey, Integer, Numeric, String, Text, text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
+from core.database import Base
+
+
+class RateSheet(Base, TenantScopedMixin, TimestampMixin):
+    __tablename__ = "rate_sheets"
+    __table_args__ = {"schema": "crm"}
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    supplier_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("crm.suppliers.id"), nullable=True, index=True
+    )
+    # aereo | maritimo_fcl | maritimo_lcl | terrestre
+    mode: Mapped[str] = mapped_column(String(20), nullable=False, index=True)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    currency: Mapped[str | None] = mapped_column(String(3), nullable=True, server_default=text("'USD'"))
+    valid_from: Mapped[date | None] = mapped_column(Date, nullable=True)
+    valid_to: Mapped[date | None] = mapped_column(Date, nullable=True)
+    default_origin: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    # borrador | activo | vencido | reemplazado
+    status: Mapped[str] = mapped_column(String(20), nullable=False, server_default=text("'borrador'"))
+    source_file: Mapped[str | None] = mapped_column(String(512), nullable=True)
+    source_url: Mapped[str | None] = mapped_column(String(1024), nullable=True)
+    notes: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    updated_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
+
+
+class RateLane(Base, TenantScopedMixin, TimestampMixin):
+    __tablename__ = "rate_lanes"
+    __table_args__ = {"schema": "crm"}
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    rate_sheet_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("crm.rate_sheets.id"), nullable=False, index=True
+    )
+    origin: Mapped[str | None] = mapped_column(String(20), nullable=True, index=True)
+    destination: Mapped[str | None] = mapped_column(String(20), nullable=True, index=True)
+    region: Mapped[str | None] = mapped_column(String(60), nullable=True)
+    # Solo FCL/terrestre (código del catálogo tipo_equipo). Nulo en aéreo/LCL.
+    equipment_type: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    # per_kg | per_wm | per_container | flat
+    rate_unit: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    min_charge: Mapped[Decimal | None] = mapped_column(Numeric(14, 4), nullable=True)
+    flat_rate: Mapped[Decimal | None] = mapped_column(Numeric(14, 4), nullable=True)
+    transit_days: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    notes: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+
+class RateBreak(Base, TenantScopedMixin, TimestampMixin):
+    __tablename__ = "rate_breaks"
+    __table_args__ = {"schema": "crm"}
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    rate_lane_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("crm.rate_lanes.id"), nullable=False, index=True
+    )
+    # Umbral del quiebre (kg en aéreo; W/M en LCL)
+    from_qty: Mapped[Decimal] = mapped_column(Numeric(12, 3), nullable=False, server_default=text("0"))
+    rate: Mapped[Decimal] = mapped_column(Numeric(14, 4), nullable=False, server_default=text("0"))
+
+
+class RateCharge(Base, TenantScopedMixin, TimestampMixin):
+    __tablename__ = "rate_charges"
+    __table_args__ = {"schema": "crm"}
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    rate_sheet_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("crm.rate_sheets.id"), nullable=True, index=True
+    )
+    rate_lane_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("crm.rate_lanes.id"), nullable=True, index=True
+    )
+    concept: Mapped[str] = mapped_column(String(60), nullable=False)
+    # fijo | por_kg | por_guia | por_contenedor | porcentaje
+    charge_type: Mapped[str] = mapped_column(String(20), nullable=False, server_default=text("'fijo'"))
+    value: Mapped[Decimal | None] = mapped_column(Numeric(14, 4), nullable=True)
+    condition: Mapped[str | None] = mapped_column(Text, nullable=True)

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

@@ -0,0 +1,269 @@
+"""Endpoints del módulo Tarifario."""
+
+from datetime import date
+
+from fastapi import APIRouter, Depends, File, Form, Query, Response, UploadFile, status
+from sqlalchemy.orm import Session
+
+from core.database import get_core_db
+from core.security import get_current_user
+
+from . import service
+from .dto import (
+    CostRequest,
+    CostResult,
+    ImportPreview,
+    RateBreakDTO,
+    RateChargeCreate,
+    RateChargeResponse,
+    RateChargeUpdate,
+    RateLaneCreate,
+    RateLaneResponse,
+    RateSheetCreate,
+    RateSheetResponse,
+    RateSheetUpdate,
+)
+
+router = APIRouter(prefix="/rate-sheets", tags=["Tarifario"])
+
+
+def _ctx(current_user: dict):
+    return current_user["tenant_id"], current_user.get("sub") or current_user.get("id")
+
+
+def _sheet_out(db: Session, tenant_id: int, sheet) -> RateSheetResponse:
+    out = RateSheetResponse.model_validate(sheet)
+    out.lane_count = service.lane_count(db, tenant_id, sheet.id)
+    return out
+
+
+def _lane_out(db: Session, lane) -> RateLaneResponse:
+    out = RateLaneResponse.model_validate(lane)
+    out.breaks = [RateBreakDTO.model_validate(b) for b in service.breaks_of(db, lane.id)]
+    return out
+
+
+# ---------------- Tarifarios ----------------
+@router.get("", response_model=list[RateSheetResponse])
+def list_sheets(
+    company_id: int = Query(...),
+    mode: str | None = Query(None),
+    supplier_id: int | None = Query(None),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, _ = _ctx(current_user)
+    sheets = service.list_sheets(db, tenant_id, company_id, mode=mode, supplier_id=supplier_id)
+    return [_sheet_out(db, tenant_id, s) for s in sheets]
+
+
+@router.post("", response_model=RateSheetResponse, status_code=status.HTTP_201_CREATED)
+def create_sheet(
+    data: RateSheetCreate,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, user_id = _ctx(current_user)
+    sheet = service.create_sheet(db, tenant_id, company_id, data, user_id)
+    return _sheet_out(db, tenant_id, sheet)
+
+
+@router.get("/template")
+def download_template(
+    mode: str = Query(..., description="aereo | maritimo_fcl | maritimo_lcl | terrestre"),
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+):
+    content = service.build_template(mode)
+    return Response(
+        content=content,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        headers={"Content-Disposition": f'attachment; filename="plantilla_tarifario_{mode}.xlsx"'},
+    )
+
+
+@router.post("/import/preview", response_model=ImportPreview)
+async def import_preview(
+    company_id: int = Query(...),
+    mode: str = Form(...),
+    file: UploadFile = File(...),
+    current_user: dict = Depends(get_current_user),
+):
+    content = await file.read()
+    return service.parse_excel(mode, content)
+
+
+@router.post("/import", response_model=RateSheetResponse, status_code=status.HTTP_201_CREATED)
+async def import_sheet(
+    company_id: int = Query(...),
+    mode: str = Form(...),
+    name: str = Form(...),
+    supplier_id: int | None = Form(None),
+    currency: str = Form("USD"),
+    valid_from: date | None = Form(None),
+    valid_to: date | None = Form(None),
+    default_origin: str | None = Form(None),
+    file: UploadFile = File(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, user_id = _ctx(current_user)
+    content = await file.read()
+    header = RateSheetCreate(
+        mode=mode, name=name, supplier_id=supplier_id, currency=currency,
+        valid_from=valid_from, valid_to=valid_to, default_origin=default_origin,
+    )
+    sheet = service.import_from_excel(db, tenant_id, company_id, mode, content, header, user_id)
+    return _sheet_out(db, tenant_id, sheet)
+
+
+@router.get("/{sheet_id}", response_model=RateSheetResponse)
+def get_sheet(
+    sheet_id: int,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, _ = _ctx(current_user)
+    return _sheet_out(db, tenant_id, service.get_sheet(db, tenant_id, company_id, sheet_id))
+
+
+@router.patch("/{sheet_id}", response_model=RateSheetResponse)
+def update_sheet(
+    sheet_id: int,
+    data: RateSheetUpdate,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, user_id = _ctx(current_user)
+    return _sheet_out(db, tenant_id, service.update_sheet(db, tenant_id, company_id, sheet_id, data, user_id))
+
+
+@router.delete("/{sheet_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_sheet(
+    sheet_id: int,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, _ = _ctx(current_user)
+    service.delete_sheet(db, tenant_id, company_id, sheet_id)
+
+
+# ---------------- Rutas (lanes) ----------------
+@router.get("/{sheet_id}/lanes", response_model=list[RateLaneResponse])
+def list_lanes(
+    sheet_id: int,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, _ = _ctx(current_user)
+    service.get_sheet(db, tenant_id, company_id, sheet_id)
+    return [_lane_out(db, lane) for lane in service.list_lanes(db, tenant_id, sheet_id)]
+
+
+@router.post("/{sheet_id}/lanes", response_model=RateLaneResponse, status_code=status.HTTP_201_CREATED)
+def create_lane(
+    sheet_id: int,
+    data: RateLaneCreate,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, _ = _ctx(current_user)
+    lane = service.create_lane(db, tenant_id, company_id, sheet_id, data)
+    return _lane_out(db, lane)
+
+
+@router.delete("/{sheet_id}/lanes/{lane_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_lane(
+    sheet_id: int,
+    lane_id: int,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, _ = _ctx(current_user)
+    service.delete_lane(db, tenant_id, sheet_id, lane_id)
+
+
+# ---------------- Cargos adicionales ----------------
+@router.get("/{sheet_id}/charges", response_model=list[RateChargeResponse])
+def list_charges(
+    sheet_id: int,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, _ = _ctx(current_user)
+    service.get_sheet(db, tenant_id, company_id, sheet_id)
+    return service.list_charges(db, tenant_id, sheet_id)
+
+
+@router.post("/{sheet_id}/charges", response_model=RateChargeResponse, status_code=status.HTTP_201_CREATED)
+def create_charge(
+    sheet_id: int,
+    data: RateChargeCreate,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, _ = _ctx(current_user)
+    return service.create_charge(db, tenant_id, company_id, sheet_id, data)
+
+
+@router.patch("/{sheet_id}/charges/{charge_id}", response_model=RateChargeResponse)
+def update_charge(
+    sheet_id: int,
+    charge_id: int,
+    data: RateChargeUpdate,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, _ = _ctx(current_user)
+    return service.update_charge(db, tenant_id, sheet_id, charge_id, data)
+
+
+@router.delete("/{sheet_id}/charges/{charge_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_charge(
+    sheet_id: int,
+    charge_id: int,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    tenant_id, _ = _ctx(current_user)
+    service.delete_charge(db, tenant_id, sheet_id, charge_id)
+
+
+# ---------------- Motor de costeo ----------------
+cost_router = APIRouter(tags=["Tarifario"])
+
+
+@cost_router.post("/rate-quote", response_model=CostResult)
+def rate_quote(
+    req: CostRequest,
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Calcula opciones de costo (por proveedor) para una ruta/carga."""
+    tenant_id, _ = _ctx(current_user)
+    options = service.quote_cost(db, tenant_id, company_id, req)
+    return CostResult(request=req, options=options)
+
+
+@cost_router.get("/rate-locations")
+def rate_locations(
+    mode: str = Query(...),
+    company_id: int = Query(...),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Orígenes/destinos cotizables (de los tarifarios activos) para alinear el cotizador."""
+    tenant_id, _ = _ctx(current_user)
+    return service.lane_locations(db, tenant_id, company_id, mode)

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

@@ -0,0 +1,565 @@
+"""Lógica del módulo Tarifario: CRUD, importación por Excel y motor de costeo."""
+
+import io
+from datetime import date
+from decimal import Decimal
+from typing import Any
+
+from fastapi import HTTPException, status
+from sqlalchemy import and_, or_
+from sqlalchemy.orm import Session
+
+from .dto import (
+    CostChargeLine,
+    CostOption,
+    CostRequest,
+    ImportConfirm,
+    ImportPreview,
+    ImportPreviewRow,
+    RateLaneCreate,
+    RateSheetCreate,
+    RateSheetUpdate,
+)
+from ..common.pricing import air_volumetric_kg
+from .models import RateBreak, RateCharge, RateLane, RateSheet
+
+# Factor volumétrico aéreo: 1 m³ = 167 kg (equivale a 6000 cm³/kg).
+# Respaldo cuando solo se conoce el volumen en m³ (sin dimensiones cm).
+AIR_VOLUMETRIC_FACTOR = Decimal("167")
+
+
+# ============================================================ CRUD tarifarios
+def _sheet_query(db: Session, tenant_id: int, company_id: int):
+    return db.query(RateSheet).filter(
+        RateSheet.tenant_id == tenant_id,
+        RateSheet.company_id == company_id,
+        RateSheet.deleted_at.is_(None),
+    )
+
+
+def list_sheets(db: Session, tenant_id: int, company_id: int, mode: str | None = None,
+                supplier_id: int | None = None) -> list[RateSheet]:
+    q = _sheet_query(db, tenant_id, company_id)
+    if mode:
+        q = q.filter(RateSheet.mode == mode)
+    if supplier_id:
+        q = q.filter(RateSheet.supplier_id == supplier_id)
+    return q.order_by(RateSheet.created_at.desc()).all()
+
+
+def lane_count(db: Session, tenant_id: int, sheet_id: int) -> int:
+    return (
+        db.query(RateLane)
+        .filter(RateLane.rate_sheet_id == sheet_id, RateLane.tenant_id == tenant_id,
+                RateLane.deleted_at.is_(None))
+        .count()
+    )
+
+
+def get_sheet(db: Session, tenant_id: int, company_id: int, sheet_id: int) -> RateSheet:
+    sheet = _sheet_query(db, tenant_id, company_id).filter(RateSheet.id == sheet_id).first()
+    if not sheet:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Tarifario no encontrado")
+    return sheet
+
+
+def create_sheet(db: Session, tenant_id: int, company_id: int, data: RateSheetCreate,
+                 user_id: str | None) -> RateSheet:
+    sheet = RateSheet(
+        tenant_id=tenant_id, company_id=company_id,
+        **data.model_dump(),
+        created_by=user_id, updated_by=user_id,
+    )
+    db.add(sheet)
+    db.commit()
+    db.refresh(sheet)
+    return sheet
+
+
+def update_sheet(db: Session, tenant_id: int, company_id: int, sheet_id: int,
+                 data: RateSheetUpdate, user_id: str | None) -> RateSheet:
+    sheet = get_sheet(db, tenant_id, company_id, sheet_id)
+    for field, value in data.model_dump(exclude_unset=True).items():
+        setattr(sheet, field, value)
+    sheet.updated_by = user_id
+    db.commit()
+    db.refresh(sheet)
+    return sheet
+
+
+def delete_sheet(db: Session, tenant_id: int, company_id: int, sheet_id: int) -> None:
+    from sqlalchemy import func
+    sheet = get_sheet(db, tenant_id, company_id, sheet_id)
+    sheet.deleted_at = func.now()
+    db.commit()
+
+
+# ============================================================ Rutas (lanes)
+def list_lanes(db: Session, tenant_id: int, sheet_id: int) -> list[RateLane]:
+    return (
+        db.query(RateLane)
+        .filter(RateLane.rate_sheet_id == sheet_id, RateLane.tenant_id == tenant_id,
+                RateLane.deleted_at.is_(None))
+        .order_by(RateLane.region, RateLane.destination)
+        .all()
+    )
+
+
+def breaks_of(db: Session, lane_id: int) -> list[RateBreak]:
+    return (
+        db.query(RateBreak)
+        .filter(RateBreak.rate_lane_id == lane_id, RateBreak.deleted_at.is_(None))
+        .order_by(RateBreak.from_qty)
+        .all()
+    )
+
+
+def _add_lane(db: Session, tenant_id: int, company_id: int, sheet_id: int,
+              lane_data: RateLaneCreate) -> RateLane:
+    payload = lane_data.model_dump(exclude={"breaks"})
+    lane = RateLane(tenant_id=tenant_id, company_id=company_id, rate_sheet_id=sheet_id, **payload)
+    db.add(lane)
+    db.flush()  # id
+    for br in lane_data.breaks:
+        db.add(RateBreak(
+            tenant_id=tenant_id, company_id=company_id, rate_lane_id=lane.id,
+            from_qty=br.from_qty, rate=br.rate,
+        ))
+    return lane
+
+
+def create_lane(db: Session, tenant_id: int, company_id: int, sheet_id: int,
+                lane_data: RateLaneCreate) -> RateLane:
+    get_sheet(db, tenant_id, company_id, sheet_id)  # valida pertenencia
+    lane = _add_lane(db, tenant_id, company_id, sheet_id, lane_data)
+    db.commit()
+    db.refresh(lane)
+    return lane
+
+
+def delete_lane(db: Session, tenant_id: int, sheet_id: int, lane_id: int) -> None:
+    from sqlalchemy import func
+    lane = (
+        db.query(RateLane)
+        .filter(RateLane.id == lane_id, RateLane.rate_sheet_id == sheet_id,
+                RateLane.tenant_id == tenant_id)
+        .first()
+    )
+    if not lane:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Ruta no encontrada")
+    lane.deleted_at = func.now()
+    db.commit()
+
+
+# ============================================================ Cargos adicionales
+def list_charges(db: Session, tenant_id: int, sheet_id: int) -> list[RateCharge]:
+    return (
+        db.query(RateCharge)
+        .filter(RateCharge.rate_sheet_id == sheet_id, RateCharge.tenant_id == tenant_id,
+                RateCharge.deleted_at.is_(None))
+        .order_by(RateCharge.concept)
+        .all()
+    )
+
+
+def create_charge(db: Session, tenant_id: int, company_id: int, sheet_id: int, data) -> RateCharge:
+    get_sheet(db, tenant_id, company_id, sheet_id)
+    ch = RateCharge(
+        tenant_id=tenant_id, company_id=company_id, rate_sheet_id=sheet_id,
+        rate_lane_id=data.rate_lane_id, concept=data.concept, charge_type=data.charge_type,
+        value=data.value, condition=data.condition,
+    )
+    db.add(ch)
+    db.commit()
+    db.refresh(ch)
+    return ch
+
+
+def update_charge(db: Session, tenant_id: int, sheet_id: int, charge_id: int, data) -> RateCharge:
+    ch = (
+        db.query(RateCharge)
+        .filter(RateCharge.id == charge_id, RateCharge.rate_sheet_id == sheet_id,
+                RateCharge.tenant_id == tenant_id)
+        .first()
+    )
+    if not ch:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Cargo no encontrado")
+    for field, value in data.model_dump(exclude_unset=True).items():
+        setattr(ch, field, value)
+    db.commit()
+    db.refresh(ch)
+    return ch
+
+
+def delete_charge(db: Session, tenant_id: int, sheet_id: int, charge_id: int) -> None:
+    from sqlalchemy import func
+    ch = (
+        db.query(RateCharge)
+        .filter(RateCharge.id == charge_id, RateCharge.rate_sheet_id == sheet_id,
+                RateCharge.tenant_id == tenant_id)
+        .first()
+    )
+    if not ch:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Cargo no encontrado")
+    ch.deleted_at = func.now()
+    db.commit()
+
+
+# ============================================================ Importación Excel
+# Plantillas por modo: encabezados esperados (orden libre, se detectan por nombre).
+TEMPLATES: dict[str, list[str]] = {
+    "aereo": ["Region", "Origen", "Destino", "IATA", "Min", "100", "300", "500", "1000"],
+    "maritimo_fcl": ["Origen", "Destino", "Tipo contenedor", "Tarifa", "Transito", "Notas"],
+    "maritimo_lcl": ["Origen", "Destino", "Tarifa W/M", "Minimo", "Notas"],
+    "terrestre": ["Origen", "Destino", "Tarifa", "Transito", "Notas"],
+}
+
+
+def build_template(mode: str) -> bytes:
+    """Genera un .xlsx con los encabezados del modo + una fila de ejemplo."""
+    import openpyxl
+
+    if mode not in TEMPLATES:
+        raise HTTPException(status_code=400, detail=f"Modo '{mode}' no válido")
+    wb = openpyxl.Workbook()
+    ws = wb.active
+    ws.title = mode
+    headers = TEMPLATES[mode]
+    ws.append(headers)
+    examples = {
+        "aereo": ["EUROPA", "NLU", "Frankfurt", "FRA", 190, 1.00, 1.00, 0.95, 0.90],
+        "maritimo_fcl": ["MXZLO", "CNSHA", "40HC", 2500, 28, "THC no incluido"],
+        "maritimo_lcl": ["MXZLO", "USLAX", 45, 80, "1 W/M = 1 ton o 1 m3"],
+        "terrestre": ["Monterrey", "Laredo", 850, 1, ""],
+    }
+    ws.append(examples[mode])
+    buf = io.BytesIO()
+    wb.save(buf)
+    return buf.getvalue()
+
+
+def _num(v: Any) -> Decimal | None:
+    if v is None or v == "":
+        return None
+    try:
+        return Decimal(str(v).replace("$", "").replace(",", "").strip())
+    except Exception:
+        return None
+
+
+def parse_excel(mode: str, content: bytes) -> ImportPreview:
+    """Lee el Excel y devuelve una vista previa con validaciones (no persiste)."""
+    import openpyxl
+
+    if mode not in TEMPLATES:
+        raise HTTPException(status_code=400, detail=f"Modo '{mode}' no válido")
+    try:
+        wb = openpyxl.load_workbook(io.BytesIO(content), data_only=True, read_only=True)
+    except Exception:
+        raise HTTPException(status_code=400, detail="No se pudo leer el archivo Excel")
+    ws = wb.active
+    rows_iter = ws.iter_rows(values_only=True)
+    header = next(rows_iter, None)
+    if not header:
+        raise HTTPException(status_code=400, detail="El archivo está vacío")
+    cols = [str(c).strip() if c is not None else "" for c in header]
+    idx = {name.lower(): i for i, name in enumerate(cols)}
+
+    def cell(row, name):
+        i = idx.get(name.lower())
+        return row[i] if i is not None and i < len(row) else None
+
+    preview_rows: list[ImportPreviewRow] = []
+    valid = 0
+    for n, row in enumerate(rows_iter, start=2):
+        if row is None or all(c is None or str(c).strip() == "" for c in row):
+            continue
+        errors: list[str] = []
+        warnings: list[str] = []
+        data: dict = {}
+        if mode == "aereo":
+            data = {
+                "region": cell(row, "Region"),
+                "origin": cell(row, "Origen"),
+                "destination": cell(row, "Destino") or cell(row, "IATA"),
+                "iata": cell(row, "IATA"),
+                "min_charge": _num(cell(row, "Min")),
+                "breaks": {b: _num(cell(row, b)) for b in ("100", "300", "500", "1000")},
+            }
+            if not data["destination"]:
+                errors.append("Falta destino/IATA")
+            if not any(v is not None for v in data["breaks"].values()):
+                errors.append("Sin tarifas por quiebre")
+        elif mode == "maritimo_fcl":
+            data = {
+                "origin": cell(row, "Origen"),
+                "destination": cell(row, "Destino"),
+                "equipment_type": cell(row, "Tipo contenedor"),
+                "flat_rate": _num(cell(row, "Tarifa")),
+                "transit_days": _num(cell(row, "Transito")),
+                "notes": cell(row, "Notas"),
+            }
+            if data["flat_rate"] is None:
+                errors.append("Falta la tarifa")
+            if not data["equipment_type"]:
+                warnings.append("Sin tipo de contenedor")
+        elif mode == "maritimo_lcl":
+            data = {
+                "origin": cell(row, "Origen"),
+                "destination": cell(row, "Destino"),
+                "wm_rate": _num(cell(row, "Tarifa W/M")),
+                "min_charge": _num(cell(row, "Minimo")),
+                "notes": cell(row, "Notas"),
+            }
+            if data["wm_rate"] is None:
+                errors.append("Falta la tarifa W/M")
+        else:  # terrestre
+            data = {
+                "origin": cell(row, "Origen"),
+                "destination": cell(row, "Destino"),
+                "flat_rate": _num(cell(row, "Tarifa")),
+                "transit_days": _num(cell(row, "Transito")),
+                "notes": cell(row, "Notas"),
+            }
+            if data["flat_rate"] is None:
+                errors.append("Falta la tarifa")
+        if not data.get("destination"):
+            errors.append("Falta destino")
+        ok = not errors
+        if ok:
+            valid += 1
+        preview_rows.append(ImportPreviewRow(row=n, data=_jsonable(data), ok=ok,
+                                             warnings=warnings, errors=errors))
+    return ImportPreview(mode=mode, total=len(preview_rows), valid=valid,
+                         rows=preview_rows, columns=cols)
+
+
+def _jsonable(d: dict) -> dict:
+    out = {}
+    for k, v in d.items():
+        if isinstance(v, Decimal):
+            out[k] = float(v)
+        elif isinstance(v, dict):
+            out[k] = {kk: (float(vv) if isinstance(vv, Decimal) else vv) for kk, vv in v.items()}
+        else:
+            out[k] = v
+    return out
+
+
+def _rows_to_lanes(mode: str, rows: list[ImportPreviewRow], default_origin: str | None) -> list[RateLaneCreate]:
+    lanes: list[RateLaneCreate] = []
+    for r in rows:
+        if not r.ok:
+            continue
+        d = r.data
+        origin = d.get("origin") or default_origin
+        if mode == "aereo":
+            breaks = [
+                {"from_qty": Decimal(b), "rate": Decimal(str(v))}
+                for b, v in (d.get("breaks") or {}).items() if v is not None
+            ]
+            lanes.append(RateLaneCreate(
+                origin=str(origin) if origin else None,
+                destination=str(d.get("destination")),
+                region=d.get("region"), rate_unit="per_kg",
+                min_charge=_num(d.get("min_charge")),
+                breaks=breaks,  # type: ignore[arg-type]
+            ))
+        elif mode == "maritimo_fcl":
+            lanes.append(RateLaneCreate(
+                origin=str(origin) if origin else None, destination=str(d.get("destination")),
+                equipment_type=d.get("equipment_type"), rate_unit="per_container",
+                flat_rate=_num(d.get("flat_rate")),
+                transit_days=int(d["transit_days"]) if d.get("transit_days") else None,
+                notes=d.get("notes"),
+            ))
+        elif mode == "maritimo_lcl":
+            lanes.append(RateLaneCreate(
+                origin=str(origin) if origin else None, destination=str(d.get("destination")),
+                rate_unit="per_wm", min_charge=_num(d.get("min_charge")),
+                breaks=[{"from_qty": Decimal(0), "rate": Decimal(str(d["wm_rate"]))}],  # type: ignore[arg-type]
+                notes=d.get("notes"),
+            ))
+        else:
+            lanes.append(RateLaneCreate(
+                origin=str(origin) if origin else None, destination=str(d.get("destination")),
+                rate_unit="flat", flat_rate=_num(d.get("flat_rate")),
+                transit_days=int(d["transit_days"]) if d.get("transit_days") else None,
+                notes=d.get("notes"),
+            ))
+    return lanes
+
+
+def confirm_import(db: Session, tenant_id: int, company_id: int, data: ImportConfirm,
+                   user_id: str | None) -> RateSheet:
+    """Crea el tarifario + rutas a partir de la vista previa confirmada."""
+    sheet = RateSheet(
+        tenant_id=tenant_id, company_id=company_id,
+        supplier_id=data.supplier_id, mode=data.mode, name=data.name,
+        currency=data.currency, valid_from=data.valid_from, valid_to=data.valid_to,
+        default_origin=data.default_origin, status=data.status or "borrador",
+        notes=data.notes, created_by=user_id, updated_by=user_id,
+    )
+    db.add(sheet)
+    db.flush()
+    for lane in data.lanes:
+        _add_lane(db, tenant_id, company_id, sheet.id, lane)
+    db.commit()
+    db.refresh(sheet)
+    return sheet
+
+
+def import_from_excel(db: Session, tenant_id: int, company_id: int, mode: str,
+                      content: bytes, header: RateSheetCreate, user_id: str | None) -> RateSheet:
+    """Atajo: parsea el Excel y crea el tarifario en un solo paso."""
+    preview = parse_excel(mode, content)
+    lanes = _rows_to_lanes(mode, preview.rows, header.default_origin)
+    return confirm_import(
+        db, tenant_id, company_id,
+        ImportConfirm(**header.model_dump(), lanes=lanes), user_id,
+    )
+
+
+# ============================================================ Motor de costeo
+def _volumetric_kg(volume_m3: Decimal | None) -> Decimal:
+    return (volume_m3 or Decimal(0)) * AIR_VOLUMETRIC_FACTOR
+
+
+def _rate_for(breaks: list[RateBreak], qty: Decimal) -> Decimal | None:
+    """Tarifa aplicable al peso/wm 'qty' (mayor quiebre cuyo umbral <= qty)."""
+    if not breaks:
+        return None
+    applicable = None
+    for b in breaks:
+        if b.from_qty <= qty:
+            applicable = b.rate
+    if applicable is None:
+        applicable = breaks[0].rate  # por debajo del primer quiebre → tarifa base (gobierna el mínimo)
+    return applicable
+
+
+def _best_break_cost(breaks: list[RateBreak], qty: Decimal) -> Decimal:
+    """Costo base con optimización de quiebre (declarar peso mayor si conviene)."""
+    base_rate = _rate_for(breaks, qty)
+    base = (qty * base_rate) if base_rate is not None else Decimal(0)
+    for b in breaks:
+        if b.from_qty > qty:
+            candidate = b.from_qty * b.rate
+            if candidate < base:
+                base = candidate
+    return base
+
+
+def _apply_charges(db: Session, sheet: RateSheet, lane: RateLane, base: Decimal,
+                   chargeable: Decimal, quantity: int, dangerous: bool) -> list[CostChargeLine]:
+    charges = (
+        db.query(RateCharge)
+        .filter(
+            RateCharge.deleted_at.is_(None),
+            or_(RateCharge.rate_sheet_id == sheet.id, RateCharge.rate_lane_id == lane.id),
+        )
+        .all()
+    )
+    lines: list[CostChargeLine] = []
+    for c in charges:
+        if c.concept == "dgr" and not dangerous:
+            continue
+        v = c.value or Decimal(0)
+        if c.charge_type == "fijo" or c.charge_type == "por_guia":
+            amt = v
+        elif c.charge_type == "por_kg":
+            amt = v * chargeable
+        elif c.charge_type == "por_contenedor":
+            amt = v * quantity
+        elif c.charge_type == "porcentaje":
+            amt = base * v / Decimal(100)
+        else:
+            amt = v
+        lines.append(CostChargeLine(concept=c.concept, amount=amt))
+    return lines
+
+
+def lane_locations(db: Session, tenant_id: int, company_id: int, mode: str) -> dict[str, list[str]]:
+    """Orígenes/destinos existentes en los tarifarios activos de un modo.
+
+    Alinea el cotizador con las rutas realmente cotizables (los códigos provienen
+    de las lanes, por lo que el costeo siempre encontrará ruta).
+    """
+    sheets = _sheet_query(db, tenant_id, company_id).filter(
+        RateSheet.mode == mode, RateSheet.status == "activo",
+    ).all()
+    origins: set[str] = set()
+    destinations: set[str] = set()
+    for sheet in sheets:
+        lanes = db.query(RateLane).filter(
+            RateLane.rate_sheet_id == sheet.id, RateLane.deleted_at.is_(None),
+        ).all()
+        for lane in lanes:
+            origin = lane.origin or sheet.default_origin
+            if origin:
+                origins.add(origin)
+            if lane.destination:
+                destinations.add(lane.destination)
+    return {"origins": sorted(origins), "destinations": sorted(destinations)}
+
+
+def quote_cost(db: Session, tenant_id: int, company_id: int, req: CostRequest) -> list[CostOption]:
+    on_date = req.on_date or date.today()
+    sheets = _sheet_query(db, tenant_id, company_id).filter(
+        RateSheet.mode == req.mode,
+        RateSheet.status == "activo",
+        or_(RateSheet.valid_from.is_(None), RateSheet.valid_from <= on_date),
+        or_(RateSheet.valid_to.is_(None), RateSheet.valid_to >= on_date),
+    ).all()
+
+    gross = req.gross_weight_kg or Decimal(0)
+    options: list[CostOption] = []
+    for sheet in sheets:
+        lanes_q = db.query(RateLane).filter(
+            RateLane.rate_sheet_id == sheet.id, RateLane.deleted_at.is_(None),
+        )
+        if req.destination:
+            lanes_q = lanes_q.filter(RateLane.destination == req.destination)
+        for lane in lanes_q.all():
+            # Origen: match exacto o el default del tarifario.
+            lane_origin = lane.origin or sheet.default_origin
+            if req.origin and lane_origin and lane_origin != req.origin:
+                continue
+            if req.mode == "maritimo_fcl":
+                if req.equipment_type and lane.equipment_type and lane.equipment_type != req.equipment_type:
+                    continue
+                chargeable = Decimal(req.quantity)
+                base = (lane.flat_rate or Decimal(0)) * req.quantity
+                detail = f"{req.quantity} x {lane.equipment_type or 'contenedor'}"
+            elif req.mode == "terrestre":
+                chargeable = Decimal(req.quantity)
+                base = (lane.flat_rate or Decimal(0)) * req.quantity
+                detail = "tarifa por ruta"
+            elif req.mode == "maritimo_lcl":
+                tons = gross / Decimal(1000)
+                wm = max(tons, req.volume_m3 or Decimal(0))
+                brks = breaks_of(db, lane.id)
+                base = _best_break_cost(brks, wm) if brks else Decimal(0)
+                chargeable = wm
+                base = max(base, lane.min_charge or Decimal(0))
+                detail = f"W/M {wm.quantize(Decimal('0.01'))}"
+            else:  # aereo
+                # P/Vol por dimensiones (L×A×H×cant / 6000); si no hay dimensiones,
+                # respaldo con el volumen en m³ × 167.
+                vol_by_dims = air_volumetric_kg(req.length_cm, req.width_cm, req.height_cm, req.quantity)
+                volumetric = vol_by_dims if vol_by_dims > 0 else _volumetric_kg(req.volume_m3)
+                chargeable = max(gross, volumetric)
+                brks = breaks_of(db, lane.id)
+                base = _best_break_cost(brks, chargeable)
+                base = max(base, lane.min_charge or Decimal(0))
+                detail = f"facturable {chargeable.quantize(Decimal('0.01'))} kg (P/Vol)"
+
+            charge_lines = _apply_charges(db, sheet, lane, base, chargeable, req.quantity, req.dangerous)
+            total = base + sum((c.amount for c in charge_lines), Decimal(0))
+            options.append(CostOption(
+                rate_sheet_id=sheet.id, rate_sheet_name=sheet.name, supplier_id=sheet.supplier_id,
+                currency=sheet.currency, chargeable=chargeable, base_cost=base,
+                charges=charge_lines, total_cost=total, transit_days=lane.transit_days, detail=detail,
+            ))
+    options.sort(key=lambda o: o.total_cost)
+    return options

backend/api/v1/modules/crm/router.py

@@ -13,14 +13,18 @@ from . import permissions  # noqa: F401  (side-effect: registra permisos del CRM
 from .accounts.routes import router as accounts_router
 from .activities.routes import router as activities_router
 from .addresses.routes import router as addresses_router
+from .cases.routes import router as cases_router
 from .catalogs.routes import router as catalogs_router
 from .contacts.routes import router as contacts_router
 from .documents.routes import router as documents_router
+from .expediente_gateway.routes import router as expediente_gateway_router
 from .leads.routes import router as leads_router
 from .metrics.routes import router as metrics_router
 from .opportunities.routes import router as opportunities_router
 from .pipelines.routes import router as pipelines_router
 from .quotes.routes import router as quotes_router
+from .rates.routes import cost_router as rates_cost_router
+from .rates.routes import router as rates_router
 from .service_requests.routes import router as service_requests_router
 from .suppliers.routes import router as suppliers_router
 from .uploads.routes import router as uploads_router
@@ -41,6 +45,13 @@ router.include_router(leads_router)
 router.include_router(pipelines_router)
 router.include_router(opportunities_router)
 router.include_router(activities_router)
+router.include_router(cases_router)
 router.include_router(metrics_router)
 router.include_router(catalogs_router)
 router.include_router(uploads_router)
+router.include_router(rates_router)
+router.include_router(rates_cost_router)
+# Tablero de operación del carril hacia EFC: cola pendiente, métricas y reintento manual.
+# No es una ruta de negocio; existe para que una persona vea y desatore la entrega sin
+# entrar a la base. Hereda el enforcement de crm.access del router agregador.
+router.include_router(expediente_gateway_router)

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

@@ -7,22 +7,66 @@ from pydantic import BaseModel, ConfigDict, Field
 class ServiceRequestBase(BaseModel):
     reference: str | None = Field(None, max_length=40)
     account_id: int | None = None
+    contact_id: int | None = None
     opportunity_id: int | None = None
     operation_type: str = Field(..., max_length=20)  # importacion | exportacion
     transport_mode: str | None = Field(None, max_length=20)
     service_type: str | None = Field(None, max_length=20)
     incoterm: str | None = Field(None, max_length=10)
+    # Ruta legada (texto libre) — se conserva por compatibilidad
     origin: str | None = Field(None, max_length=160)
     destination: str | None = Field(None, max_length=160)
+    # Ruta estructurada (país por catálogo ISO; ciudad/puerto por catálogo o texto)
+    origin_country: str | None = Field(None, max_length=3)
+    origin_city: str | None = Field(None, max_length=120)
+    origin_port: str | None = Field(None, max_length=20)
+    destination_country: str | None = Field(None, max_length=3)
+    destination_city: str | None = Field(None, max_length=120)
+    destination_port: str | None = Field(None, max_length=20)
+    pickup_location: str | None = Field(None, max_length=255)
+    delivery_location: str | None = Field(None, max_length=255)
     cargo_type: str | None = Field(None, max_length=120)
-    weight: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)
+    weight: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)  # peso bruto
     volume: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)
-    load_type: str | None = Field(None, max_length=10)
+    load_type: str | None = Field(None, max_length=10)  # FCL | LCL | AMBAS
     container_equipment: str | None = Field(None, max_length=120)
+    container_count: int | None = Field(None, ge=0)
     commodity: str | None = None
     required_date: date | None = None
+    request_date: date | None = None
+    estimated_shipment_date: date | None = None
+    currency: str | None = Field(None, max_length=3)
+    priority: str | None = Field(None, max_length=20)
+    # Mercancía
+    cargo_value: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=2)
+    insurance_required: bool = False
+    hs_code: str | None = Field(None, max_length=20)
+    goods_origin_country: str | None = Field(None, max_length=3)
+    hazardous_imo: bool = False
+    refrigerated: bool = False
+    stackable: bool = False
+    # Dimensiones y bultos
+    pieces_count: int | None = Field(None, ge=0)
+    boxes_count: int | None = Field(None, ge=0)
+    pallets_count: int | None = Field(None, ge=0)
+    net_weight: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)
+    length_cm: Decimal | None = Field(None, ge=0, max_digits=10, decimal_places=2)
+    width_cm: Decimal | None = Field(None, ge=0, max_digits=10, decimal_places=2)
+    height_cm: Decimal | None = Field(None, ge=0, max_digits=10, decimal_places=2)
+    measurement_unit: str | None = Field(None, max_length=20)
+    # LCL
+    packaging_type: str | None = Field(None, max_length=20)
+    oversized: bool = False
+    weight_per_pallet: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)
+    volume_per_pallet: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)
+    # Servicios adicionales (códigos del catálogo servicio_adicional) y pago
+    additional_services: list[str] | None = None
+    additional_service_costs: dict[str, float] | None = None  # {codigo: costo estimado}
+    payment_method: str | None = Field(None, max_length=20)
     destination_agent_id: int | None = None
     requirements: str | None = None
+    client_notes: str | None = None
+    internal_notes: str | None = None
     status: str = Field("nueva", max_length=20)
     notes: str | None = None
     owner_user_id: str | None = Field(None, max_length=64)
@@ -38,8 +82,12 @@ class ServiceRequestContactInput(BaseModel):
 
 
 class ServiceRequestFromOpportunityInput(BaseModel):
-    """Datos para convertir una oportunidad del embudo en solicitud/RFQ (R-C-02)."""
-    operation_type: str = Field(..., max_length=20)  # importacion | exportacion
+    """Datos para convertir una oportunidad del embudo en solicitud/RFQ (R-C-02).
+
+    La dirección impo/expo se hereda de la oportunidad; ``operation_type`` aquí es
+    solo un respaldo para oportunidades antiguas que no la tengan capturada.
+    """
+    operation_type: str | None = Field(None, max_length=20)  # importacion | exportacion
     transport_mode: str | None = Field(None, max_length=20)
     service_type: str | None = Field(None, max_length=20)
     incoterm: str | None = Field(None, max_length=10)
@@ -51,6 +99,7 @@ class ServiceRequestFromOpportunityInput(BaseModel):
 class ServiceRequestUpdate(BaseModel):
     reference: str | None = Field(None, max_length=40)
     account_id: int | None = None
+    contact_id: int | None = None
     opportunity_id: int | None = None
     operation_type: str | None = Field(None, max_length=20)
     transport_mode: str | None = Field(None, max_length=20)
@@ -58,15 +107,52 @@ class ServiceRequestUpdate(BaseModel):
     incoterm: str | None = Field(None, max_length=10)
     origin: str | None = Field(None, max_length=160)
     destination: str | None = Field(None, max_length=160)
+    origin_country: str | None = Field(None, max_length=3)
+    origin_city: str | None = Field(None, max_length=120)
+    origin_port: str | None = Field(None, max_length=20)
+    destination_country: str | None = Field(None, max_length=3)
+    destination_city: str | None = Field(None, max_length=120)
+    destination_port: str | None = Field(None, max_length=20)
+    pickup_location: str | None = Field(None, max_length=255)
+    delivery_location: str | None = Field(None, max_length=255)
     cargo_type: str | None = Field(None, max_length=120)
     weight: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)
     volume: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)
     load_type: str | None = Field(None, max_length=10)
     container_equipment: str | None = Field(None, max_length=120)
+    container_count: int | None = Field(None, ge=0)
     commodity: str | None = None
     required_date: date | None = None
+    request_date: date | None = None
+    estimated_shipment_date: date | None = None
+    currency: str | None = Field(None, max_length=3)
+    priority: str | None = Field(None, max_length=20)
+    cargo_value: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=2)
+    insurance_required: bool | None = None
+    hs_code: str | None = Field(None, max_length=20)
+    goods_origin_country: str | None = Field(None, max_length=3)
+    hazardous_imo: bool | None = None
+    refrigerated: bool | None = None
+    stackable: bool | None = None
+    pieces_count: int | None = Field(None, ge=0)
+    boxes_count: int | None = Field(None, ge=0)
+    pallets_count: int | None = Field(None, ge=0)
+    net_weight: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)
+    length_cm: Decimal | None = Field(None, ge=0, max_digits=10, decimal_places=2)
+    width_cm: Decimal | None = Field(None, ge=0, max_digits=10, decimal_places=2)
+    height_cm: Decimal | None = Field(None, ge=0, max_digits=10, decimal_places=2)
+    measurement_unit: str | None = Field(None, max_length=20)
+    packaging_type: str | None = Field(None, max_length=20)
+    oversized: bool | None = None
+    weight_per_pallet: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)
+    volume_per_pallet: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=3)
+    additional_services: list[str] | None = None
+    additional_service_costs: dict[str, float] | None = None
+    payment_method: str | None = Field(None, max_length=20)
     destination_agent_id: int | None = None
     requirements: str | None = None
+    client_notes: str | None = None
+    internal_notes: str | None = None
     status: str | None = Field(None, max_length=20)
     notes: str | None = None
     owner_user_id: str | None = Field(None, max_length=64)
@@ -76,6 +162,7 @@ class ServiceRequestResponse(ServiceRequestBase):
     model_config = ConfigDict(from_attributes=True)
 
     id: int
+    case_id: int | None = None
     first_contact_at: datetime | None = None
     first_contact_notes: str | None = None
     tenant_id: int

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

@@ -1,6 +1,6 @@
 from datetime import date, datetime
 
-from sqlalchemy import Date, DateTime, ForeignKey, Integer, Numeric, String, Text, text
+from sqlalchemy import JSON, Boolean, Date, DateTime, ForeignKey, Integer, Numeric, String, Text, text
 from sqlalchemy.orm import Mapped, mapped_column
 
 from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
@@ -19,6 +19,7 @@ class ServiceRequest(Base, TenantScopedMixin, TimestampMixin):
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     reference: Mapped[str | None] = mapped_column(String(40), nullable=True, index=True)  # folio
+    case_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("crm.cases.id"), nullable=True, index=True)  # expediente
     account_id: Mapped[int | None] = mapped_column(
         Integer, ForeignKey("crm.accounts.id"), nullable=True, index=True
     )
@@ -57,6 +58,57 @@ class ServiceRequest(Base, TenantScopedMixin, TimestampMixin):
     created_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
     updated_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
 
+    # ----- Campos del documento maestro de cotización (T2026-08) -----
+    # Datos generales
+    contact_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("crm.contacts.id"), nullable=True, index=True
+    )
+    request_date: Mapped[date | None] = mapped_column(Date, nullable=True)  # fecha de la solicitud
+    currency: Mapped[str | None] = mapped_column(String(3), nullable=True)
+    priority: Mapped[str | None] = mapped_column(String(20), nullable=True)  # baja|normal|alta|urgente
+    # Ruta (país por catálogo ISO; ciudad/puerto por catálogo o texto libre)
+    origin_country: Mapped[str | None] = mapped_column(String(3), nullable=True)
+    origin_city: Mapped[str | None] = mapped_column(String(120), nullable=True)
+    origin_port: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    destination_country: Mapped[str | None] = mapped_column(String(3), nullable=True)
+    destination_city: Mapped[str | None] = mapped_column(String(120), nullable=True)
+    destination_port: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    pickup_location: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    delivery_location: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    estimated_shipment_date: Mapped[date | None] = mapped_column(Date, nullable=True)
+    # Mercancía
+    cargo_value: Mapped[float | None] = mapped_column(Numeric(14, 2), nullable=True)
+    insurance_required: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    hs_code: Mapped[str | None] = mapped_column(String(20), nullable=True)  # fracción arancelaria
+    goods_origin_country: Mapped[str | None] = mapped_column(String(3), nullable=True)  # país de origen de la mercancía
+    hazardous_imo: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    refrigerated: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    stackable: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    # Dimensiones y bultos
+    pieces_count: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    boxes_count: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    pallets_count: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    net_weight: Mapped[float | None] = mapped_column(Numeric(14, 3), nullable=True)  # peso neto (weight = bruto)
+    length_cm: Mapped[float | None] = mapped_column(Numeric(10, 2), nullable=True)
+    width_cm: Mapped[float | None] = mapped_column(Numeric(10, 2), nullable=True)
+    height_cm: Mapped[float | None] = mapped_column(Numeric(10, 2), nullable=True)
+    measurement_unit: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    # FCL
+    container_count: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    # LCL
+    packaging_type: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    oversized: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    weight_per_pallet: Mapped[float | None] = mapped_column(Numeric(14, 3), nullable=True)
+    volume_per_pallet: Mapped[float | None] = mapped_column(Numeric(14, 3), nullable=True)
+    # Servicios adicionales (lista de códigos del catálogo servicio_adicional) y pago
+    additional_services: Mapped[list | None] = mapped_column(JSON, nullable=True)
+    # Costo estimado por servicio adicional marcado: {codigo: costo}
+    additional_service_costs: Mapped[dict | None] = mapped_column(JSON, nullable=True)
+    payment_method: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    # Notas
+    client_notes: Mapped[str | None] = mapped_column(Text, nullable=True)
+    internal_notes: Mapped[str | None] = mapped_column(Text, nullable=True)
+
 
 class RateRequest(Base, TenantScopedMixin, TimestampMixin):
     """Solicitud de tarifa a un proveedor para una solicitud de servicio (Diagrama 1, paso 6)."""

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

@@ -4,7 +4,10 @@ from fastapi import HTTPException, status
 from sqlalchemy.orm import Session
 
 from ..accounts.models import Account
+from ..cases import service as cases_service
 from ..catalogs.data import INCOTERM_CODES
+from ..common.folios import next_folio
+from ..contacts.models import Contact
 from ..opportunities.models import Opportunity
 from ..suppliers.models import Supplier
 from .dto import (
@@ -37,6 +40,8 @@ def _exists(db: Session, model, _id: int | None, tenant_id: int, company_id: int
 def _validate_request_refs(db: Session, data: dict, tenant_id: int, company_id: int) -> None:
     if not _exists(db, Account, data.get("account_id"), tenant_id, company_id):
         raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="El cliente asociado no existe")
+    if not _exists(db, Contact, data.get("contact_id"), tenant_id, company_id):
+        raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="El contacto asociado no existe")
     if not _exists(db, Supplier, data.get("destination_agent_id"), tenant_id, company_id):
         raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail="El agente en destino no existe")
     if not _exists(db, Opportunity, data.get("opportunity_id"), tenant_id, company_id):
@@ -103,6 +108,15 @@ def create_service_request(
     data = payload.model_dump()
     _validate_request_refs(db, data, tenant_id, company_id)
     obj = ServiceRequest(**data, tenant_id=tenant_id, company_id=company_id, created_by=user_id, updated_by=user_id)
+    # Folio S... auto-generado (mensual) si no viene uno explícito
+    if not obj.reference:
+        obj.reference = next_folio(db, tenant_id, company_id, "S", obj.operation_type)
+    # Expediente: normalmente nace en la oportunidad; si la solicitud es directa, se mintea aquí
+    if not obj.case_id:
+        case = cases_service.create_case(
+            db, tenant_id, company_id, account_id=obj.account_id, title=obj.reference, stage="solicitud", user_id=user_id,
+        )
+        obj.case_id = case.id
     db.add(obj)
     db.commit()
     db.refresh(obj)
@@ -166,10 +180,24 @@ def create_from_opportunity(
     )
     if not opp:
         raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Oportunidad no encontrada")
+
+    # Idempotente: si la oportunidad ya se convirtió, devuelve la misma solicitud
+    if opp.converted_service_request_id:
+        existing = get_service_request(db, opp.converted_service_request_id, tenant_id, company_id)
+        return existing
+
+    # La dirección impo/expo se hereda de la oportunidad (respaldo: el payload)
+    operation_type = opp.operation_type or payload.operation_type
+    if not operation_type:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="Define la dirección (importación/exportación) en la oportunidad para convertirla",
+        )
     obj = ServiceRequest(
         account_id=opp.account_id,
+        contact_id=opp.contact_id,
         opportunity_id=opp.id,
-        operation_type=payload.operation_type,
+        operation_type=operation_type,
         transport_mode=payload.transport_mode,
         service_type=payload.service_type,
         incoterm=payload.incoterm,
@@ -178,12 +206,24 @@ def create_from_opportunity(
         status="nueva",
         notes=payload.notes,
         owner_user_id=opp.owner_user_id,
+        reference=next_folio(db, tenant_id, company_id, "S", operation_type),
+        case_id=opp.case_id,
         tenant_id=tenant_id,
         company_id=company_id,
         created_by=user_id,
         updated_by=user_id,
     )
     db.add(obj)
+    db.flush()
+    # Expediente heredado de la oportunidad (fallback si la oportunidad es antigua sin expediente)
+    if not obj.case_id:
+        obj.case_id = cases_service.create_case(
+            db, tenant_id, company_id, account_id=opp.account_id, title=obj.reference, stage="solicitud", user_id=user_id,
+        ).id
+        opp.case_id = obj.case_id
+    cases_service.advance_stage(db, obj.case_id, "solicitud")
+    # Back-link para cerrar el ciclo Oportunidad→Solicitud (y garantizar idempotencia)
+    opp.converted_service_request_id = obj.id
     db.commit()
     db.refresh(obj)
     return obj

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/api/v1/modules/crm/uploads/routes.py

@@ -7,10 +7,10 @@ pide una URL firmada fresca en ``/uploads/url`` (las presignadas expiran).
 import re
 import uuid
 
-from fastapi import APIRouter, Depends, File, HTTPException, Query, UploadFile, status
+from fastapi import APIRouter, Depends, File, HTTPException, Query, Response, UploadFile, status
 
 from core.security import get_current_user
-from core.storage_s3 import presigned_get_url, put_object_bytes
+from core.storage_s3 import get_object_bytes, presigned_get_url, put_object_bytes
 
 router = APIRouter()
 
@@ -61,3 +61,29 @@ def get_upload_url(
     if not key.startswith(prefix):
         raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Archivo fuera de tu alcance")
     return {"url": presigned_get_url(key)}
+
+
+@router.get("/uploads/download")
+def download_file(
+    key: str = Query(..., description="Object key del archivo en el almacén"),
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+):
+    """Transmite el archivo por el backend (sin exponer MinIO al navegador).
+
+    Evita el bug de la URL prefirmada que apunta al host interno ``minio:9000``.
+    """
+    tenant_id = current_user["tenant_id"]
+    prefix = f"tenants/{tenant_id}/companies/{company_id}/"
+    if not key.startswith(prefix):
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Archivo fuera de tu alcance")
+    try:
+        data = get_object_bytes(key)
+    except Exception:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Archivo no encontrado")
+    filename = key.rsplit("/", 1)[-1]
+    return Response(
+        content=data,
+        media_type="application/octet-stream",
+        headers={"Content-Disposition": f'inline; filename="{filename}"'},
+    )

backend/api/v1/modules/fin/catalogs/__init__.py

@@ -0,0 +1 @@
+"""Catálogos oficiales del SAT (schema ``sat``): globales y de solo lectura."""

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

@@ -0,0 +1,61 @@
+"""Esquemas de respuesta de los catálogos del SAT (solo lectura)."""
+
+from pydantic import BaseModel, ConfigDict
+
+
+class SatCatalogItem(BaseModel):
+    """Forma común de todo catálogo del SAT: clave + descripción."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    code: str
+    description: str
+    is_active: bool
+
+
+class TaxRegimeResponse(SatCatalogItem):
+    """``c_RegimenFiscal``: incluye a qué tipo de persona aplica el régimen."""
+
+    applies_to_individual: bool  # persona física
+    applies_to_legal_entity: bool  # persona moral
+
+
+class TaxResponse(SatCatalogItem):
+    """``c_Impuesto``: indica si el impuesto puede retenerse o trasladarse."""
+
+    is_withholding: bool
+    is_transferred: bool
+    is_local: bool
+
+
+class UnitOfMeasureResponse(SatCatalogItem):
+    """``c_ClaveUnidad``: nombre corto, símbolo y nota larga del catálogo."""
+
+    description: str | None = None
+    name: str
+    symbol: str | None = None
+
+
+class PaymentFormResponse(SatCatalogItem):
+    """``c_FormaPago``."""
+
+
+class ProductServiceResponse(SatCatalogItem):
+    """``c_ClaveProdServ``."""
+
+
+class VoucherTypeResponse(SatCatalogItem):
+    """``c_TipoDeComprobante``."""
+
+
+class PaymentMethodResponse(SatCatalogItem):
+    """``c_MetodoPago``."""
+
+
+class TaxObjectResponse(SatCatalogItem):
+    """``c_ObjetoImp``."""
+
+
+class CfdiUseResponse(SatCatalogItem):
+    """``c_UsoCFDI``."""

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

@@ -0,0 +1,143 @@
+"""Modelos de los catálogos oficiales del SAT — schema ``sat``.
+
+Son catálogos **globales**: los publica el SAT, valen igual para cualquier tenant y
+compañía, por eso no heredan ``TenantScopedMixin``. Tampoco se borran: cuando el SAT
+retira una clave, el registro se marca ``is_active = false`` para que las facturas
+históricas que la usan sigan resolviendo su descripción (de ahí que se use
+``BaseTimestampMixin``, sin ``deleted_at``).
+
+La API los expone únicamente en modo lectura; el alta y la actualización pasan por
+``seed_data.sync_catalogs()``.
+"""
+
+from sqlalchemy import Boolean, Integer, String, text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from api.v1.common.base_models import BaseTimestampMixin
+from core.database import Base
+
+
+class SatCatalogMixin(BaseTimestampMixin):
+    """Campos comunes a todo catálogo del SAT.
+
+    ``code`` (la clave oficial) se declara en cada modelo porque su longitud
+    cambia de catálogo en catálogo.
+    """
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    description: Mapped[str] = mapped_column(String(500), nullable=False)
+    is_active: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("true"))
+
+
+class TaxRegime(Base, SatCatalogMixin):
+    """``c_RegimenFiscal`` — régimen fiscal del emisor y del receptor del CFDI.
+
+    Las banderas indican a qué tipo de persona aplica el régimen: una persona física
+    no puede declararse en el 601 (General de Ley Personas Morales) y viceversa.
+    """
+
+    __tablename__ = "tax_regimes"
+    __table_args__ = {"schema": "sat"}
+
+    code: Mapped[str] = mapped_column(String(3), nullable=False, unique=True, index=True)
+    applies_to_individual: Mapped[bool] = mapped_column(  # persona física
+        Boolean, nullable=False, server_default=text("false")
+    )
+    applies_to_legal_entity: Mapped[bool] = mapped_column(  # persona moral
+        Boolean, nullable=False, server_default=text("false")
+    )
+
+
+class Tax(Base, SatCatalogMixin):
+    """``c_Impuesto`` — impuestos federales que pueden trasladarse o retenerse."""
+
+    __tablename__ = "taxes"
+    __table_args__ = {"schema": "sat"}
+
+    code: Mapped[str] = mapped_column(String(3), nullable=False, unique=True, index=True)
+    is_withholding: Mapped[bool] = mapped_column(  # puede retenerse
+        Boolean, nullable=False, server_default=text("false")
+    )
+    is_transferred: Mapped[bool] = mapped_column(  # puede trasladarse
+        Boolean, nullable=False, server_default=text("false")
+    )
+    # Los impuestos locales (ISH y similares) viajan en el complemento "Impuestos
+    # Locales" con claves ajenas a c_Impuesto; la bandera queda disponible para
+    # cuando el negocio defina ese catálogo.
+    is_local: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+
+
+class PaymentForm(Base, SatCatalogMixin):
+    """``c_FormaPago`` — con qué se pagó (efectivo, transferencia, tarjeta…)."""
+
+    __tablename__ = "payment_forms"
+    __table_args__ = {"schema": "sat"}
+
+    code: Mapped[str] = mapped_column(String(2), nullable=False, unique=True, index=True)
+
+
+class UnitOfMeasure(Base, SatCatalogMixin):
+    """``c_ClaveUnidad`` — unidad de medida de la partida.
+
+    Único catálogo que separa nombre corto y definición: ``name`` es lo que se
+    muestra al capturar y ``description`` la nota larga del SAT, que puede venir
+    vacía.
+    """
+
+    __tablename__ = "units_of_measure"
+    __table_args__ = {"schema": "sat"}
+
+    code: Mapped[str] = mapped_column(String(20), nullable=False, unique=True, index=True)
+    name: Mapped[str] = mapped_column(String(255), nullable=False)
+    symbol: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    # Se redeclara para permitir NULL: aquí la descripción es la nota del catálogo.
+    description: Mapped[str | None] = mapped_column(String(500), nullable=True)
+
+
+class ProductService(Base, SatCatalogMixin):
+    """``c_ClaveProdServ`` — clave de producto o servicio de la partida."""
+
+    __tablename__ = "products_services"
+    __table_args__ = {"schema": "sat"}
+
+    code: Mapped[str] = mapped_column(String(8), nullable=False, unique=True, index=True)
+
+
+class VoucherType(Base, SatCatalogMixin):
+    """``c_TipoDeComprobante`` — I ingreso, E egreso, T traslado, N nómina, P pago."""
+
+    __tablename__ = "voucher_types"
+    __table_args__ = {"schema": "sat"}
+
+    code: Mapped[str] = mapped_column(String(1), nullable=False, unique=True, index=True)
+
+
+class PaymentMethod(Base, SatCatalogMixin):
+    """``c_MetodoPago`` — PUE (una sola exhibición) o PPD (parcialidades/diferido)."""
+
+    __tablename__ = "payment_methods"
+    __table_args__ = {"schema": "sat"}
+
+    code: Mapped[str] = mapped_column(String(3), nullable=False, unique=True, index=True)
+
+
+class TaxObject(Base, SatCatalogMixin):
+    """``c_ObjetoImp`` — si la partida es o no objeto de impuesto."""
+
+    __tablename__ = "tax_objects"
+    __table_args__ = {"schema": "sat"}
+
+    code: Mapped[str] = mapped_column(String(2), nullable=False, unique=True, index=True)
+
+
+class CfdiUse(Base, SatCatalogMixin):
+    """``c_UsoCFDI`` — uso que el receptor le dará al comprobante.
+
+    Lo declara el receptor, no el emisor, y el SAT lo valida contra su régimen
+    fiscal: por eso vive en la ficha del cliente (``crm.accounts.cfdi_use_id``).
+    """
+
+    __tablename__ = "cfdi_uses"
+    __table_args__ = {"schema": "sat"}
+
+    code: Mapped[str] = mapped_column(String(4), nullable=False, unique=True, index=True)

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

@@ -0,0 +1,138 @@
+"""Endpoints de los catálogos del SAT — **solo lectura**.
+
+No se exponen POST/PUT/PATCH/DELETE a propósito: son catálogos fijos publicados por
+el SAT y se mantienen con ``seed_data.sync_catalogs()``, no por API.
+
+Nota: aunque los catálogos son globales, el router del módulo exige ``fin.access``,
+permiso que se resuelve sobre una compañía; por eso las peticiones siguen llevando
+``company_id`` en la query string.
+"""
+
+from typing import Literal
+
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.orm import Session
+
+from core.database import get_core_db
+from core.security import get_current_user
+
+from . import service
+from .dto import (
+    CfdiUseResponse,
+    PaymentFormResponse,
+    PaymentMethodResponse,
+    ProductServiceResponse,
+    TaxObjectResponse,
+    TaxRegimeResponse,
+    TaxResponse,
+    UnitOfMeasureResponse,
+    VoucherTypeResponse,
+)
+
+router = APIRouter()
+
+_SEARCH = Query(None, description="Búsqueda por clave o descripción")
+_ACTIVE_ONLY = Query(True, description="Solo claves vigentes")
+
+
+@router.get("/catalogs/tax-regimes", response_model=list[TaxRegimeResponse])
+def list_tax_regimes(
+    search: str | None = _SEARCH,
+    active_only: bool = _ACTIVE_ONLY,
+    person_type: Literal["fisica", "moral"] | None = Query(
+        None, description="Acota al régimen de persona física o moral"
+    ),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """``c_RegimenFiscal`` — régimen fiscal del emisor/receptor del CFDI."""
+    return service.get_tax_regimes(db, search, active_only, person_type)
+
+
+@router.get("/catalogs/taxes", response_model=list[TaxResponse])
+def list_taxes(
+    search: str | None = _SEARCH,
+    active_only: bool = _ACTIVE_ONLY,
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """``c_Impuesto`` — impuestos federales trasladados y retenidos."""
+    return service.get_taxes(db, search, active_only)
+
+
+@router.get("/catalogs/payment-forms", response_model=list[PaymentFormResponse])
+def list_payment_forms(
+    search: str | None = _SEARCH,
+    active_only: bool = _ACTIVE_ONLY,
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """``c_FormaPago`` — medio con el que se liquidó el comprobante."""
+    return service.get_payment_forms(db, search, active_only)
+
+
+@router.get("/catalogs/units-of-measure", response_model=list[UnitOfMeasureResponse])
+def list_units_of_measure(
+    search: str | None = _SEARCH,
+    active_only: bool = _ACTIVE_ONLY,
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """``c_ClaveUnidad`` — unidad de medida de la partida."""
+    return service.get_units_of_measure(db, search, active_only)
+
+
+@router.get("/catalogs/products-services", response_model=list[ProductServiceResponse])
+def list_products_services(
+    search: str | None = _SEARCH,
+    active_only: bool = _ACTIVE_ONLY,
+    limit: int = Query(50, ge=1, le=200, description="Máximo de claves devueltas"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """``c_ClaveProdServ`` — clave de producto/servicio; pensado para autocompletado."""
+    return service.get_products_services(db, search, active_only, limit)
+
+
+@router.get("/catalogs/voucher-types", response_model=list[VoucherTypeResponse])
+def list_voucher_types(
+    search: str | None = _SEARCH,
+    active_only: bool = _ACTIVE_ONLY,
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """``c_TipoDeComprobante`` — ingreso, egreso, traslado, nómina o pago."""
+    return service.get_voucher_types(db, search, active_only)
+
+
+@router.get("/catalogs/payment-methods", response_model=list[PaymentMethodResponse])
+def list_payment_methods(
+    search: str | None = _SEARCH,
+    active_only: bool = _ACTIVE_ONLY,
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """``c_MetodoPago`` — PUE o PPD."""
+    return service.get_payment_methods(db, search, active_only)
+
+
+@router.get("/catalogs/tax-objects", response_model=list[TaxObjectResponse])
+def list_tax_objects(
+    search: str | None = _SEARCH,
+    active_only: bool = _ACTIVE_ONLY,
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """``c_ObjetoImp`` — si la partida es objeto de impuesto."""
+    return service.get_tax_objects(db, search, active_only)
+
+
+@router.get("/catalogs/cfdi-uses", response_model=list[CfdiUseResponse])
+def list_cfdi_uses(
+    search: str | None = _SEARCH,
+    active_only: bool = _ACTIVE_ONLY,
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """``c_UsoCFDI`` — uso que el receptor le dará al comprobante."""
+    return service.get_cfdi_uses(db, search, active_only)

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

@@ -0,0 +1,336 @@
+"""Datos semilla de los catálogos del SAT y su sincronización idempotente.
+
+Los catálogos viven aquí y no dentro de una migración concreta a propósito: cuando el
+SAT corrige una descripción o publica una clave nueva, basta editar estas listas y
+volver a correr :func:`sync_catalogs`, sin escribir una migración de esquema.
+
+Las tablas se describen con ``sa.Table`` ligeros sobre un ``MetaData`` propio (no con
+los modelos ORM) para que la migración pueda importar este módulo sin acoplarse a la
+definición ORM, que sigue evolucionando.
+"""
+
+import sqlalchemy as sa
+
+_metadata = sa.MetaData()
+
+
+def _catalog_table(name: str, *extra_columns: sa.Column) -> sa.Table:
+    """Tabla mínima de catálogo: las columnas que toca el upsert, nada más."""
+    return sa.Table(
+        name,
+        _metadata,
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column("code", sa.String, nullable=False),
+        sa.Column("description", sa.String),
+        sa.Column("is_active", sa.Boolean),
+        *extra_columns,
+        schema="sat",
+    )
+
+
+tax_regimes_table = _catalog_table(
+    "tax_regimes",
+    sa.Column("applies_to_individual", sa.Boolean),
+    sa.Column("applies_to_legal_entity", sa.Boolean),
+)
+taxes_table = _catalog_table(
+    "taxes",
+    sa.Column("is_withholding", sa.Boolean),
+    sa.Column("is_transferred", sa.Boolean),
+    sa.Column("is_local", sa.Boolean),
+)
+payment_forms_table = _catalog_table("payment_forms")
+units_of_measure_table = _catalog_table(
+    "units_of_measure",
+    sa.Column("name", sa.String),
+    sa.Column("symbol", sa.String),
+)
+products_services_table = _catalog_table("products_services")
+voucher_types_table = _catalog_table("voucher_types")
+payment_methods_table = _catalog_table("payment_methods")
+tax_objects_table = _catalog_table("tax_objects")
+cfdi_uses_table = _catalog_table("cfdi_uses")
+
+
+# ---------------------------------------------------------------------------
+# c_RegimenFiscal (CFDI 4.0)
+# ---------------------------------------------------------------------------
+
+def _regime(code: str, description: str, individual: bool, legal_entity: bool) -> dict:
+    return {
+        "code": code,
+        "description": description,
+        "applies_to_individual": individual,
+        "applies_to_legal_entity": legal_entity,
+        "is_active": True,
+    }
+
+
+TAX_REGIMES: list[dict] = [
+    _regime("601", "General de Ley Personas Morales", False, True),
+    _regime("603", "Personas Morales con Fines no Lucrativos", False, True),
+    _regime("605", "Sueldos y Salarios e Ingresos Asimilados a Salarios", True, False),
+    _regime("606", "Arrendamiento", True, False),
+    _regime("607", "Régimen de Enajenación o Adquisición de Bienes", True, False),
+    _regime("608", "Demás ingresos", True, False),
+    _regime("610", "Residentes en el Extranjero sin Establecimiento Permanente en México", True, True),
+    _regime("611", "Ingresos por Dividendos (socios y accionistas)", True, False),
+    _regime("612", "Personas Físicas con Actividades Empresariales y Profesionales", True, False),
+    _regime("614", "Ingresos por intereses", True, False),
+    _regime("615", "Régimen de los ingresos por obtención de premios", True, False),
+    _regime("616", "Sin obligaciones fiscales", True, False),
+    _regime("620", "Sociedades Cooperativas de Producción que optan por diferir sus ingresos", False, True),
+    _regime("621", "Incorporación Fiscal", True, False),
+    _regime("622", "Actividades Agrícolas, Ganaderas, Silvícolas y Pesqueras", False, True),
+    _regime("623", "Opcional para Grupos de Sociedades", False, True),
+    _regime("624", "Coordinados", False, True),
+    _regime("625", "Régimen de las Actividades Empresariales con ingresos a través de Plataformas Tecnológicas", True, False),
+    _regime("626", "Régimen Simplificado de Confianza", True, True),
+]
+
+
+# ---------------------------------------------------------------------------
+# c_Impuesto
+# ---------------------------------------------------------------------------
+# is_local queda en false para los tres: los impuestos locales (ISH y similares)
+# se declaran en el complemento "Impuestos Locales" con claves que no pertenecen
+# a c_Impuesto. No se siembran registros locales inventados.
+
+TAXES: list[dict] = [
+    {"code": "001", "description": "ISR", "is_withholding": True, "is_transferred": False, "is_local": False, "is_active": True},
+    {"code": "002", "description": "IVA", "is_withholding": True, "is_transferred": True, "is_local": False, "is_active": True},
+    {"code": "003", "description": "IEPS", "is_withholding": True, "is_transferred": True, "is_local": False, "is_active": True},
+]
+
+
+# ---------------------------------------------------------------------------
+# c_FormaPago
+# ---------------------------------------------------------------------------
+
+PAYMENT_FORMS: list[dict] = [
+    {"code": code, "description": description, "is_active": True}
+    for code, description in [
+        ("01", "Efectivo"),
+        ("02", "Cheque nominativo"),
+        ("03", "Transferencia electrónica de fondos"),
+        ("04", "Tarjeta de crédito"),
+        ("05", "Monedero electrónico"),
+        ("06", "Dinero electrónico"),
+        ("08", "Vales de despensa"),
+        ("12", "Dación en pago"),
+        ("13", "Pago por subrogación"),
+        ("14", "Pago por consignación"),
+        ("15", "Condonación"),
+        ("17", "Compensación"),
+        ("23", "Novación"),
+        ("24", "Confusión"),
+        ("25", "Remisión de deuda"),
+        ("26", "Prescripción o caducidad"),
+        ("27", "A satisfacción del acreedor"),
+        ("28", "Tarjeta de débito"),
+        ("29", "Tarjeta de servicios"),
+        ("30", "Aplicación de anticipos"),
+        ("31", "Intermediario pagos"),
+        ("99", "Por definir"),
+    ]
+]
+
+
+# ---------------------------------------------------------------------------
+# c_TipoDeComprobante
+# ---------------------------------------------------------------------------
+
+VOUCHER_TYPES: list[dict] = [
+    {"code": code, "description": description, "is_active": True}
+    for code, description in [
+        ("I", "Ingreso"),
+        ("E", "Egreso"),
+        ("T", "Traslado"),
+        ("N", "Nómina"),
+        ("P", "Pago"),
+    ]
+]
+
+
+# ---------------------------------------------------------------------------
+# c_MetodoPago
+# ---------------------------------------------------------------------------
+
+PAYMENT_METHODS: list[dict] = [
+    {"code": "PUE", "description": "Pago en una sola exhibición", "is_active": True},
+    {"code": "PPD", "description": "Pago en parcialidades o diferido", "is_active": True},
+]
+
+
+# ---------------------------------------------------------------------------
+# c_ObjetoImp
+# ---------------------------------------------------------------------------
+# Versiones posteriores del catálogo incorporan las claves 05–07; no se siembran
+# hasta que el área Fiscal confirme la versión vigente (ver PENDIENTE DECISIÓN).
+
+TAX_OBJECTS: list[dict] = [
+    {"code": "01", "description": "No objeto de impuesto", "is_active": True},
+    {"code": "02", "description": "Sí objeto de impuesto", "is_active": True},
+    {"code": "03", "description": "Sí objeto del impuesto y no obligado al desglose", "is_active": True},
+    {"code": "04", "description": "Sí objeto del impuesto y no causa impuesto", "is_active": True},
+]
+
+
+# ---------------------------------------------------------------------------
+# c_ClaveUnidad — subset operativo
+# ---------------------------------------------------------------------------
+# description queda en NULL: es la nota larga del catálogo, que aquí no aporta.
+
+UNITS_OF_MEASURE: list[dict] = [
+    {"code": code, "name": name, "symbol": symbol, "description": None, "is_active": True}
+    for code, name, symbol in [
+        ("H87", "Pieza", "pz"),
+        ("E48", "Unidad de servicio", None),
+        ("ACT", "Actividad", None),
+        ("C62", "Uno", None),
+        ("KGM", "Kilogramo", "kg"),
+        ("TNE", "Tonelada métrica", "t"),
+        ("GRM", "Gramo", "g"),
+        ("LTR", "Litro", "l"),
+        ("MTR", "Metro", "m"),
+        ("MTK", "Metro cuadrado", "m²"),
+        ("MTQ", "Metro cúbico", "m³"),
+        ("KMT", "Kilómetro", "km"),
+        ("CMT", "Centímetro", "cm"),
+        ("DAY", "Día", "d"),
+        ("HUR", "Hora", "h"),
+        ("MON", "Mes", None),
+        ("XBX", "Caja", None),
+        ("XPK", "Paquete", None),
+        ("XPX", "Paleta / tarima", None),
+        ("XLT", "Lote", None),
+        ("E51", "Trabajo", None),
+    ]
+]
+
+
+# ---------------------------------------------------------------------------
+# c_ClaveProdServ — subset de logística
+# ---------------------------------------------------------------------------
+# Subset inicial de c_ClaveProdServ para agente de carga — pendiente validación con
+# área Fiscal antes de producción. El catálogo completo son ~52,000 claves; aquí solo
+# se siembran las del giro. Si falta una clave para un caso de uso, se documenta como
+# PENDIENTE DECISIÓN: no se deduce ni se inventa.
+
+PRODUCTS_SERVICES: list[dict] = [
+    {"code": code, "description": description, "is_active": True}
+    for code, description in [
+        ("78101500", "Transporte de carga por carretera"),
+        ("78101600", "Transporte de carga marítimo"),
+        ("78101700", "Transporte de carga por ferrocarril"),
+        ("78101800", "Transporte de carga aérea"),
+        ("78102200", "Servicios postales de paqueteo y courrier"),
+        ("78121600", "Embalaje"),
+        ("78131600", "Almacenaje"),
+        ("78141500", "Servicios de planificación logística"),
+        ("78141600", "Servicios de expedición de fletes"),
+        ("84131500", "Seguros de vida, salud y accidentes / seguros de carga"),
+        ("80101500", "Servicios de consultoría de negocios y administración corporativa"),
+    ]
+]
+
+
+# ---------------------------------------------------------------------------
+# c_UsoCFDI
+# ---------------------------------------------------------------------------
+# Catálogo del uso que el receptor da al comprobante. Se siembran clave y
+# descripción; **no** se cargan las banderas de persona física/moral ni la
+# compatibilidad por régimen fiscal, porque esa matriz cambia entre versiones del
+# catálogo y equivocarla provoca rechazos al timbrar.
+#
+# Pendiente validación con área Fiscal antes de producción, igual que el subset de
+# c_ClaveProdServ.
+
+CFDI_USES: list[dict] = [
+    {"code": code, "description": description, "is_active": True}
+    for code, description in [
+        ("G01", "Adquisición de mercancías"),
+        ("G02", "Devoluciones, descuentos o bonificaciones"),
+        ("G03", "Gastos en general"),
+        ("I01", "Construcciones"),
+        ("I02", "Mobiliario y equipo de oficina por inversiones"),
+        ("I03", "Equipo de transporte"),
+        ("I04", "Equipo de cómputo y accesorios"),
+        ("I05", "Dados, troqueles, moldes, matrices y herramental"),
+        ("I06", "Comunicaciones telefónicas"),
+        ("I07", "Comunicaciones satelitales"),
+        ("I08", "Otra maquinaria y equipo"),
+        ("D01", "Honorarios médicos, dentales y gastos hospitalarios"),
+        ("D02", "Gastos médicos por incapacidad o discapacidad"),
+        ("D03", "Gastos funerales"),
+        ("D04", "Donativos"),
+        ("D05", "Intereses reales efectivamente pagados por créditos hipotecarios (casa habitación)"),
+        ("D06", "Aportaciones voluntarias al SAR"),
+        ("D07", "Primas por seguros de gastos médicos"),
+        ("D08", "Gastos de transportación escolar obligatoria"),
+        ("D09", "Depósitos en cuentas para el ahorro, primas que tengan como base planes de pensiones"),
+        ("D10", "Pagos por servicios educativos (colegiaturas)"),
+        ("S01", "Sin efectos fiscales"),
+        ("CP01", "Pagos"),
+        ("CN01", "Nómina"),
+    ]
+]
+
+
+# Orden estable de sincronización: (tabla, filas).
+CATALOGS: list[tuple[sa.Table, list[dict]]] = [
+    (tax_regimes_table, TAX_REGIMES),
+    (taxes_table, TAXES),
+    (payment_forms_table, PAYMENT_FORMS),
+    (units_of_measure_table, UNITS_OF_MEASURE),
+    (products_services_table, PRODUCTS_SERVICES),
+    (voucher_types_table, VOUCHER_TYPES),
+    (payment_methods_table, PAYMENT_METHODS),
+    (tax_objects_table, TAX_OBJECTS),
+    (cfdi_uses_table, CFDI_USES),
+]
+
+
+def sync_catalogs(connection) -> dict[str, int]:
+    """Sincroniza los catálogos del SAT contra la base, de forma idempotente.
+
+    Inserta las claves que faltan y actualiza descripción y banderas de las que ya
+    existen. **Nunca borra**: una clave retirada por el SAT se desactiva a mano para
+    no romper los CFDI históricos que la referencian.
+
+    Devuelve un resumen ``{"sat.tabla": filas_insertadas}`` útil para la bitácora de
+    la migración.
+
+    Los catálogos cuya tabla todavía no existe se omiten: al correr el historial de
+    migraciones desde cero, una migración antigua invoca esta misma función cuando los
+    catálogos agregados después aún no se han creado. Cada uno se siembra en la
+    migración que lo crea.
+
+    Se usa contra el ``connection`` que da ``op.get_bind()`` en Alembic, o contra la
+    conexión de una sesión en pruebas.
+    """
+    inspector = sa.inspect(connection)
+    # La inspección no aplica el schema_translate_map (las pruebas mapean sat -> None
+    # sobre SQLite), así que se resuelve el schema efectivo a mano.
+    schema_map = connection.get_execution_options().get("schema_translate_map") or {}
+
+    inserted: dict[str, int] = {}
+    for table, rows in CATALOGS:
+        effective_schema = schema_map.get(table.schema, table.schema)
+        if not inspector.has_table(table.name, schema=effective_schema):
+            continue
+        key = f"sat.{table.name}"
+        inserted[key] = 0
+        for row in rows:
+            existing = connection.execute(
+                sa.select(table.c.id).where(table.c.code == row["code"])
+            ).scalar()
+            values = {k: v for k, v in row.items() if k != "code"}
+            if existing is None:
+                connection.execute(table.insert().values(code=row["code"], **values))
+                inserted[key] += 1
+            else:
+                connection.execute(
+                    table.update().where(table.c.id == existing).values(**values)
+                )
+    return inserted

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

@@ -0,0 +1,106 @@
+"""Consultas de los catálogos del SAT.
+
+Son globales (sin tenant_id / company_id) y de solo lectura: aquí no hay altas,
+cambios ni bajas, únicamente búsqueda para llenar los selectores de captura.
+"""
+
+from sqlalchemy import or_
+from sqlalchemy.orm import Session
+
+from .models import (
+    CfdiUse,
+    PaymentForm,
+    PaymentMethod,
+    ProductService,
+    Tax,
+    TaxObject,
+    TaxRegime,
+    UnitOfMeasure,
+    VoucherType,
+)
+
+# Catálogos que además del código y la descripción buscan por nombre corto.
+_SEARCHABLE_EXTRA_FIELDS = {UnitOfMeasure: ("name",)}
+
+
+def search_catalog(
+    db: Session,
+    model,
+    search: str | None = None,
+    active_only: bool = True,
+    limit: int | None = None,
+) -> list:
+    """Devuelve las claves de un catálogo, filtradas por texto libre.
+
+    ``search`` compara contra la clave o la descripción sin distinguir mayúsculas.
+    """
+    q = db.query(model)
+    if active_only:
+        q = q.filter(model.is_active.is_(True))
+    if search:
+        term = f"%{search.strip()}%"
+        fields = [model.code, model.description]
+        for extra in _SEARCHABLE_EXTRA_FIELDS.get(model, ()):
+            fields.append(getattr(model, extra))
+        q = q.filter(or_(*[f.ilike(term) for f in fields]))
+    q = q.order_by(model.code.asc())
+    if limit is not None:
+        q = q.limit(limit)
+    return q.all()
+
+
+def get_tax_regimes(
+    db: Session,
+    search: str | None = None,
+    active_only: bool = True,
+    person_type: str | None = None,
+) -> list[TaxRegime]:
+    """``c_RegimenFiscal``, opcionalmente acotado al tipo de persona.
+
+    ``person_type='fisica'`` deja solo los regímenes que puede usar una persona
+    física; ``'moral'``, los de persona moral.
+    """
+    q = db.query(TaxRegime)
+    if active_only:
+        q = q.filter(TaxRegime.is_active.is_(True))
+    if search:
+        term = f"%{search.strip()}%"
+        q = q.filter(or_(TaxRegime.code.ilike(term), TaxRegime.description.ilike(term)))
+    if person_type == "fisica":
+        q = q.filter(TaxRegime.applies_to_individual.is_(True))
+    elif person_type == "moral":
+        q = q.filter(TaxRegime.applies_to_legal_entity.is_(True))
+    return q.order_by(TaxRegime.code.asc()).all()
+
+
+def get_taxes(db: Session, search=None, active_only=True) -> list[Tax]:
+    return search_catalog(db, Tax, search, active_only)
+
+
+def get_payment_forms(db: Session, search=None, active_only=True) -> list[PaymentForm]:
+    return search_catalog(db, PaymentForm, search, active_only)
+
+
+def get_units_of_measure(db: Session, search=None, active_only=True) -> list[UnitOfMeasure]:
+    return search_catalog(db, UnitOfMeasure, search, active_only)
+
+
+def get_products_services(db: Session, search=None, active_only=True, limit=50) -> list[ProductService]:
+    """``c_ClaveProdServ``. Va paginado porque alimenta un autocompletado."""
+    return search_catalog(db, ProductService, search, active_only, limit=limit)
+
+
+def get_voucher_types(db: Session, search=None, active_only=True) -> list[VoucherType]:
+    return search_catalog(db, VoucherType, search, active_only)
+
+
+def get_payment_methods(db: Session, search=None, active_only=True) -> list[PaymentMethod]:
+    return search_catalog(db, PaymentMethod, search, active_only)
+
+
+def get_tax_objects(db: Session, search=None, active_only=True) -> list[TaxObject]:
+    return search_catalog(db, TaxObject, search, active_only)
+
+
+def get_cfdi_uses(db: Session, search=None, active_only=True) -> list[CfdiUse]:
+    return search_catalog(db, CfdiUse, search, active_only)

backend/api/v1/modules/fin/concepts/__init__.py

@@ -0,0 +1 @@
+"""Catálogo de conceptos de facturación por empresa."""

backend/api/v1/modules/fin/concepts/dto.py

@@ -0,0 +1,55 @@
+"""Esquemas del catálogo de conceptos de facturación."""
+
+from datetime import datetime
+from decimal import Decimal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from ..catalogs.dto import ProductServiceResponse, TaxObjectResponse, UnitOfMeasureResponse
+
+
+class ConceptBase(BaseModel):
+    code: str = Field(..., min_length=1, max_length=40, description="Clave interna del concepto")
+    description: str = Field(..., min_length=1, max_length=500)
+    product_service_id: int = Field(..., description="Clave ProdServ del SAT (1:1 por empresa)")
+    unit_of_measure_id: int | None = None
+    tax_object_id: int | None = None
+    unit_price: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=2)
+    currency: str = Field("MXN", min_length=3, max_length=3)
+    is_active: bool = True
+    notes: str | None = None
+
+
+class ConceptCreate(ConceptBase):
+    pass
+
+
+class ConceptUpdate(BaseModel):
+    """Actualización parcial: solo se tocan los campos enviados."""
+
+    code: str | None = Field(None, min_length=1, max_length=40)
+    description: str | None = Field(None, min_length=1, max_length=500)
+    product_service_id: int | None = None
+    unit_of_measure_id: int | None = None
+    tax_object_id: int | None = None
+    unit_price: Decimal | None = Field(None, ge=0, max_digits=14, decimal_places=2)
+    currency: str | None = Field(None, min_length=3, max_length=3)
+    is_active: bool | None = None
+    notes: str | None = None
+
+
+class ConceptResponse(ConceptBase):
+    """Incluye los objetos del catálogo del SAT ya resueltos, para evitar N+1 en la UI."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    tenant_id: int
+    company_id: int
+    product_service: ProductServiceResponse | None = None
+    unit_of_measure: UnitOfMeasureResponse | None = None
+    tax_object: TaxObjectResponse | None = None
+    created_by: str | None = None
+    updated_by: str | None = None
+    created_at: datetime
+    updated_at: datetime

backend/api/v1/modules/fin/concepts/models.py

@@ -0,0 +1,67 @@
+"""Catálogo de conceptos de facturación — ``fin.concepts``.
+
+A diferencia de los catálogos del SAT, este es **propio de cada empresa**: cada
+concepto que la empresa factura (flete internacional, despacho, almacenaje…) se
+registra una vez y queda amarrado a la clave de producto/servicio del SAT que le
+corresponde.
+
+La relación con ``sat.products_services`` es **1:1 por empresa**: si dos conceptos
+compartieran la misma clave ProdServ, al timbrar no habría forma de saber cuál
+descripción corresponde a la clave, así que la unicidad se garantiza por índice y se
+valida además en el service para devolver un 409 con mensaje entendible.
+"""
+
+from sqlalchemy import Boolean, ForeignKey, Index, Integer, Numeric, String, Text, text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
+from core.database import Base
+
+from ..catalogs.models import ProductService, TaxObject, UnitOfMeasure  # noqa: F401  (resuelve las relaciones)
+
+# Los índices son parciales (``WHERE deleted_at IS NULL``): un concepto dado de baja
+# lógica libera su clave y su código para uno nuevo.
+_ALIVE = text("deleted_at IS NULL")
+
+
+class Concept(Base, TenantScopedMixin, TimestampMixin):
+    """Concepto facturable de una empresa, ligado a una clave ProdServ del SAT."""
+
+    __tablename__ = "concepts"
+    __table_args__ = (
+        Index(
+            "uq_fin_concepts_code",
+            "tenant_id", "company_id", "code",
+            unique=True, postgresql_where=_ALIVE, sqlite_where=_ALIVE,
+        ),
+        Index(
+            "uq_fin_concepts_product_service",
+            "tenant_id", "company_id", "product_service_id",
+            unique=True, postgresql_where=_ALIVE, sqlite_where=_ALIVE,
+        ),
+        {"schema": "fin"},
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    code: Mapped[str] = mapped_column(String(40), nullable=False)  # clave interna del concepto
+    description: Mapped[str] = mapped_column(String(500), nullable=False)
+    product_service_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("sat.products_services.id"), nullable=False, index=True
+    )
+    unit_of_measure_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("sat.units_of_measure.id"), nullable=True
+    )
+    tax_object_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("sat.tax_objects.id"), nullable=True
+    )
+    unit_price: Mapped[float | None] = mapped_column(Numeric(14, 2), nullable=True)
+    currency: Mapped[str] = mapped_column(String(3), nullable=False, server_default=text("'MXN'"))
+    is_active: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("true"))
+    notes: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    updated_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
+
+    # Cargadas con selectinload para que el listado no dispare N+1 consultas.
+    product_service: Mapped["ProductService"] = relationship("ProductService", lazy="selectin")
+    unit_of_measure: Mapped["UnitOfMeasure | None"] = relationship("UnitOfMeasure", lazy="selectin")
+    tax_object: Mapped["TaxObject | None"] = relationship("TaxObject", lazy="selectin")

backend/api/v1/modules/fin/concepts/routes.py

@@ -0,0 +1,96 @@
+"""Endpoints del catálogo de conceptos de facturación (CRUD por empresa)."""
+
+from fastapi import APIRouter, Depends, Query, status
+from sqlalchemy.orm import Session
+
+from api.v1.modules.core.permissions.dependencies import PermissionChecker
+from core.database import get_core_db
+from core.security import get_current_user
+
+from . import service
+from .dto import ConceptCreate, ConceptResponse, ConceptUpdate
+
+router = APIRouter()
+
+
+def _uid(current_user: dict) -> str | None:
+    return current_user.get("sub") or current_user.get("id")
+
+
+@router.get(
+    "/concepts",
+    response_model=list[ConceptResponse],
+    dependencies=[Depends(PermissionChecker(["fin.concept.view"]))],
+)
+def list_concepts(
+    company_id: int = Query(..., description="Company ID"),
+    search: str | None = Query(None, description="Búsqueda por clave o descripción"),
+    active_only: bool | None = Query(None, description="Filtra por conceptos activos o inactivos"),
+    product_service_id: int | None = Query(None, description="Filtra por clave ProdServ del SAT"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    return service.get_concepts(
+        db, current_user["tenant_id"], company_id, search, active_only, product_service_id
+    )
+
+
+@router.get(
+    "/concepts/{concept_id}",
+    response_model=ConceptResponse,
+    dependencies=[Depends(PermissionChecker(["fin.concept.view"]))],
+)
+def get_concept(
+    concept_id: int,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    return service.get_concept(db, concept_id, current_user["tenant_id"], company_id)
+
+
+@router.post(
+    "/concepts",
+    response_model=ConceptResponse,
+    status_code=status.HTTP_201_CREATED,
+    dependencies=[Depends(PermissionChecker(["fin.concept.create"]))],
+)
+def create_concept(
+    payload: ConceptCreate,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    return service.create_concept(db, payload, current_user["tenant_id"], company_id, _uid(current_user))
+
+
+@router.patch(
+    "/concepts/{concept_id}",
+    response_model=ConceptResponse,
+    dependencies=[Depends(PermissionChecker(["fin.concept.edit"]))],
+)
+def update_concept(
+    concept_id: int,
+    payload: ConceptUpdate,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    return service.update_concept(
+        db, concept_id, payload, current_user["tenant_id"], company_id, _uid(current_user)
+    )
+
+
+@router.delete(
+    "/concepts/{concept_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+    dependencies=[Depends(PermissionChecker(["fin.concept.delete"]))],
+)
+def delete_concept(
+    concept_id: int,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Baja lógica del concepto (``deleted_at``)."""
+    service.delete_concept(db, concept_id, current_user["tenant_id"], company_id)

backend/api/v1/modules/fin/concepts/service.py

@@ -0,0 +1,146 @@
+"""Lógica del catálogo de conceptos de facturación.
+
+Todas las consultas filtran por ``tenant_id``, ``company_id`` y ``deleted_at IS NULL``:
+el catálogo es privado de cada empresa dentro de cada tenant.
+"""
+
+from datetime import datetime, timezone
+
+from fastapi import HTTPException, status
+from sqlalchemy import or_
+from sqlalchemy.orm import Session
+
+from ..catalogs.models import ProductService, TaxObject, UnitOfMeasure
+from .dto import ConceptCreate, ConceptUpdate
+from .models import Concept
+
+
+def _check_sat_refs(db: Session, data: dict) -> None:
+    """Verifica que las claves del SAT referidas existan antes de guardar."""
+    for field, model, msg in [
+        ("product_service_id", ProductService, "La clave de producto/servicio del SAT no existe"),
+        ("unit_of_measure_id", UnitOfMeasure, "La unidad de medida del SAT no existe"),
+        ("tax_object_id", TaxObject, "El objeto de impuesto del SAT no existe"),
+    ]:
+        value = data.get(field)
+        if field in data and value is not None:
+            if db.query(model.id).filter(model.id == value).first() is None:
+                raise HTTPException(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=msg)
+
+
+def _check_unique(
+    db: Session,
+    tenant_id: int,
+    company_id: int,
+    code: str | None,
+    product_service_id: int | None,
+    exclude_id: int | None = None,
+) -> None:
+    """Aplica en el service las mismas reglas que los índices únicos parciales.
+
+    Sin esto el conflicto llegaría al cliente como un IntegrityError crudo; aquí se
+    traduce a un 409 con mensaje en español.
+    """
+    base = db.query(Concept).filter(
+        Concept.tenant_id == tenant_id,
+        Concept.company_id == company_id,
+        Concept.deleted_at.is_(None),
+    )
+    if exclude_id is not None:
+        base = base.filter(Concept.id != exclude_id)
+
+    if code is not None and base.filter(Concept.code == code).first() is not None:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=f"Ya existe un concepto con la clave '{code}' en esta empresa",
+        )
+    # Regla 1:1 — una clave ProdServ no puede repetirse entre conceptos de la empresa.
+    if product_service_id is not None and base.filter(
+        Concept.product_service_id == product_service_id
+    ).first() is not None:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="La clave de producto/servicio del SAT ya está asignada a otro concepto de esta empresa",
+        )
+
+
+def get_concepts(
+    db: Session,
+    tenant_id: int,
+    company_id: int,
+    search: str | None = None,
+    active_only: bool | None = None,
+    product_service_id: int | None = None,
+) -> list[Concept]:
+    q = db.query(Concept).filter(
+        Concept.tenant_id == tenant_id,
+        Concept.company_id == company_id,
+        Concept.deleted_at.is_(None),
+    )
+    if active_only is not None:
+        q = q.filter(Concept.is_active.is_(active_only))
+    if product_service_id is not None:
+        q = q.filter(Concept.product_service_id == product_service_id)
+    if search:
+        term = f"%{search.strip()}%"
+        q = q.filter(or_(Concept.code.ilike(term), Concept.description.ilike(term)))
+    return q.order_by(Concept.code.asc()).all()
+
+
+def get_concept(db: Session, concept_id: int, tenant_id: int, company_id: int) -> Concept:
+    obj = db.query(Concept).filter(
+        Concept.id == concept_id,
+        Concept.tenant_id == tenant_id,
+        Concept.company_id == company_id,
+        Concept.deleted_at.is_(None),
+    ).first()
+    if not obj:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Concepto no encontrado")
+    return obj
+
+
+def create_concept(
+    db: Session, payload: ConceptCreate, tenant_id: int, company_id: int, user_id: str | None = None
+) -> Concept:
+    data = payload.model_dump()
+    _check_sat_refs(db, data)
+    _check_unique(db, tenant_id, company_id, data["code"], data["product_service_id"])
+    obj = Concept(**data, tenant_id=tenant_id, company_id=company_id, created_by=user_id, updated_by=user_id)
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def update_concept(
+    db: Session,
+    concept_id: int,
+    payload: ConceptUpdate,
+    tenant_id: int,
+    company_id: int,
+    user_id: str | None = None,
+) -> Concept:
+    obj = get_concept(db, concept_id, tenant_id, company_id)
+    data = payload.model_dump(exclude_unset=True)
+    _check_sat_refs(db, data)
+    _check_unique(
+        db,
+        tenant_id,
+        company_id,
+        data.get("code"),
+        data.get("product_service_id"),
+        exclude_id=obj.id,
+    )
+    for field, value in data.items():
+        setattr(obj, field, value)
+    obj.updated_by = user_id
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def delete_concept(db: Session, concept_id: int, tenant_id: int, company_id: int) -> None:
+    """Baja lógica: libera la clave ProdServ y el código para un concepto nuevo."""
+    obj = get_concept(db, concept_id, tenant_id, company_id)
+    obj.deleted_at = datetime.now(timezone.utc)
+    db.commit()

backend/api/v1/modules/fin/invoices/dto.py

@@ -1,5 +1,6 @@
 from datetime import date, datetime
 from decimal import Decimal
+from typing import Literal
 
 from pydantic import BaseModel, ConfigDict, Field, computed_field
 
@@ -10,7 +11,16 @@ class InvoiceClientReviewInput(BaseModel):
     notes: str | None = None
 
 
-class InvoiceItemBase(BaseModel):
+class InvoiceItemSatFields(BaseModel):
+    """Claves fiscales de la partida. Opcionales: las facturas previas no las tienen."""
+
+    concept_id: int | None = None
+    product_service_id: int | None = None
+    unit_of_measure_id: int | None = None
+    tax_object_id: int | None = None
+
+
+class InvoiceItemBase(InvoiceItemSatFields):
     concept: str = Field(..., max_length=60)
     description: str | None = Field(None, max_length=255)
     quantity: Decimal = Field(Decimal(1), ge=0, max_digits=12, decimal_places=2)
@@ -19,9 +29,11 @@ class InvoiceItemBase(BaseModel):
 
 class InvoiceItemCreate(InvoiceItemBase):
     invoice_id: int
+    # Opcional solo si viene concept_id: el service copia la descripción del concepto.
+    concept: str | None = Field(None, max_length=60)
 
 
-class InvoiceItemUpdate(BaseModel):
+class InvoiceItemUpdate(InvoiceItemSatFields):
     concept: str | None = Field(None, max_length=60)
     description: str | None = Field(None, max_length=255)
     quantity: Decimal | None = Field(None, ge=0, max_digits=12, decimal_places=2)
@@ -76,6 +88,14 @@ class InvoiceBase(BaseModel):
     bank_info: str | None = None
     notes: str | None = None
     owner_user_id: str | None = Field(None, max_length=64)
+    # ----- Claves fiscales del CFDI (opcionales mientras no se timbre) -----
+    voucher_type_id: int | None = None
+    payment_form_id: int | None = None
+    payment_method_id: int | None = None
+    expedition_zip_code: str | None = Field(None, max_length=5)
+    # Modo de timbrado de ESTA factura. 'produccion' emite un CFDI con validez fiscal real
+    # ante el SAT; por eso el default es 'pruebas' y subirlo es una decisión explícita.
+    stamping_mode: Literal["pruebas", "produccion"] = "pruebas"
 
 
 class InvoiceCreate(InvoiceBase):
@@ -94,12 +114,18 @@ class InvoiceUpdate(BaseModel):
     bank_info: str | None = None
     notes: str | None = None
     owner_user_id: str | None = Field(None, max_length=64)
+    voucher_type_id: int | None = None
+    payment_form_id: int | None = None
+    payment_method_id: int | None = None
+    expedition_zip_code: str | None = Field(None, max_length=5)
+    stamping_mode: Literal["pruebas", "produccion"] | None = None
 
 
 class InvoiceResponse(InvoiceBase):
     model_config = ConfigDict(from_attributes=True)
 
     id: int
+    case_id: int | None = None
     status: str
     subtotal: Decimal
     tax_amount: Decimal
@@ -119,3 +145,26 @@ class InvoiceResponse(InvoiceBase):
     company_id: int
     created_at: datetime
     updated_at: datetime
+
+
+class InvoiceItemTaxInput(BaseModel):
+    """Alta o ajuste de un impuesto de la partida.
+
+    El importe no se recibe: se calcula de la base de la partida por la tasa, para que no
+    pueda quedar un desglose que no cuadre con el importe del concepto.
+    """
+
+    tax_id: int
+    rate: Decimal = Field(..., ge=0, le=1, max_digits=8, decimal_places=6)
+    is_withholding: bool = False
+
+
+class InvoiceItemTaxResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    invoice_item_id: int
+    tax_id: int
+    is_withholding: bool
+    rate: Decimal | None = None
+    amount: Decimal

backend/api/v1/modules/fin/invoices/models.py

@@ -1,11 +1,22 @@
 from datetime import date, datetime
 
-from sqlalchemy import Boolean, Date, DateTime, ForeignKey, Integer, Numeric, String, Text, text
+from sqlalchemy import Boolean, Date, DateTime, ForeignKey, Index, Integer, Numeric, String, Text, text
 from sqlalchemy.orm import Mapped, mapped_column
 
 from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
 from core.database import Base
 
+from ..catalogs.models import (  # noqa: F401  (registra los catálogos SAT referidos por las FK)
+    PaymentForm,
+    PaymentMethod,
+    ProductService,
+    Tax,
+    TaxObject,
+    UnitOfMeasure,
+    VoucherType,
+)
+from ..concepts.models import Concept  # noqa: F401
+
 
 class Invoice(Base, TenantScopedMixin, TimestampMixin):
     """Factura (Diagrama 4). Integra los costos de la operación para cobro al cliente."""
@@ -15,6 +26,7 @@ class Invoice(Base, TenantScopedMixin, TimestampMixin):
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     reference: Mapped[str | None] = mapped_column(String(40), nullable=True, index=True)  # folio
+    case_id: Mapped[int | None] = mapped_column(Integer, ForeignKey("crm.cases.id"), nullable=True, index=True)  # expediente
     shipment_id: Mapped[int | None] = mapped_column(
         Integer, ForeignKey("ops.shipments.id"), nullable=True, index=True
     )
@@ -50,6 +62,25 @@ class Invoice(Base, TenantScopedMixin, TimestampMixin):
     owner_user_id: Mapped[str | None] = mapped_column(String(64), nullable=True, index=True)
     created_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
     updated_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    # ----- Datos fiscales del CFDI (catálogos SAT) -----
+    # Nullables: las facturas emitidas antes de existir los catálogos no los tienen.
+    voucher_type_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("sat.voucher_types.id"), nullable=True
+    )
+    payment_form_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("sat.payment_forms.id"), nullable=True
+    )
+    payment_method_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("sat.payment_methods.id"), nullable=True
+    )
+    expedition_zip_code: Mapped[str | None] = mapped_column(String(5), nullable=True)
+    # ----- Modo de timbrado (por factura, no por entorno) -----
+    # 'pruebas' | 'produccion'. Determina el host del PAC y, con él, si el comprobante tiene
+    # validez fiscal ante el SAT. Inmutable una vez que la factura tiene un timbre exitoso:
+    # cambiarlo después falsearía el registro de con qué intención se emitió.
+    stamping_mode: Mapped[str] = mapped_column(
+        String(12), nullable=False, server_default=text("'pruebas'")
+    )
 
 
 class InvoiceItem(Base, TenantScopedMixin, TimestampMixin):
@@ -62,10 +93,54 @@ class InvoiceItem(Base, TenantScopedMixin, TimestampMixin):
     invoice_id: Mapped[int] = mapped_column(
         Integer, ForeignKey("fin.invoices.id"), nullable=False, index=True
     )
+    # Texto libre histórico: lo consume el PDF actual y se conserva obligatorio.
     concept: Mapped[str] = mapped_column(String(60), nullable=False)
     description: Mapped[str | None] = mapped_column(String(255), nullable=True)
     quantity: Mapped[float] = mapped_column(Numeric(12, 2), nullable=False, server_default=text("1"))
     unit_amount: Mapped[float] = mapped_column(Numeric(14, 2), nullable=False, server_default=text("0"))
+    # ----- Datos fiscales de la partida (catálogos SAT) -----
+    concept_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("fin.concepts.id"), nullable=True, index=True
+    )
+    product_service_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("sat.products_services.id"), nullable=True
+    )
+    unit_of_measure_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("sat.units_of_measure.id"), nullable=True
+    )
+    tax_object_id: Mapped[int | None] = mapped_column(
+        Integer, ForeignKey("sat.tax_objects.id"), nullable=True
+    )
+
+
+class InvoiceItemTax(Base, TenantScopedMixin, TimestampMixin):
+    """Impuesto trasladado o retenido de una partida de la factura.
+
+    Es captura de detalle fiscal para el futuro CFDI: **no** interviene en el cálculo
+    de subtotal/IVA/total de la factura, que sigue saliendo de ``invoices.tax_rate``.
+    """
+
+    __tablename__ = "invoice_item_taxes"
+    __table_args__ = (
+        Index(
+            "uq_fin_invoice_item_taxes",
+            "invoice_item_id", "tax_id", "is_withholding",
+            unique=True,
+            postgresql_where=text("deleted_at IS NULL"),
+            sqlite_where=text("deleted_at IS NULL"),
+        ),
+        {"schema": "fin"},
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    invoice_item_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("fin.invoice_items.id"), nullable=False, index=True
+    )
+    tax_id: Mapped[int] = mapped_column(Integer, ForeignKey("sat.taxes.id"), nullable=False)
+    # false = trasladado (se cobra al cliente); true = retenido
+    is_withholding: Mapped[bool] = mapped_column(Boolean, nullable=False, server_default=text("false"))
+    rate: Mapped[float | None] = mapped_column(Numeric(8, 6), nullable=True)  # p. ej. 0.160000
+    amount: Mapped[float] = mapped_column(Numeric(14, 2), nullable=False, server_default=text("0"))
 
 
 class Payment(Base, TenantScopedMixin, TimestampMixin):

backend/api/v1/modules/fin/invoices/routes.py

@@ -4,12 +4,14 @@ from sqlalchemy.orm import Session
 from core.database import get_core_db
 from core.security import get_current_user
 
-from . import service
+from . import service, taxes_service
 from .dto import (
     InvoiceClientReviewInput,
     InvoiceCreate,
     InvoiceItemCreate,
     InvoiceItemResponse,
+    InvoiceItemTaxInput,
+    InvoiceItemTaxResponse,
     InvoiceItemUpdate,
     InvoiceResponse,
     InvoiceUpdate,
@@ -132,3 +134,26 @@ def create_payment(payload: PaymentCreate, company_id: int = Query(...), current
 @router.delete("/payments/{payment_id}", status_code=status.HTTP_204_NO_CONTENT)
 def delete_payment(payment_id: int, company_id: int = Query(...), current_user: dict = Depends(get_current_user), db: Session = Depends(get_core_db)):
     service.delete_payment(db, payment_id, current_user["tenant_id"], company_id)
+
+
+# ----- Impuestos por partida -----
+# El traslado de IVA se deriva del % de la factura; estos endpoints son para ajustarlo
+# (retenciones, tasas distintas) cuando el caso lo pide.
+
+@router.get("/invoice-items/{item_id}/taxes", response_model=list[InvoiceItemTaxResponse])
+def list_item_taxes(item_id: int, company_id: int = Query(...), current_user: dict = Depends(get_current_user), db: Session = Depends(get_core_db)):
+    return taxes_service.list_item_taxes(db, item_id, current_user["tenant_id"], company_id)
+
+
+@router.put("/invoice-items/{item_id}/taxes", response_model=InvoiceItemTaxResponse)
+def set_item_tax(item_id: int, payload: InvoiceItemTaxInput, company_id: int = Query(...), current_user: dict = Depends(get_current_user), db: Session = Depends(get_core_db)):
+    """Alta o ajuste. La combinación impuesto + traslado/retención es única por partida."""
+    return taxes_service.set_item_tax(
+        db, item_id, payload.tax_id, payload.rate, payload.is_withholding,
+        current_user["tenant_id"], company_id,
+    )
+
+
+@router.delete("/invoice-item-taxes/{tax_row_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_item_tax(tax_row_id: int, company_id: int = Query(...), current_user: dict = Depends(get_current_user), db: Session = Depends(get_core_db)):
+    taxes_service.delete_item_tax(db, tax_row_id, current_user["tenant_id"], company_id)

backend/api/v1/modules/fin/invoices/service.py

@@ -6,9 +6,12 @@ from sqlalchemy import func
 from sqlalchemy.orm import Session
 
 from api.v1.modules.crm.accounts.models import Account
+from api.v1.modules.crm.cases import service as cases_service
+from api.v1.modules.crm.common.folios import next_folio
 from api.v1.modules.crm.quotes.models import Quote, QuoteItem
 from api.v1.modules.ops.shipments.models import Shipment
 
+from ..concepts.models import Concept
 from .dto import (
     InvoiceClientReviewInput,
     InvoiceCreate,
@@ -17,6 +20,7 @@ from .dto import (
     InvoiceUpdate,
     PaymentCreate,
 )
+from . import taxes_service
 from .models import Invoice, InvoiceItem, Payment
 from .pdf import build_invoice_pdf
 
@@ -95,6 +99,15 @@ def create_invoice(db, payload: InvoiceCreate, tenant_id, company_id, user_id=No
     data = payload.model_dump()
     _validate_refs(db, data, tenant_id, company_id)
     obj = Invoice(**data, tenant_id=tenant_id, company_id=company_id, created_by=user_id, updated_by=user_id)
+    # Folio F... auto-generado (mensual) si no viene uno explícito
+    if not obj.reference:
+        obj.reference = next_folio(db, tenant_id, company_id, "F", None, with_direction=False)
+    # Expediente heredado del embarque (si la factura se genera de uno)
+    if obj.shipment_id and not obj.case_id:
+        sh = db.query(Shipment).filter(Shipment.id == obj.shipment_id).first()
+        if sh:
+            obj.case_id = sh.case_id
+    cases_service.advance_stage(db, obj.case_id, "facturacion")
     db.add(obj)
     db.flush()
     _recompute(db, obj)
@@ -107,16 +120,43 @@ def update_invoice(db, invoice_id, payload: InvoiceUpdate, tenant_id, company_id
     obj = get_invoice(db, invoice_id, tenant_id, company_id)
     data = payload.model_dump(exclude_unset=True)
     _validate_refs(db, data, tenant_id, company_id)
+    _reject_stamping_mode_change(db, obj, data, tenant_id, company_id)
     for f, v in data.items():
         setattr(obj, f, v)
     obj.updated_by = user_id
     db.flush()
+    if "tax_rate" in data:
+        # El % global es la fuente del IVA derivado de cada partida: si cambia, se propaga.
+        taxes_service.sync_invoice_taxes(db, obj)
     _recompute(db, obj)  # tax_rate pudo cambiar
     db.commit()
     db.refresh(obj)
     return obj
 
 
+def _reject_stamping_mode_change(db, obj: Invoice, data: dict, tenant_id, company_id) -> None:
+    """El modo de timbrado es inmutable una vez que la factura tiene timbre.
+
+    Cambiarlo después falsearía el registro de con qué intención se emitió el comprobante: el
+    CFDI ya existe ante el SAT con la validez que le dio el entorno donde se timbró, y ese
+    hecho no se edita.
+    """
+    nuevo = data.get("stamping_mode")
+    if nuevo is None or nuevo == obj.stamping_mode:
+        return
+    # Import diferido: stamping importa invoices, y al revés sería circular.
+    from ..stamping.service import get_stamp  # noqa: PLC0415
+
+    if get_stamp(db, obj.id, tenant_id, company_id):
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=(
+                "La factura ya está timbrada: el modo de timbrado no se puede cambiar "
+                f"(sigue en {obj.stamping_mode!r})."
+            ),
+        )
+
+
 def delete_invoice(db, invoice_id, tenant_id, company_id) -> None:
     obj = get_invoice(db, invoice_id, tenant_id, company_id)
     obj.deleted_at = datetime.now(timezone.utc)
@@ -281,6 +321,7 @@ def generate_from_shipment(db, shipment_id, tenant_id, company_id, user_id=None)
 
     invoice = Invoice(
         reference=shipment.reference,
+        case_id=shipment.case_id,
         shipment_id=shipment.id,
         quote_id=shipment.quote_id,
         account_id=shipment.account_id,
@@ -294,6 +335,7 @@ def generate_from_shipment(db, shipment_id, tenant_id, company_id, user_id=None)
     )
     db.add(invoice)
     db.flush()
+    cases_service.advance_stage(db, shipment.case_id, "facturacion")
 
     if quote:
         q_items = db.query(QuoteItem).filter(QuoteItem.quote_id == quote.id, QuoteItem.deleted_at.is_(None)).all()
@@ -331,11 +373,53 @@ def _get_item(db, item_id, tenant_id, company_id) -> InvoiceItem:
     return obj
 
 
+# Claves del SAT que la partida hereda del concepto del catálogo cuando no se envían.
+_CONCEPT_INHERITED_FIELDS = ("product_service_id", "unit_of_measure_id", "tax_object_id")
+
+
+def _resolve_item_concept(db, data: dict, tenant_id, company_id) -> None:
+    """Completa la partida a partir del concepto del catálogo.
+
+    Hereda dos cosas cuando el cliente no las manda:
+
+    - ``concept``: el PDF de la factura sigue leyendo esa columna de texto libre, así
+      que ahí va la descripción del concepto (recortada al largo de la columna).
+    - Las claves fiscales (``product_service_id``, ``unit_of_measure_id``,
+      ``tax_object_id``): sin ellas la partida capturada por catálogo quedaría
+      incompleta para el CFDI. Lo que el cliente sí envía manda sobre el catálogo,
+      para poder facturar una partida con una unidad distinta a la del concepto.
+    """
+    concept_id = data.get("concept_id")
+    if concept_id is not None:
+        catalog_concept = db.query(Concept).filter(
+            Concept.id == concept_id, Concept.tenant_id == tenant_id,
+            Concept.company_id == company_id, Concept.deleted_at.is_(None),
+        ).first()
+        if not catalog_concept:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail="El concepto del catálogo no existe en esta empresa",
+            )
+        if not data.get("concept"):
+            data["concept"] = catalog_concept.description[:60]
+        for field in _CONCEPT_INHERITED_FIELDS:
+            if data.get(field) is None:
+                data[field] = getattr(catalog_concept, field)
+    if not data.get("concept"):
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="La partida requiere un concepto o una referencia al catálogo de conceptos",
+        )
+
+
 def create_item(db, payload: InvoiceItemCreate, tenant_id, company_id) -> InvoiceItem:
     invoice = get_invoice(db, payload.invoice_id, tenant_id, company_id)
-    item = InvoiceItem(**payload.model_dump(), tenant_id=tenant_id, company_id=company_id)
+    data = payload.model_dump()
+    _resolve_item_concept(db, data, tenant_id, company_id)
+    item = InvoiceItem(**data, tenant_id=tenant_id, company_id=company_id)
     db.add(item)
     db.flush()
+    taxes_service.sync_item_taxes(db, item, invoice)
     _recompute(db, invoice)
     db.commit()
     db.refresh(item)
@@ -344,10 +428,17 @@ def create_item(db, payload: InvoiceItemCreate, tenant_id, company_id) -> Invoic
 
 def update_item(db, item_id, payload: InvoiceItemUpdate, tenant_id, company_id) -> InvoiceItem:
     item = _get_item(db, item_id, tenant_id, company_id)
-    for f, v in payload.model_dump(exclude_unset=True).items():
+    data = payload.model_dump(exclude_unset=True)
+    # Cambiar el concepto del catálogo revalida la referencia y vuelve a heredar
+    # descripción y claves fiscales del concepto nuevo.
+    if data.get("concept_id") is not None:
+        _resolve_item_concept(db, data, tenant_id, company_id)
+    for f, v in data.items():
         setattr(item, f, v)
     db.flush()
-    _recompute(db, get_invoice(db, item.invoice_id, tenant_id, company_id))
+    invoice = get_invoice(db, item.invoice_id, tenant_id, company_id)
+    taxes_service.sync_item_taxes(db, item, invoice)
+    _recompute(db, invoice)
     db.commit()
     db.refresh(item)
     return item

backend/api/v1/modules/fin/invoices/taxes_service.py

@@ -0,0 +1,201 @@
+"""Impuestos de las partidas de la factura.
+
+El CFDI exige el desglose **por partida**, pero la factura ya captura un porcentaje global de
+impuesto. Duplicar la captura sería trabajo doble y una fuente de incoherencias, así que el
+traslado de IVA se **deriva** de ``invoices.tax_rate`` y se recalcula cuando cambia el importe
+o el porcentaje.
+
+La derivación no pisa lo capturado a mano: en cuanto alguien ajusta los impuestos de una
+partida (una retención, una tasa distinta, un exento), esa partida deja de recalcularse sola.
+Es la diferencia entre un valor por defecto útil y un automatismo que borra trabajo ajeno.
+"""
+
+from decimal import ROUND_HALF_UP, Decimal
+
+from fastapi import HTTPException, status
+from sqlalchemy.orm import Session
+
+from ..catalogs.models import Tax, TaxObject
+from .models import Invoice, InvoiceItem, InvoiceItemTax
+
+# c_ObjetoImp que obligan al desglose de impuestos en el comprobante.
+_OBJETO_CON_DESGLOSE = {"02"}
+# c_Impuesto del IVA.
+_IVA = "002"
+
+
+def _cents(value: Decimal) -> Decimal:
+    return value.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
+
+
+def _item_taxes(db: Session, item_id: int) -> list[InvoiceItemTax]:
+    return (
+        db.query(InvoiceItemTax)
+        .filter(InvoiceItemTax.invoice_item_id == item_id, InvoiceItemTax.deleted_at.is_(None))
+        .order_by(InvoiceItemTax.id)
+        .all()
+    )
+
+
+def _tax_object_code(db: Session, item: InvoiceItem) -> str:
+    if not item.tax_object_id:
+        return ""
+    row = db.query(TaxObject).filter(TaxObject.id == item.tax_object_id).first()
+    return row.code if row else ""
+
+
+def sync_item_taxes(db: Session, item: InvoiceItem, invoice: Invoice) -> None:
+    """Deja el traslado de IVA de la partida al día con el ``tax_rate`` de la factura.
+
+    No hace nada si:
+    - la partida no es objeto de impuesto con desglose (``ObjetoImp`` distinto de 02), o
+    - ya hay impuestos que no son el traslado de IVA derivado — señal de captura manual.
+    """
+    if _tax_object_code(db, item) not in _OBJETO_CON_DESGLOSE:
+        # Si dejó de ser objeto de impuesto, se retira el traslado derivado: un CFDI con
+        # ObjetoImp 01 y nodo de impuestos es motivo de rechazo.
+        for t in _item_taxes(db, item.id):
+            db.delete(t)
+        return
+
+    iva = db.query(Tax).filter(Tax.code == _IVA).first()
+    if not iva:
+        return  # sin catálogo no hay nada que derivar; la validación del timbrado lo reportará
+
+    existentes = _item_taxes(db, item.id)
+    manuales = [t for t in existentes if t.is_withholding or t.tax_id != iva.id]
+    if manuales:
+        return  # hay captura manual: no se toca
+
+    rate = (Decimal(invoice.tax_rate or 0) / Decimal(100)).quantize(Decimal("0.000001"))
+    base = _cents(Decimal(item.quantity or 0) * Decimal(item.unit_amount or 0))
+    amount = _cents(base * rate)
+
+    traslado = next((t for t in existentes if t.tax_id == iva.id and not t.is_withholding), None)
+    if rate == 0:
+        # Tasa 0 no es lo mismo que exento, pero con el % en cero lo que hay es una factura sin
+        # IVA capturado: se retira el traslado en vez de declarar 0.00 y que el SAT lo cuestione.
+        if traslado:
+            db.delete(traslado)
+        return
+
+    if traslado is None:
+        traslado = InvoiceItemTax(
+            invoice_item_id=item.id,
+            tax_id=iva.id,
+            is_withholding=False,
+            tenant_id=item.tenant_id,
+            company_id=item.company_id,
+        )
+        db.add(traslado)
+    traslado.rate = rate
+    traslado.amount = amount
+
+
+def sync_invoice_taxes(db: Session, invoice: Invoice) -> None:
+    """Recalcula el IVA derivado de todas las partidas. Se llama al cambiar ``tax_rate``."""
+    items = (
+        db.query(InvoiceItem)
+        .filter(InvoiceItem.invoice_id == invoice.id, InvoiceItem.deleted_at.is_(None))
+        .all()
+    )
+    for item in items:
+        sync_item_taxes(db, item, invoice)
+
+
+# --------------------------------------------------------------------------------------
+# Ajuste manual
+# --------------------------------------------------------------------------------------
+def list_item_taxes(
+    db: Session, item_id: int, tenant_id: int, company_id: int
+) -> list[InvoiceItemTax]:
+    _get_item(db, item_id, tenant_id, company_id)
+    return _item_taxes(db, item_id)
+
+
+def _get_item(db: Session, item_id: int, tenant_id: int, company_id: int) -> InvoiceItem:
+    item = (
+        db.query(InvoiceItem)
+        .filter(
+            InvoiceItem.id == item_id,
+            InvoiceItem.tenant_id == tenant_id,
+            InvoiceItem.company_id == company_id,
+            InvoiceItem.deleted_at.is_(None),
+        )
+        .first()
+    )
+    if not item:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Partida no encontrada")
+    return item
+
+
+def set_item_tax(
+    db: Session,
+    item_id: int,
+    tax_id: int,
+    rate: Decimal,
+    is_withholding: bool,
+    tenant_id: int,
+    company_id: int,
+) -> InvoiceItemTax:
+    """Alta o ajuste de un impuesto de la partida. El importe se calcula de la base y la tasa."""
+    item = _get_item(db, item_id, tenant_id, company_id)
+    tax = db.query(Tax).filter(Tax.id == tax_id).first()
+    if not tax:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="El impuesto indicado no existe en el catálogo del SAT",
+        )
+    if is_withholding and not tax.is_withholding:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"El impuesto {tax.code} ({tax.description}) no puede retenerse",
+        )
+    if not is_withholding and not tax.is_transferred:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"El impuesto {tax.code} ({tax.description}) no puede trasladarse",
+        )
+
+    base = _cents(Decimal(item.quantity or 0) * Decimal(item.unit_amount or 0))
+    obj = (
+        db.query(InvoiceItemTax)
+        .filter(
+            InvoiceItemTax.invoice_item_id == item_id,
+            InvoiceItemTax.tax_id == tax_id,
+            InvoiceItemTax.is_withholding == is_withholding,
+            InvoiceItemTax.deleted_at.is_(None),
+        )
+        .first()
+    )
+    if obj is None:
+        obj = InvoiceItemTax(
+            invoice_item_id=item_id,
+            tax_id=tax_id,
+            is_withholding=is_withholding,
+            tenant_id=tenant_id,
+            company_id=company_id,
+        )
+        db.add(obj)
+    obj.rate = Decimal(rate).quantize(Decimal("0.000001"))
+    obj.amount = _cents(base * Decimal(rate))
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def delete_item_tax(db: Session, tax_row_id: int, tenant_id: int, company_id: int) -> None:
+    obj = (
+        db.query(InvoiceItemTax)
+        .filter(
+            InvoiceItemTax.id == tax_row_id,
+            InvoiceItemTax.tenant_id == tenant_id,
+            InvoiceItemTax.company_id == company_id,
+            InvoiceItemTax.deleted_at.is_(None),
+        )
+        .first()
+    )
+    if not obj:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Impuesto no encontrado")
+    db.delete(obj)
+    db.commit()

backend/api/v1/modules/fin/issuer/__init__.py

@@ -0,0 +1 @@
+"""Datos fiscales del emisor por empresa."""

backend/api/v1/modules/fin/issuer/csd_service.py

@@ -0,0 +1,159 @@
+"""Carga y lectura del CSD (Certificado de Sello Digital) de la empresa.
+
+El ``.key`` es material con el que se puede firmar a nombre de la empresa ante el SAT: no se
+devuelve nunca por la API, ni entero ni en partes. Sólo entra (al subirlo) y se usa del lado
+del servidor (al timbrar).
+"""
+
+from datetime import datetime, timezone
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.x509 import load_der_x509_certificate, load_pem_x509_certificate
+from fastapi import HTTPException, status
+from sqlalchemy.orm import Session
+
+from core.crypto import SecretsNotConfigured, encrypt_secret
+from core.s3_keys import tenant_company_prefix
+
+from ...fin.stamping import sealer
+from .models import IssuerSettings
+from .service import get_issuer_settings
+
+# Tamaño máximo razonable: un .cer del SAT ronda los 2 KB y un .key los 2 KB. El tope evita
+# que alguien suba un archivo enorme por error o a propósito.
+_MAX_BYTES = 64 * 1024
+
+
+def _csd_keys(tenant_id: int, company_id: int) -> tuple[str, str]:
+    """Claves de almacenamiento del par. Estables: subir de nuevo reemplaza el anterior."""
+    prefijo = tenant_company_prefix(tenant_id, company_id) + "certificates/"
+    return prefijo + "cfdi.cer", prefijo + "cfdi.key"
+
+
+def _verify_pair(cer_bytes: bytes, key_bytes: bytes, password: str) -> str:
+    """Comprueba que la llave privada corresponde al certificado. Devuelve el NoCertificado.
+
+    Se hace firmando un dato de prueba con la llave y verificándolo con la pública del
+    certificado. Es la única forma de saberlo antes de timbrar: si no cuadran, el error
+    aparecería hasta que el PAC rechace el comprobante, con un mensaje que no menciona el CSD.
+    """
+    try:
+        cert_number, _ = sealer.read_certificate(cer_bytes)
+        private_key = sealer.load_private_key(key_bytes, password)
+    except sealer.SealingError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(exc)
+        ) from exc
+
+    try:
+        cert = load_der_x509_certificate(cer_bytes)
+    except ValueError:
+        cert = load_pem_x509_certificate(cer_bytes)
+
+    reto = b"verificacion-de-par-csd"
+    firma = private_key.sign(reto, padding.PKCS1v15(), hashes.SHA256())
+    try:
+        cert.public_key().verify(firma, reto, padding.PKCS1v15(), hashes.SHA256())
+    except Exception as exc:  # noqa: BLE001 — cualquier fallo aquí es "no corresponden"
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=(
+                "La llave privada (.key) no corresponde al certificado (.cer). "
+                "Verifica que ambos archivos sean del mismo CSD."
+            ),
+        ) from exc
+
+    return cert_number
+
+
+def upload_csd(
+    db: Session,
+    tenant_id: int,
+    company_id: int,
+    cer_bytes: bytes,
+    key_bytes: bytes,
+    password: str,
+    user_id: str | None = None,
+) -> IssuerSettings:
+    """Valida el par, lo guarda en almacenamiento y cifra la contraseña."""
+    # Exige que ya existan los datos fiscales: el CSD pertenece a un emisor, no al aire.
+    obj = get_issuer_settings(db, tenant_id, company_id)
+
+    if not password:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="La contraseña de la llave privada es obligatoria.",
+        )
+    for etiqueta, datos in (("certificado (.cer)", cer_bytes), ("llave privada (.key)", key_bytes)):
+        if not datos:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"Falta el archivo del {etiqueta}.",
+            )
+        if len(datos) > _MAX_BYTES:
+            raise HTTPException(
+                status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+                detail=f"El archivo del {etiqueta} es demasiado grande para ser un CSD.",
+            )
+
+    cert_number = _verify_pair(cer_bytes, key_bytes, password)
+
+    # La contraseña se cifra ANTES de subir los archivos: si no hay clave maestra, no se deja
+    # material criptográfico en el almacenamiento a medio configurar.
+    try:
+        password_enc = encrypt_secret(password)
+    except SecretsNotConfigured as exc:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail=str(exc)
+        ) from exc
+
+    from core.storage_s3 import (
+        put_object_bytes,
+    )  # noqa: PLC0415  (import diferido: tests sin MinIO)
+
+    cer_key, key_key = _csd_keys(tenant_id, company_id)
+    put_object_bytes(cer_key, cer_bytes, content_type="application/x-x509-ca-cert")
+    put_object_bytes(key_key, key_bytes, content_type="application/octet-stream")
+
+    obj.csd_cer_file_key = cer_key
+    obj.csd_key_file_key = key_key
+    obj.csd_password_enc = password_enc
+    obj.csd_cert_number = cert_number
+    obj.csd_uploaded_at = datetime.now(timezone.utc)
+    obj.updated_by = user_id
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+
+def delete_csd(
+    db: Session, tenant_id: int, company_id: int, user_id: str | None = None
+) -> IssuerSettings:
+    """Desvincula el CSD de la empresa.
+
+    Se borran también los objetos del almacenamiento: dejar una llave privada huérfana es
+    justo lo que no se quiere. Si el borrado remoto falla, la referencia se limpia igual —
+    sin ella el sistema ya no puede firmar.
+    """
+    obj = get_issuer_settings(db, tenant_id, company_id)
+    claves = [k for k in (obj.csd_cer_file_key, obj.csd_key_file_key) if k]
+    if claves:
+        try:
+            from core.storage_s3 import delete_object_if_exists  # noqa: PLC0415
+
+            for k in claves:
+                delete_object_if_exists(k)
+        except Exception:  # noqa: BLE001
+            # No se propaga: la referencia se limpia igual y el CSD queda inutilizable.
+            pass
+
+    obj.csd_cer_file_key = None
+    obj.csd_key_file_key = None
+    obj.csd_password_enc = None
+    obj.csd_cert_number = None
+    obj.csd_uploaded_at = None
+    obj.updated_by = user_id
+    db.commit()
+    db.refresh(obj)
+    return obj

backend/api/v1/modules/fin/issuer/dto.py

@@ -0,0 +1,71 @@
+"""Esquemas de los datos fiscales del emisor."""
+
+import re
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, computed_field, Field, field_validator
+
+from ..catalogs.dto import TaxRegimeResponse
+
+# RFC de persona moral (3 letras) o física (4 letras) + fecha + homoclave.
+RFC_PATTERN = re.compile(r"^[A-ZÑ&]{3,4}\d{6}[A-Z0-9]{3}$")
+ZIP_PATTERN = re.compile(r"^\d{5}$")
+
+
+class IssuerSettingsInput(BaseModel):
+    """Alta o actualización de los datos fiscales del emisor."""
+
+    legal_name: str = Field(..., min_length=1, max_length=255, description="Razón social")
+    rfc: str = Field(..., max_length=13, description="RFC del emisor")
+    tax_regime_id: int = Field(..., description="Régimen fiscal (c_RegimenFiscal)")
+    zip_code: str | None = Field(None, max_length=5, description="CP del lugar de expedición")
+
+    # mode="before": la normalización corre antes que el max_length del campo, para que
+    # un RFC con espacios de sobra no se rechace por longitud antes de limpiarlo.
+    @field_validator("rfc", mode="before")
+    @classmethod
+    def _validate_rfc(cls, value: str) -> str:
+        """Normaliza a mayúsculas sin espacios y valida el formato oficial del RFC."""
+        if not isinstance(value, str):
+            raise ValueError("El RFC debe ser texto")
+        normalized = value.replace(" ", "").replace("-", "").upper()
+        if not RFC_PATTERN.match(normalized):
+            raise ValueError("El RFC no tiene un formato válido (ej. XAXX010101000)")
+        return normalized
+
+    @field_validator("zip_code")
+    @classmethod
+    def _validate_zip(cls, value: str | None) -> str | None:
+        if value is None or value == "":
+            return None
+        normalized = value.strip()
+        if not ZIP_PATTERN.match(normalized):
+            raise ValueError("El código postal debe tener 5 dígitos")
+        return normalized
+
+
+class IssuerSettingsResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    tenant_id: int
+    company_id: int
+    legal_name: str
+    rfc: str
+    tax_regime_id: int
+    tax_regime: TaxRegimeResponse | None = None
+    zip_code: str | None = None
+    updated_by: str | None = None
+    created_at: datetime
+    updated_at: datetime
+    # ----- Estado del CSD -----
+    # Se expone SI hay certificado cargado y cuál, nunca su contenido ni la contraseña: con el
+    # .key se puede firmar a nombre de la empresa ante el SAT.
+    csd_cert_number: str | None = None
+    csd_uploaded_at: datetime | None = None
+
+    @computed_field
+    @property
+    def has_csd(self) -> bool:
+        """Hay par de archivos y contraseña guardados, o sea que ya se puede timbrar."""
+        return bool(self.csd_cert_number and self.csd_uploaded_at)

backend/api/v1/modules/fin/issuer/models.py

@@ -0,0 +1,57 @@
+"""Datos fiscales del emisor — ``fin.issuer_settings``.
+
+Es la identidad fiscal con la que la empresa emite CFDI: razón social, RFC, régimen
+fiscal y código postal del lugar de expedición. Hay **una sola configuración vigente
+por empresa**, garantizada con un índice único parcial.
+"""
+
+from datetime import datetime
+
+from sqlalchemy import DateTime, ForeignKey, Index, Integer, String, Text, text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
+from core.database import Base
+
+from ..catalogs.models import TaxRegime  # noqa: F401  (resuelve la relación)
+
+_ALIVE = text("deleted_at IS NULL")
+
+
+class IssuerSettings(Base, TenantScopedMixin, TimestampMixin):
+    """Configuración fiscal del emisor de la empresa."""
+
+    __tablename__ = "issuer_settings"
+    __table_args__ = (
+        Index(
+            "uq_fin_issuer_settings_company",
+            "tenant_id", "company_id",
+            unique=True, postgresql_where=_ALIVE, sqlite_where=_ALIVE,
+        ),
+        {"schema": "fin"},
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    legal_name: Mapped[str] = mapped_column(String(255), nullable=False)  # razón social
+    rfc: Mapped[str] = mapped_column(String(13), nullable=False)
+    tax_regime_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("sat.tax_regimes.id"), nullable=False, index=True
+    )
+    # CP del lugar de expedición del comprobante
+    zip_code: Mapped[str | None] = mapped_column(String(5), nullable=True)
+    updated_by: Mapped[str | None] = mapped_column(String(64), nullable=True)
+
+    # ----- CSD (Certificado de Sello Digital) de la empresa -----
+    # Los archivos viven en MinIO; aquí sólo su clave. El .key es material con el que se puede
+    # firmar a nombre de la empresa: no se expone nunca por la API, ni siquiera su contenido en
+    # base64. Sólo se sube y se usa del lado del servidor.
+    csd_cer_file_key: Mapped[str | None] = mapped_column(String(512), nullable=True)
+    csd_key_file_key: Mapped[str | None] = mapped_column(String(512), nullable=True)
+    # Contraseña de la llave privada, cifrada con la clave maestra del entorno (core.crypto).
+    # Nunca se devuelve en una respuesta; sólo se sabe si está puesta o no.
+    csd_password_enc: Mapped[str | None] = mapped_column(Text, nullable=True)
+    # Informativo, para mostrar en la pantalla qué certificado está cargado.
+    csd_cert_number: Mapped[str | None] = mapped_column(String(20), nullable=True)
+    csd_uploaded_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+
+    tax_regime: Mapped["TaxRegime"] = relationship("TaxRegime", lazy="selectin")

backend/api/v1/modules/fin/issuer/routes.py

@@ -0,0 +1,97 @@
+"""Endpoints de los datos fiscales del emisor (una configuración por empresa)."""
+
+from fastapi import APIRouter, Depends, File, Form, Query, UploadFile
+from sqlalchemy.orm import Session
+
+from api.v1.modules.core.permissions.dependencies import PermissionChecker
+from core.database import get_core_db
+from core.security import get_current_user
+
+from . import csd_service, service
+from .dto import IssuerSettingsInput, IssuerSettingsResponse
+
+router = APIRouter()
+
+
+@router.get(
+    "/settings/issuer",
+    response_model=IssuerSettingsResponse,
+    dependencies=[Depends(PermissionChecker(["fin.settings.view"]))],
+)
+def get_issuer_settings(
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Devuelve 404 mientras la empresa no haya capturado sus datos fiscales."""
+    return service.get_issuer_settings(db, current_user["tenant_id"], company_id)
+
+
+@router.put(
+    "/settings/issuer",
+    response_model=IssuerSettingsResponse,
+    dependencies=[Depends(PermissionChecker(["fin.settings.edit"]))],
+)
+def save_issuer_settings(
+    payload: IssuerSettingsInput,
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Alta o actualización (upsert) de los datos fiscales del emisor."""
+    return service.save_issuer_settings(
+        db,
+        payload,
+        current_user["tenant_id"],
+        company_id,
+        current_user.get("sub") or current_user.get("id"),
+    )
+
+
+@router.post(
+    "/settings/issuer/csd",
+    response_model=IssuerSettingsResponse,
+    dependencies=[Depends(PermissionChecker(["fin.settings.edit"]))],
+)
+async def upload_csd(
+    company_id: int = Query(..., description="Company ID"),
+    cer: UploadFile = File(..., description="Certificado del CSD (.cer)"),
+    key: UploadFile = File(..., description="Llave privada del CSD (.key)"),
+    password: str = Form(..., description="Contraseña de la llave privada"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Carga el CSD de la empresa.
+
+    Antes de guardar nada se comprueba que la llave privada corresponde al certificado: si no,
+    el error saldría hasta que el PAC rechace un comprobante, con un mensaje que no menciona
+    el CSD. La contraseña se guarda cifrada y **no se devuelve nunca**.
+    """
+    return csd_service.upload_csd(
+        db,
+        current_user["tenant_id"],
+        company_id,
+        await cer.read(),
+        await key.read(),
+        password,
+        current_user.get("sub") or current_user.get("id"),
+    )
+
+
+@router.delete(
+    "/settings/issuer/csd",
+    response_model=IssuerSettingsResponse,
+    dependencies=[Depends(PermissionChecker(["fin.settings.edit"]))],
+)
+def delete_csd(
+    company_id: int = Query(..., description="Company ID"),
+    current_user: dict = Depends(get_current_user),
+    db: Session = Depends(get_core_db),
+):
+    """Desvincula el CSD y borra sus archivos del almacenamiento."""
+    return csd_service.delete_csd(
+        db,
+        current_user["tenant_id"],
+        company_id,
+        current_user.get("sub") or current_user.get("id"),
+    )

backend/api/v1/modules/fin/issuer/service.py

@@ -0,0 +1,58 @@
+"""Lógica de los datos fiscales del emisor.
+
+Una empresa tiene, a lo más, una configuración vigente: el guardado es un upsert, no
+un alta que pueda duplicar filas.
+"""
+
+from fastapi import HTTPException, status
+from sqlalchemy.orm import Session
+
+from ..catalogs.models import TaxRegime
+from .dto import IssuerSettingsInput
+from .models import IssuerSettings
+
+
+def _find(db: Session, tenant_id: int, company_id: int) -> IssuerSettings | None:
+    return db.query(IssuerSettings).filter(
+        IssuerSettings.tenant_id == tenant_id,
+        IssuerSettings.company_id == company_id,
+        IssuerSettings.deleted_at.is_(None),
+    ).first()
+
+
+def get_issuer_settings(db: Session, tenant_id: int, company_id: int) -> IssuerSettings:
+    obj = _find(db, tenant_id, company_id)
+    if not obj:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="La empresa aún no tiene datos fiscales del emisor configurados",
+        )
+    return obj
+
+
+def save_issuer_settings(
+    db: Session,
+    payload: IssuerSettingsInput,
+    tenant_id: int,
+    company_id: int,
+    user_id: str | None = None,
+) -> IssuerSettings:
+    """Crea la configuración la primera vez y la actualiza en adelante."""
+    if db.query(TaxRegime.id).filter(TaxRegime.id == payload.tax_regime_id).first() is None:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail="El régimen fiscal indicado no existe en el catálogo del SAT",
+        )
+
+    obj = _find(db, tenant_id, company_id)
+    data = payload.model_dump()
+    if obj is None:
+        obj = IssuerSettings(**data, tenant_id=tenant_id, company_id=company_id, updated_by=user_id)
+        db.add(obj)
+    else:
+        for field, value in data.items():
+            setattr(obj, field, value)
+        obj.updated_by = user_id
+    db.commit()
+    db.refresh(obj)
+    return obj

backend/api/v1/modules/fin/permissions.py

@@ -3,7 +3,7 @@
 from api.v1.modules.core.permissions.registry import registry
 
 MODULE = "fin"
-_ENTITIES = [("invoice", "facturas"), ("payment", "pagos")]
+_ENTITIES = [("invoice", "facturas"), ("payment", "pagos"), ("concept", "conceptos")]
 _ACTIONS = [("view", "Ver"), ("create", "Crear"), ("edit", "Editar"), ("delete", "Eliminar")]
 
 
@@ -12,6 +12,11 @@ def register_permissions() -> None:
     for entity, label in _ENTITIES:
         for action, verb in _ACTIONS:
             registry.register(code=f"{MODULE}.{entity}.{action}", description=f"{verb} {label}", module=MODULE, action=action)
+    # Datos fiscales del emisor: es configuración de la empresa, no una entidad con CRUD,
+    # así que solo tiene ver/editar. Los catálogos del SAT no llevan permiso propio:
+    # son globales y de solo lectura, basta con fin.access.
+    registry.register(code=f"{MODULE}.settings.view", description="Ver datos fiscales del emisor", module=MODULE, action="view")
+    registry.register(code=f"{MODULE}.settings.edit", description="Editar datos fiscales del emisor", module=MODULE, action="edit")
 
 
 register_permissions()

backend/api/v1/modules/fin/router.py

@@ -5,8 +5,16 @@ from fastapi import APIRouter, Depends
 from api.v1.modules.core.permissions.dependencies import PermissionChecker
 
 from . import permissions  # noqa: F401  (side-effect: registra permisos)
+from .catalogs.routes import router as catalogs_router
+from .concepts.routes import router as concepts_router
 from .invoices.routes import router as invoices_router
+from .issuer.routes import router as issuer_router
+from .stamping.routes import router as stamping_router
 
 # Enforcement por área/carril (R-T-07): se exige fin.access para el módulo.
 router = APIRouter(dependencies=[Depends(PermissionChecker(["fin.access"]))])
+router.include_router(catalogs_router)
+router.include_router(concepts_router)
+router.include_router(issuer_router)
 router.include_router(invoices_router)
+router.include_router(stamping_router)

backend/api/v1/modules/fin/stamping/__init__.py

@@ -0,0 +1 @@
+"""Timbrado de CFDI 4.0 ante el PAC (Comercio Digital)."""