Upload 7 files

.gitignore

@@ -0,0 +1,12 @@
+.env
+__pycache__/
+*.pyc
+*.log
+api_test.*.log
+streamlit_test.*.log
+backend.log
+ACP DATA LIC PASADAS*.xlsx
+PRY-FRPCL-003 Evaluación de Cumplimiento del Proveedor.xlsx
+app_recovered_*.py
+fix_*.py
+update_*.py

api.py

@@ -2,750 +2,1052 @@ from fastapi import FastAPI, UploadFile, File, HTTPException, Form, BackgroundTa
 from fastapi.middleware.cors import CORSMiddleware
 from typing import List
 from pydantic import BaseModel
-import google.generativeai as genai
 import tempfile
 import os
+try:
+    import truststore
+    truststore.inject_into_ssl()
+except Exception:
+    pass
+try:
+    import certifi
+    CERTIFI_CA_BUNDLE = certifi.where()
+    os.environ.setdefault("SSL_CERT_FILE", CERTIFI_CA_BUNDLE)
+    os.environ.setdefault("REQUESTS_CA_BUNDLE", CERTIFI_CA_BUNDLE)
+    os.environ.setdefault("GRPC_DEFAULT_SSL_ROOTS_FILE_PATH", CERTIFI_CA_BUNDLE)
+except Exception:
+    pass
+import google.generativeai as genai
 import json
-import imaplib
-import email
-from email.header import decode_header
-import re
-import hashlib
-import time
-import pandas as pd
-import io
-from urllib.parse import urljoin
-from dotenv import load_dotenv
-import database as db
-import logging
-from logging.handlers import RotatingFileHandler
-from bs4 import BeautifulSoup
-import sys
-import asyncio
-import crypto
-
-if sys.platform == "win32":
-    asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
-load_dotenv()
-
-# --- 1. LOGGING CON ROTACIÓN (max 2MB, 3 backups) ---
-log_handler = RotatingFileHandler('backend.log', maxBytes=2*1024*1024, backupCount=3, encoding='utf-8')
-log_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
-logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
-logger.addHandler(log_handler)
-
-# --- 2. SEGURIDAD Y CIFRADO ---
-# Se utiliza el módulo centralizado `crypto.py`
-INTERNAL_API_TOKEN = os.getenv("INTERNAL_API_TOKEN", "default-dev-token")
-
-def verify_internal_token(x_internal_token: str = Header(None)):
-    if x_internal_token != INTERNAL_API_TOKEN:
-        raise HTTPException(status_code=403, detail="Acceso denegado: Token interno inválido.")
-    return x_internal_token
-
-
-# --- 3. APP FASTAPI ---
-app = FastAPI(title="Proyelec Core API v6.1")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["http://localhost:8501", "http://127.0.0.1:8501"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-@app.get("/")
-def estado():
-    return {"status": "Online", "engine": "Proyelec Core v6.1 — Token-Optimized"}
-
-# --- 4. PROMPT ANALISTA DE PLIEGOS (Multi-documento) ---
+import imaplib
+import email
+from email.header import decode_header
+import re
+import hashlib
+import time
+import pandas as pd
+import io
+from urllib.parse import urljoin
+from dotenv import load_dotenv
+import database as db
+import logging
+from logging.handlers import RotatingFileHandler
+from bs4 import BeautifulSoup
+import sys
+import asyncio
+import crypto
+
+if sys.platform == "win32":
+    asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
+load_dotenv()
+
+# --- 1. LOGGING CON ROTACIÓN (max 2MB, 3 backups) ---
+log_handler = RotatingFileHandler('backend.log', maxBytes=2*1024*1024, backupCount=3, encoding='utf-8')
+log_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(log_handler)
+
+# --- 2. SEGURIDAD Y CIFRADO ---
+# Se utiliza el módulo centralizado `crypto.py`
+INTERNAL_API_TOKEN = os.getenv("INTERNAL_API_TOKEN", "default-dev-token")
+
+def verify_internal_token(x_internal_token: str = Header(None)):
+    if x_internal_token != INTERNAL_API_TOKEN:
+        raise HTTPException(status_code=403, detail="Acceso denegado: Token interno inválido.")
+    return x_internal_token
+
+
+# --- 3. APP FASTAPI ---
+app = FastAPI(title="Proyelec Core API v6.1")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:8501", "http://127.0.0.1:8501", "http://localhost:3000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+def estado():
+    return {"status": "Online", "engine": "Proyelec Core v6.1 — Token-Optimized"}
+
+# --- 4. PROMPT ANALISTA DE PLIEGOS (Multi-documento) ---
 PROMPT_ANALISTA_MULTI = """
 Eres un Analista Senior de Procura. Analiza TODO el conjunto de documentos proporcionados (Pliego Principal y Anexos Técnicos).
 Cruza la información de todos los documentos para obtener descripciones técnicas exactas.
+
+REGLA DE ORO ESTRICTA:
+Tu análisis debe basarse ÚNICA Y EXCLUSIVAMENTE en el texto, tablas y datos contenidos en los documentos adjuntos.
+No busques información en internet, no deduzcas, no asumas y no uses conocimiento externo sobre leyes, fabricantes, estándares o prácticas comerciales.
+Si un dato no aparece explícitamente en los documentos, devuelve exactamente: "No especificado en los documentos adjuntos".
+
 IMPORTANTE: El campo 'ficha_tecnica_completa' debe ser redactado como una Checklist técnica. Lista todos los requerimientos, materiales, normativas y entregables que exige la ACP para ese renglón usando el formato '- [ ] Requisito'.
+IMPORTANTE: No confundas 'ficha_tecnica_completa' con 'requiere_ficha_tecnica'. 
+- 'ficha_tecnica_completa' resume las especificaciones técnicas del producto/renglón.
+- 'requiere_ficha_tecnica' solo indica si el oferente debe ENTREGAR/ADJUNTAR un documento técnico en la oferta.
+
+Extrae también controles técnicos críticos para decidir participación:
+- restriccion_marca_proveedor: Si el pliego exige o restringe explícitamente a una marca, fabricante, suplidor, proponente o distribuidor autorizado que no sea la ACP, descríbelo aquí (ej. 'Solo se acepta marca X' o 'Solo distribuidor autorizado Y'). Si no hay restricciones, devuelve null.
+- permite_equivalentes: true si el pliego permite marcas/modelos equivalentes, alternativas técnicas o "igual o superior"; false si exige una marca/modelo exacto sin alternativas; null si no se puede determinar.
+- permite_carta_obsolescencia: true si el pliego (usualmente en el Inciso 9 o similar) permite entregar actualizaciones de números de parte obsoletos acompañadas de una carta del fabricante, false si no.
+- evidencia_restricciones: cita corta o referencia de la cláusula/inciso donde se detectó restricción, equivalentes, carta de fabricante u obsolescencia. Si no aplica, devuelve "".
+- riesgo_tecnico_global: "Bajo", "Medio" o "Alto" según restricciones de marca/proveedor, falta de equivalentes, fichas técnicas obligatorias y riesgo de obsolescencia.
+- propuesta_tecnica_requerida: "Si" si el pliego exige adjuntar propuesta técnica; "No" si explícitamente no la exige; "No especificado en los documentos adjuntos" si no se menciona. Si aplica solo a ciertos renglones, devuelve "Si (aplica solo a líneas X, Y)".
+- propuesta_tecnica_aplica_renglones: lista de renglones/líneas donde aplica la propuesta técnica. Si aplica globalmente, usa ["Todos"]. Si no se especifica, [].
+- evidencia_propuesta_tecnica: cita corta exacta donde se pide la propuesta técnica y se indica a qué líneas aplica.
+- persona_encargada_licitacion: nombre del agente de compras, contacto, responsable o persona encargada de la licitación si aparece en el documento. Si no aparece, devuelve "No especificado en los documentos adjuntos".
+- correo_encargado_licitacion: correo electrónico del contacto de la licitación si aparece. Si no aparece, devuelve "No especificado en los documentos adjuntos".
+- telefono_encargado_licitacion: teléfono del contacto de la licitación si aparece. Si no aparece, devuelve "No especificado en los documentos adjuntos".
+- requiere_presencia_local: true si el pliego exige explícitamente empresa local, presencia local, oficina local, representante local o condición similar para participar; false si no se detecta ese requisito en los documentos o el pliego permite participar sin esa condición; null si el texto es contradictorio o no se puede determinar.
+- evidencia_presencia_local: cita corta exacta donde se detecta el requisito de presencia local o la ausencia/permiso relevante. Si no hay evidencia textual clara, devuelve "".
+- empresa_recomendada_participacion: "EP" si requiere_presencia_local es true; "Proyelec" si requiere_presencia_local es false; "Validar" si requiere_presencia_local es null.
+
+Para cada renglón extrae:
+- codigo_articulo: código ACP del renglón ÚNICAMENTE si aparece con formato de 3 letras, guion, 3 letras, guion y 5 números, por ejemplo ABC-DEF-12345. No incluyas descripciones, números de parte, marcas ni texto adicional. Si el código no aparece con ese formato exacto, devuelve "".
+- requiere_propuesta_tecnica: true si la propuesta técnica aplica a ese renglón/línea; false si no aplica.
+- requiere_ficha_tecnica: true SOLO si el pliego exige entregar/presentar/adjuntar ficha técnica, catálogo, datasheet, plano, certificado, muestra, manual, ficha de seguridad o submittal técnico junto con la oferta/propuesta. false si el texto solo describe especificaciones técnicas, marca, modelo, número de parte o cumplimiento técnico sin pedir un documento entregable.
+- marca_modelo_requerido: marca, fabricante, modelo o número de parte exigido para ese renglón. Si no hay, null.
+- acepta_equivalente: true si ese renglón acepta equivalente; false si no acepta; null si no se puede determinar.
+- posible_obsolescencia: true si el texto menciona número de parte obsoleto, reemplazo, actualización, discontinued, superseded, obsolete o carta del fabricante para ese renglón; false si no.
+- evidencia_tecnica: cita corta o inciso relevante para ficha técnica, marca/modelo, equivalentes u obsolescencia de ese renglón.
+
+Regla especial para 'requiere_ficha_tecnica':
+- NO marques true solo porque exista una marca restringida.
+- NO marques true solo porque exista número de parte, modelo, material, dimensión, norma o especificación técnica.
+- Marca true únicamente si el documento exige un ENTREGABLE DOCUMENTAL como "presentar ficha técnica", "adjuntar catálogo", "entregar datasheet", "certificado", "manual", "carta del fabricante", "plano", "muestra" o frase equivalente.
+- Si la evidencia no contiene una exigencia documental clara, requiere_ficha_tecnica debe ser false.
+
+Regla especial para 'requiere_propuesta_tecnica':
+- Si el documento dice "Se requiere propuesta técnica" y luego limita con frases como "(APLICA SOLO PARA LAS LÍNEAS 3 Y 4)", marca true únicamente en esos renglones.
+- No confundas "propuesta técnica" con "marca restringida". Una licitación puede permitir alternativas técnicas y aun así exigir propuesta técnica para comprobar cumplimiento.
+- Si la propuesta técnica debe incluir marca/modelo/dimensiones para líneas específicas, eso es requiere_propuesta_tecnica=true para esas líneas, no necesariamente requiere_ficha_tecnica=true.
 
 Responde ÚNICAMENTE con el siguiente JSON estricto, sin texto adicional:
-{"condiciones_generales": {"numero_licitacion": "", "tiempo_de_entrega_global": "", "garantia_exigida": "", "lugar_de_entrega": "", "validez_de_la_oferta": "", "propuesta_tecnica_requerida": "Si/No"},
- "items": [{"renglon": "", "codigo_articulo": "", "cantidad": 0, "unidad_de_medida": "", "ficha_tecnica_completa": "", "termino_de_busqueda_corto": ""}]}
+{"condiciones_generales": {"numero_licitacion": "", "tiempo_de_entrega_global": "", "garantia_exigida": "", "lugar_de_entrega": "", "validez_de_la_oferta": "", "persona_encargada_licitacion": "No especificado en los documentos adjuntos", "correo_encargado_licitacion": "No especificado en los documentos adjuntos", "telefono_encargado_licitacion": "No especificado en los documentos adjuntos", "requiere_presencia_local": null, "evidencia_presencia_local": "", "empresa_recomendada_participacion": "Validar", "propuesta_tecnica_requerida": "Si/No/No especificado en los documentos adjuntos", "propuesta_tecnica_aplica_renglones": [], "evidencia_propuesta_tecnica": "", "restriccion_marca_proveedor": null, "permite_equivalentes": null, "permite_carta_obsolescencia": false, "evidencia_restricciones": "", "riesgo_tecnico_global": "Bajo"},
+ "items": [{"renglon": "", "codigo_articulo": "", "cantidad": 0, "unidad_de_medida": "", "ficha_tecnica_completa": "", "termino_de_busqueda_corto": "", "requiere_propuesta_tecnica": false, "requiere_ficha_tecnica": false, "marca_modelo_requerido": null, "acepta_equivalente": null, "posible_obsolescencia": false, "evidencia_tecnica": ""}]}
 """
 
+DOCUMENTAL_KEYWORDS = [
+    "presentar ficha", "adjuntar ficha", "entregar ficha", "ficha tecnica", "ficha técnica",
+    "catalogo", "catálogo", "datasheet", "data sheet", "certificado", "certificacion",
+    "certificación", "manual", "carta del fabricante", "carta de fabricante", "plano",
+    "muestra", "submittal", "hoja de seguridad", "ficha de seguridad", "msds",
+]
+
+ACP_CODE_RE = re.compile(r"\b([A-Z]{3})-([A-Z]{3})-(\d{5})\b", re.IGNORECASE)
+
+def _normalize_acp_code(value):
+    text = str(value or "").strip().upper()
+    match = ACP_CODE_RE.search(text)
+    if not match:
+        return ""
+    return f"{match.group(1).upper()}-{match.group(2).upper()}-{match.group(3)}"
+
+def _parse_rows_from_scope_text(value):
+    rows = set()
+    if value is None:
+        return rows, False
+    if isinstance(value, (list, tuple, set)):
+        all_rows = False
+        for item in value:
+            item_text = str(item or "").strip().lower()
+            if item_text in ["todos", "todas", "all"]:
+                all_rows = True
+            rows.update(re.findall(r"\d+", item_text))
+        return rows, all_rows
+
+    text = str(value or "").strip()
+    if not text:
+        return rows, False
+    if re.search(r"\b(todos|todas|global|all)\b", text, re.IGNORECASE):
+        return rows, True
+
+    scoped_matches = re.findall(
+        r"(?:l[ií]neas?|renglones?)\s+([0-9][0-9,\s\-yY]*)",
+        text,
+        flags=re.IGNORECASE,
+    )
+    for match in scoped_matches:
+        rows.update(re.findall(r"\d+", match))
+    return rows, False
+
+def _to_bool(value, default=False):
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return default
+    text = str(value).strip().lower()
+    if text in ["true", "si", "sí", "yes", "1"]:
+        return True
+    if text in ["false", "no", "0", "none", "null", "n/a", ""]:
+        return False
+    return default
+
+def _to_optional_bool(value):
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return None
+    text = str(value).strip().lower()
+    if text in ["true", "si", "sí", "yes", "1"]:
+        return True
+    if text in ["false", "no", "0"]:
+        return False
+    return None
+
+def postprocess_technical_analysis(data: dict) -> dict:
+    """Reduce falsos positivos entre especificaciones técnicas y entregables documentales."""
+    items = data.get("items", []) if isinstance(data, dict) else []
+    proposal_rows = []
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        item["codigo_articulo"] = _normalize_acp_code(item.get("codigo_articulo"))
+        requiere_propuesta = _to_bool(item.get("requiere_propuesta_tecnica"), default=False)
+        item["requiere_propuesta_tecnica"] = requiere_propuesta
+        if requiere_propuesta:
+            renglon = str(item.get("renglon") or "").strip()
+            if renglon:
+                proposal_rows.append(renglon)
+
+        requiere = _to_bool(item.get("requiere_ficha_tecnica"), default=False)
+        evidencia = str(item.get("evidencia_tecnica") or "").lower()
+        combined = evidencia
+
+        has_documental_evidence = any(keyword in combined for keyword in DOCUMENTAL_KEYWORDS)
+        if requiere and not has_documental_evidence:
+            item["requiere_ficha_tecnica"] = False
+            if evidencia:
+                item["evidencia_tecnica"] = f"{item.get('evidencia_tecnica')} | Nota sistema: no se detectó entregable documental explícito."
+            else:
+                item["evidencia_tecnica"] = "No especificado en los documentos adjuntos"
+        else:
+            item["requiere_ficha_tecnica"] = requiere
+
+        item["posible_obsolescencia"] = _to_bool(item.get("posible_obsolescencia"), default=False)
+
+    cg = data.get("condiciones_generales", {}) if isinstance(data, dict) else {}
+    if isinstance(cg, dict):
+        scope_rows, scope_all = _parse_rows_from_scope_text(cg.get("propuesta_tecnica_aplica_renglones"))
+        text_scope_rows, text_scope_all = _parse_rows_from_scope_text(
+            f"{cg.get('propuesta_tecnica_requerida', '')} {cg.get('evidencia_propuesta_tecnica', '')}"
+        )
+        scope_rows.update(text_scope_rows)
+        scope_all = scope_all or text_scope_all
+        proposal_required = str(cg.get("propuesta_tecnica_requerida", "") or "").strip().lower().startswith(("si", "sí")) or bool(scope_rows) or scope_all
+
+        if proposal_required and (scope_all or scope_rows):
+            proposal_rows = []
+            for item in items:
+                if not isinstance(item, dict):
+                    continue
+                renglon = str(item.get("renglon") or "").strip()
+                row_number_match = re.search(r"\d+", renglon)
+                row_number = row_number_match.group(0) if row_number_match else ""
+                applies = scope_all or row_number in scope_rows
+                item["requiere_propuesta_tecnica"] = bool(applies)
+                if applies and row_number:
+                    proposal_rows.append(row_number)
+            if scope_rows:
+                proposal_rows = sorted(set(scope_rows), key=lambda x: int(x) if x.isdigit() else x)
+            elif scope_all:
+                cg["propuesta_tecnica_requerida"] = "Si (aplica a todos los renglones)"
+                cg["propuesta_tecnica_aplica_renglones"] = ["Todos"]
+        if proposal_rows:
+            unique_rows = sorted(set(proposal_rows), key=lambda x: int(x) if x.isdigit() else x)
+            cg["propuesta_tecnica_requerida"] = f"Si (aplica líneas {', '.join(unique_rows)})"
+            cg["propuesta_tecnica_aplica_renglones"] = unique_rows
+        elif str(cg.get("propuesta_tecnica_requerida", "")).strip().lower() in ["", "n/a", "none", "null"]:
+            cg["propuesta_tecnica_requerida"] = "No especificado en los documentos adjuntos"
+
+        for key in [
+            "persona_encargada_licitacion",
+            "correo_encargado_licitacion",
+            "telefono_encargado_licitacion",
+        ]:
+            if str(cg.get(key, "") or "").strip().lower() in ["", "n/a", "none", "null"]:
+                cg[key] = "No especificado en los documentos adjuntos"
+
+        presencia_local = _to_optional_bool(cg.get("requiere_presencia_local"))
+        cg["requiere_presencia_local"] = presencia_local
+        if presencia_local is True:
+            cg["empresa_recomendada_participacion"] = "EP"
+        elif presencia_local is False:
+            cg["empresa_recomendada_participacion"] = "Proyelec"
+        else:
+            cg["empresa_recomendada_participacion"] = "Validar"
+            if str(cg.get("evidencia_presencia_local", "") or "").strip().lower() in ["n/a", "none", "null"]:
+                cg["evidencia_presencia_local"] = ""
+
+    return data
+
 @app.post("/api/v1/analizar-pliego")
-async def analizar_pliego(archivos_pdf: List[UploadFile] = File(...), gemini_key: str = Form(...), _token: str = Depends(verify_internal_token)):
+async def analizar_pliego(
+    archivos_pdf: List[UploadFile] = File(...),
+    gemini_key: str = Form(...),
+    username: str = Form("API"),
+    role: str = Form(""),
+    _token: str = Depends(verify_internal_token)
+):
+    started_at = time.perf_counter()
     api_key_clean = gemini_key.strip()
     try:
-        genai.configure(api_key=api_key_clean)
-        archivos_subidos = []
-
-        for archivo in archivos_pdf:
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
-                content = await archivo.read()
-                tmp.write(content)
-                tmp_path = tmp.name
-            
-            uploaded_file = genai.upload_file(path=tmp_path, mime_type="application/pdf")
-            archivos_subidos.append(uploaded_file)
-            os.remove(tmp_path)
-
-        # gemini-2.5-flash para análisis complejo de PDFs
+        genai.configure(api_key=api_key_clean, transport="rest")
+        archivos_subidos = []
+
+        for archivo in archivos_pdf:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+                content = await archivo.read()
+                tmp.write(content)
+                tmp_path = tmp.name
+            
+            uploaded_file = genai.upload_file(path=tmp_path, mime_type="application/pdf")
+            archivos_subidos.append(uploaded_file)
+            os.remove(tmp_path)
+
+        # gemini-2.5-flash para análisis complejo de PDFs
         model = genai.GenerativeModel('gemini-2.5-flash', generation_config={"response_mime_type": "application/json"})
         response = model.generate_content([PROMPT_ANALISTA_MULTI, *archivos_subidos])
-
-        # Limpieza de archivos en la nube de Gemini para evitar llenar la cuota
-        for f in archivos_subidos:
-            try:
-                genai.delete_file(f.name)
-            except Exception as e:
-                logger.warning(f"No se pudo borrar archivo temporal de Gemini: {e}")
+        try:
+            db.log_ai_usage(
+                username=username,
+                role=role,
+                action="analizar_pliego",
+                model="gemini-2.5-flash",
+                usage_metadata=response.usage_metadata,
+                duration_ms=int((time.perf_counter() - started_at) * 1000),
+                metadata={"pdf_count": len(archivos_subidos)}
+            )
+        except Exception as e:
+            logger.warning(f"Error logging metric: {e}")
+
+
+        # Limpieza de archivos en la nube de Gemini para evitar llenar la cuota
+        for f in archivos_subidos:
+            try:
+                genai.delete_file(f.name)
+            except Exception as e:
+                logger.warning(f"No se pudo borrar archivo temporal de Gemini: {e}")
 
         logger.info(f"{len(archivos_subidos)} pliego(s) analizados exitosamente.")
-        return json.loads(response.text)
+        data = json.loads(response.text)
+        return postprocess_technical_analysis(data)
 
     except Exception as e:
         logger.error(f"Error analizando pliego: {str(e)}")
+        db.log_usage_event(
+            username=username,
+            role=role,
+            module="ai",
+            action="analizar_pliego",
+            provider="gemini",
+            model="gemini-2.5-flash",
+            status="error",
+            error_message=str(e)[:500],
+            duration_ms=int((time.perf_counter() - started_at) * 1000),
+            metadata={"pdf_count": len(archivos_pdf)}
+        )
         raise HTTPException(status_code=500, detail=str(e))
-
-# --- 5. FUNCIONES DE APOYO PARA CORREOS (HILO SECUNDARIO) ---
-def get_user_credentials(username):
-    row = db.get_user_credentials(username)
-    return (row[0], crypto.decrypt_data(row[1]), row[2]) if row else (None, None, None)
-
-# Prompt compacto: clasifica Y extrae cotizacion en una sola llamada (cero tokens extra)
-PROMPT_CLASIFICADOR_CORREOS = """Eres un asistente de procura. Analiza este correo en relacion a la licitacion {licitacion}.
-Items de referencia: {contexto_items_resumido}
-
-Correo:
-Asunto: {asunto}\nRemitente: {remitente}\nCuerpo: {cuerpo}
-
-Responde SOLO con este JSON (sin texto adicional):
-{{"relacionado": true/false,
-  "resumen": "1 linea de lo que ofrece el proveedor",
-  "renglones": "numeros separados por coma ej: 1, 3",
-  "borrador_respuesta": "correo de respuesta profesional firmado como Departamento de Compras",
-  "cotizaciones": [
-    {{"renglon": "1", "precio_unitario": 0.0, "moneda": "USD", "tiempo_entrega": "30 dias", "condiciones": "FOB"}}
-  ]
-}}
-Si el correo no contiene precios, devuelve cotizaciones como lista vacia [].
-"""
-
-def procesar_correos_background(username: str, servidor_imap: str, licitacion_activa: str, contexto_items: str):
-    email_user, email_pass, gemini_key = get_user_credentials(username)
-    if not email_user or not email_pass:
-        logger.warning(f"Sin credenciales de correo para usuario {username}")
-        return
-
-    try:
-        genai.configure(api_key=gemini_key)
-        # gemini-2.5-flash para clasificación simple de correos
-        model = genai.GenerativeModel('gemini-2.5-flash')
-
-        # Reducir contexto enviado: solo los 3 campos clave, NO la ficha técnica completa
-        try:
-            df_items = pd.read_json(io.StringIO(contexto_items))
-            cols_disponibles = [c for c in ['renglon', 'codigo_articulo', 'termino_de_busqueda_corto'] if c in df_items.columns]
-            contexto_resumido = df_items[cols_disponibles].to_json(orient="records", force_ascii=False)
-        except Exception:
-            contexto_resumido = contexto_items[:500]  # fallback seguro
-
-        mail = imaplib.IMAP4_SSL(servidor_imap)
-        mail.login(email_user, email_pass)
-        mail.select("inbox")
-
-        status, mensajes = mail.search(None, 'ALL')
-        if not mensajes[0]:
-            return
-
-        # Evaluamos los últimos 50 correos, pero enviaremos máximo 15 a Gemini
-        lista_ids = mensajes[0].split()[-50:]
-        correos_enviados_a_gemini = 0
-
-        for id_correo in lista_ids:
-            if correos_enviados_a_gemini >= 15:
-                break
-            res, data = mail.fetch(id_correo, '(RFC822)')
-            for part in data:
-                if isinstance(part, tuple):
-                    msg = email.message_from_bytes(part[1])
-                    subj_raw = decode_header(msg.get("Subject", ""))[0]
-                    asunto = subj_raw[0].decode(subj_raw[1] or 'utf-8', errors='ignore') if isinstance(subj_raw[0], bytes) else str(subj_raw[0])
-                    remitente = msg.get("From", "Desconocido")
-
-                    if db.check_email_exists(licitacion_activa, asunto, remitente):
-                        continue
-
-                    # Pre-filtro inteligente y ahorrador de tokens:
-                    num_lic_clean = "".join(re.findall(r'\d+', licitacion_activa))
-                    
-                    # Evitar procesar correos automáticos o spam obvio
-                    if "no-reply" in remitente.lower() or "newsletter" in remitente.lower() or "marketing" in remitente.lower():
-                        continue
-
-                    # Extraer el cuerpo antes para poder filtrarlo
-                    cuerpo_crudo = ""
-                    if msg.is_multipart():
-                        for p in msg.walk():
-                            if p.get_content_type() == "text/plain":
-                                cuerpo_crudo += p.get_payload(decode=True).decode(errors='ignore')
-                    else:
-                        cuerpo_crudo = msg.get_payload(decode=True).decode(errors='ignore')
-
-                    cuerpo_limpio = " ".join(cuerpo_crudo.split())
-                    
-                    # Chequeo flexible: Si menciona el número de licitación o tiene palabras clave de B2B
-                    # Busca tanto en el Asunto como en los primeros 300 caracteres del correo
-                    texto_busqueda = (asunto + " " + cuerpo_limpio[:300]).upper()
-                    palabras_clave = ["RFQ", "COTIZA", "QUOTE", "PROCURA", "PRECIO", "OFERTA", "SUMINISTRO", "USD", "$", "ATTACH", "ADJUNT", "REQUIREMENT", "TECH", "ESPECIFICACION", "DELIVERY", "ENTREGA"]
-                    
-                    es_relevante = (num_lic_clean in texto_busqueda) or (any(p in texto_busqueda for p in palabras_clave))
-                    
-                    if not es_relevante:
-                        continue
-
-                    # Limitar cuerpo a 1200 chars (antes 2000) - ahorra 40% de tokens de Gemini
-                    cuerpo_ia = cuerpo_limpio[:1200]
-
-                    prompt = PROMPT_CLASIFICADOR_CORREOS.format(
-                        licitacion=licitacion_activa,
-                        contexto_items_resumido=contexto_resumido,
-                        asunto=asunto,
-                        remitente=remitente,
-                        cuerpo=cuerpo_ia
-                    )
-
-                    try:
-                        time.sleep(6)  # 6s entre llamadas — respeta 15 RPM de Gemini Free
-                        res_ia = model.generate_content(prompt)
-                        correos_enviados_a_gemini += 1
-                        texto_ia = res_ia.text.strip().replace("```json", "").replace("```", "").strip()
-                        datos_ia = json.loads(texto_ia)
-
-                        if datos_ia.get("relacionado"):
-                            db.insert_smart_inbox(
-                                licitacion_activa, remitente, asunto,
-                                msg.get("Date"), datos_ia.get('resumen', ''),
-                                datos_ia.get('renglones', ''), cuerpo_limpio,
-                                datos_ia.get('borrador_respuesta', '')
-                            )
-                            logger.info(f"Correo guardado: '{asunto}' para licitación {licitacion_activa}")
-
-                            # Guardar cotizaciones extraídas (si las hay) en tabla comparador
-                            for cot in datos_ia.get('cotizaciones', []):
-                                renglon = str(cot.get('renglon', '')).strip()
-                                proveedor = remitente
-                                precio = float(cot.get('precio_unitario', 0) or 0)
-                                if renglon and precio > 0:
-                                    if not db.check_cotizacion_exists(licitacion_activa, renglon, proveedor):
-                                        db.insert_cotizacion(
-                                            licitacion_activa, renglon, proveedor,
-                                            precio,
-                                            str(cot.get('moneda', 'USD')),
-                                            str(cot.get('tiempo_entrega', 'N/A')),
-                                            str(cot.get('condiciones', '')),
-                                            str(msg.get('Date', '')),
-                                            asunto
-                                        )
-                                        logger.info(f"Cotizacion guardada: Renglón {renglon} | {proveedor} | ${precio}")
-                    except Exception as parse_error:
-                        logger.warning(f"Error procesando correo '{asunto}': {parse_error}")
-                        continue
-
-        mail.logout()
-        logger.info(f"Escaneo de correos finalizado para usuario {username}.")
-
-    except Exception as e:
-        logger.error(f"Error crítico en hilo de correos: {e}")
-
-
-# --- 6. ENDPOINT ASÍNCRONO DE CORREOS ---
-@app.post("/api/v1/organizar-correos")
-def organizar_correos(
-    background_tasks: BackgroundTasks,
-    username: str = Form(...),
-    servidor_imap: str = Form("mail.proyelec.com"),
-    licitacion_activa: str = Form(...),
-    contexto_items: str = Form(...),
-    _token: str = Depends(verify_internal_token)
-):
-    # Validar credenciales de correo sincronamente antes de lanzar la tarea
+
+# --- 5. FUNCIONES DE APOYO PARA CORREOS (HILO SECUNDARIO) ---
+def get_user_credentials(username):
+    row = db.get_user_credentials(username)
+    return (row[0], crypto.decrypt_data(row[1]), row[2]) if row else (None, None, None)
+
+# Prompt compacto: clasifica Y extrae cotizacion en una sola llamada (cero tokens extra)
+PROMPT_CLASIFICADOR_CORREOS = """Eres un asistente de procura. Analiza este correo en relacion a la licitacion {licitacion}.
+Items de referencia: {contexto_items_resumido}
+
+Correo:
+Asunto: {asunto}\nRemitente: {remitente}\nCuerpo: {cuerpo}
+
+Responde SOLO con este JSON (sin texto adicional):
+{{"relacionado": true/false,
+  "resumen": "1 linea de lo que ofrece el proveedor",
+  "renglones": "numeros separados por coma ej: 1, 3",
+  "borrador_respuesta": "correo de respuesta profesional firmado como Departamento de Compras",
+  "cotizaciones": [
+    {{"renglon": "1", "precio_unitario": 0.0, "moneda": "USD", "tiempo_entrega": "30 dias", "condiciones": "FOB"}}
+  ]
+}}
+Si el correo no contiene precios, devuelve cotizaciones como lista vacia [].
+"""
+
+def procesar_correos_background(username: str, servidor_imap: str, licitacion_activa: str, contexto_items: str):
+    email_user, email_pass, gemini_key = get_user_credentials(username)
+    if not email_user or not email_pass:
+        logger.warning(f"Sin credenciales de correo para usuario {username}")
+        return
+
+    try:
+        genai.configure(api_key=gemini_key, transport="rest")
+        # gemini-2.5-flash para clasificación simple de correos
+        model = genai.GenerativeModel('gemini-2.5-flash')
+
+        # Reducir contexto enviado: solo los 3 campos clave, NO la ficha técnica completa
+        try:
+            df_items = pd.read_json(io.StringIO(contexto_items))
+            cols_disponibles = [c for c in ['renglon', 'codigo_articulo', 'termino_de_busqueda_corto'] if c in df_items.columns]
+            contexto_resumido = df_items[cols_disponibles].to_json(orient="records", force_ascii=False)
+        except Exception:
+            contexto_resumido = contexto_items[:500]  # fallback seguro
+
+        mail = imaplib.IMAP4_SSL(servidor_imap)
+        mail.login(email_user, email_pass)
+        mail.select("inbox")
+
+        status, mensajes = mail.search(None, 'ALL')
+        if not mensajes[0]:
+            return
+
+        # Evaluamos los últimos 50 correos, pero enviaremos máximo 15 a Gemini
+        lista_ids = mensajes[0].split()[-50:]
+        correos_enviados_a_gemini = 0
+
+        for id_correo in lista_ids:
+            if correos_enviados_a_gemini >= 15:
+                break
+            res, data = mail.fetch(id_correo, '(RFC822)')
+            for part in data:
+                if isinstance(part, tuple):
+                    msg = email.message_from_bytes(part[1])
+                    subj_raw = decode_header(msg.get("Subject", ""))[0]
+                    asunto = subj_raw[0].decode(subj_raw[1] or 'utf-8', errors='ignore') if isinstance(subj_raw[0], bytes) else str(subj_raw[0])
+                    remitente = msg.get("From", "Desconocido")
+
+                    if db.check_email_exists(licitacion_activa, asunto, remitente):
+                        continue
+
+                    # Pre-filtro inteligente y ahorrador de tokens:
+                    num_lic_clean = "".join(re.findall(r'\d+', licitacion_activa))
+                    
+                    # Evitar procesar correos automáticos o spam obvio
+                    if "no-reply" in remitente.lower() or "newsletter" in remitente.lower() or "marketing" in remitente.lower():
+                        continue
+
+                    # Extraer el cuerpo antes para poder filtrarlo
+                    cuerpo_crudo = ""
+                    if msg.is_multipart():
+                        for p in msg.walk():
+                            if p.get_content_type() == "text/plain":
+                                cuerpo_crudo += p.get_payload(decode=True).decode(errors='ignore')
+                    else:
+                        cuerpo_crudo = msg.get_payload(decode=True).decode(errors='ignore')
+
+                    cuerpo_limpio = " ".join(cuerpo_crudo.split())
+                    
+                    # Chequeo flexible: Si menciona el número de licitación o tiene palabras clave de B2B
+                    # Busca tanto en el Asunto como en los primeros 300 caracteres del correo
+                    texto_busqueda = (asunto + " " + cuerpo_limpio[:300]).upper()
+                    palabras_clave = ["RFQ", "COTIZA", "QUOTE", "PROCURA", "PRECIO", "OFERTA", "SUMINISTRO", "USD", "$", "ATTACH", "ADJUNT", "REQUIREMENT", "TECH", "ESPECIFICACION", "DELIVERY", "ENTREGA"]
+                    
+                    es_relevante = (num_lic_clean in texto_busqueda) or (any(p in texto_busqueda for p in palabras_clave))
+                    
+                    if not es_relevante:
+                        continue
+
+                    # Limitar cuerpo a 1200 chars (antes 2000) - ahorra 40% de tokens de Gemini
+                    cuerpo_ia = cuerpo_limpio[:1200]
+
+                    prompt = PROMPT_CLASIFICADOR_CORREOS.format(
+                        licitacion=licitacion_activa,
+                        contexto_items_resumido=contexto_resumido,
+                        asunto=asunto,
+                        remitente=remitente,
+                        cuerpo=cuerpo_ia
+                    )
+
+                    try:
+                        time.sleep(6)  # 6s entre llamadas — respeta 15 RPM de Gemini Free
+                        res_ia = model.generate_content(prompt)
+                        correos_enviados_a_gemini += 1
+                        texto_ia = res_ia.text.strip().replace("```json", "").replace("```", "").strip()
+                        datos_ia = json.loads(texto_ia)
+
+                        if datos_ia.get("relacionado"):
+                            db.insert_smart_inbox(
+                                licitacion_activa, remitente, asunto,
+                                msg.get("Date"), datos_ia.get('resumen', ''),
+                                datos_ia.get('renglones', ''), cuerpo_limpio,
+                                datos_ia.get('borrador_respuesta', '')
+                            )
+                            logger.info(f"Correo guardado: '{asunto}' para licitación {licitacion_activa}")
+
+                            # Guardar cotizaciones extraídas (si las hay) en tabla comparador
+                            for cot in datos_ia.get('cotizaciones', []):
+                                renglon = str(cot.get('renglon', '')).strip()
+                                proveedor = remitente
+                                precio = float(cot.get('precio_unitario', 0) or 0)
+                                if renglon and precio > 0:
+                                    if not db.check_cotizacion_exists(licitacion_activa, renglon, proveedor):
+                                        db.insert_cotizacion(
+                                            licitacion_activa, renglon, proveedor,
+                                            precio,
+                                            str(cot.get('moneda', 'USD')),
+                                            str(cot.get('tiempo_entrega', 'N/A')),
+                                            str(cot.get('condiciones', '')),
+                                            str(msg.get('Date', '')),
+                                            asunto
+                                        )
+                                        logger.info(f"Cotizacion guardada: Renglón {renglon} | {proveedor} | ${precio}")
+                    except Exception as parse_error:
+                        logger.warning(f"Error procesando correo '{asunto}': {parse_error}")
+                        continue
+
+        mail.logout()
+        logger.info(f"Escaneo de correos finalizado para usuario {username}.")
+
+    except Exception as e:
+        logger.error(f"Error crítico en hilo de correos: {e}")
+
+
+# --- 6. ENDPOINT ASÍNCRONO DE CORREOS ---
+@app.post("/api/v1/organizar-correos")
+def organizar_correos(
+    background_tasks: BackgroundTasks,
+    username: str = Form(...),
+    servidor_imap: str = Form("mail.proyelec.com"),
+    licitacion_activa: str = Form(...),
+    contexto_items: str = Form(...),
+    _token: str = Depends(verify_internal_token)
+):
+    # Validar credenciales de correo sincronamente antes de lanzar la tarea
     email_user, email_pass, _ = get_user_credentials(username)
     if not email_user or not email_pass:
+        db.log_usage_event(username=username, module="email", action="organizar_correos", licitacion=licitacion_activa, status="error", error_message="Credenciales de correo faltantes")
         return {"status": "error", "mensaje": "No has configurado tu correo y contraseña en el panel lateral."}
-    
-    try:
-        import imaplib
-        mail = imaplib.IMAP4_SSL(servidor_imap, timeout=10)
-        mail.login(email_user, email_pass)
-        mail.logout()
+    
+    try:
+        import imaplib
+        mail = imaplib.IMAP4_SSL(servidor_imap, timeout=10)
+        mail.login(email_user, email_pass)
+        mail.logout()
     except imaplib.IMAP4.error as e:
+        db.log_usage_event(username=username, module="email", action="organizar_correos", licitacion=licitacion_activa, status="error", error_message=str(e)[:500])
         return {"status": "error", "mensaje": f"Autenticación rechazada. ¿Usas Office365 o Gmail? Necesitas una 'App Password'. Error: {e}"}
     except Exception as e:
+        db.log_usage_event(username=username, module="email", action="organizar_correos", licitacion=licitacion_activa, status="error", error_message=str(e)[:500])
         return {"status": "error", "mensaje": f"No se pudo conectar al servidor IMAP '{servidor_imap}'. Revisa la dirección del servidor. Error: {e}"}
 
     background_tasks.add_task(procesar_correos_background, username, servidor_imap, licitacion_activa, contexto_items)
+    db.log_usage_event(username=username, module="email", action="organizar_correos", licitacion=licitacion_activa, metadata={"servidor_imap": servidor_imap})
     return {"status": "success", "mensaje": "✅ Conexión exitosa. Gemini está escaneando los correos en segundo plano..."}
-
-
-# --- 7. GENERADOR DE FICHAS TÉCNICAS (CON CACHE) ---
-@app.post("/api/v1/generar-ficha")
-def generar_ficha(
-    username: str = Form(...),
-    licitacion: str = Form(...),
-    codigo_renglon: str = Form(...),
-    pliego_context: str = Form(...),
-    items_context: str = Form(...),
-    gemini_key: str = Form(...),
-    _token: str = Depends(verify_internal_token)
-):
-    # Verificar cache primero — si ya se generó, devolver sin gastar tokens
-    cached = db.get_ficha_cache(username, licitacion, codigo_renglon)
-    if cached:
-        logger.info(f"Ficha para {codigo_renglon} servida desde cache.")
+
+
+# --- 7. GENERADOR DE FICHAS TÉCNICAS (CON CACHE) ---
+@app.post("/api/v1/generar-ficha")
+def generar_ficha(
+    username: str = Form(...),
+    licitacion: str = Form(...),
+    codigo_renglon: str = Form(...),
+    pliego_context: str = Form(...),
+    items_context: str = Form(...),
+    gemini_key: str = Form(...),
+    _token: str = Depends(verify_internal_token)
+):
+    # Verificar cache primero — si ya se generó, devolver sin gastar tokens
+    cached = db.get_ficha_cache(username, licitacion, codigo_renglon)
+    if cached:
+        logger.info(f"Ficha para {codigo_renglon} servida desde cache.")
+        db.log_usage_event(
+            username=username,
+            module="ai",
+            action="generar_ficha_cache",
+            licitacion=licitacion,
+            provider="gemini",
+            model="gemini-2.5-flash",
+            metadata={"codigo_renglon": codigo_renglon}
+        )
         return {"status": "success", "datasheet_md": cached, "from_cache": True}
-
-    try:
-        genai.configure(api_key=gemini_key)
-        model = genai.GenerativeModel('gemini-2.5-flash')
-        prompt = f"""Eres un Ingeniero de Compras especializado. Genera una ficha técnica en formato Markdown para el artículo: {codigo_renglon}.
-Condiciones del Pliego: {pliego_context}
-Detalle del Ítem: {items_context}
-
-La ficha debe contener:
-- **Título y Descripción breve**
-- **Tabla de Especificaciones Técnicas**
-- **Requisitos de Calidad / Certificaciones**
-- **Condiciones especiales de la licitación**
-Formato profesional y estructurado."""
-
-        response = model.generate_content(prompt)
-        datasheet = response.text
-
-        # Guardar en cache para futuras consultas
-        db.save_ficha_cache(username, licitacion, codigo_renglon, datasheet)
+
+    try:
+        genai.configure(api_key=gemini_key, transport="rest")
+        model = genai.GenerativeModel('gemini-2.5-flash')
+        prompt = f"""Eres un Ingeniero de Compras especializado. Genera una ficha técnica en formato Markdown para el artículo: {codigo_renglon}.
+Condiciones del Pliego: {pliego_context}
+Detalle del Ítem: {items_context}
+
+La ficha debe contener:
+- **Título y Descripción breve**
+- **Tabla de Especificaciones Técnicas**
+- **Requisitos de Calidad / Certificaciones**
+- **Condiciones especiales de la licitación**
+Formato profesional y estructurado."""
+
+        response = model.generate_content(prompt)
+        datasheet = response.text
+
+        # Guardar en cache para futuras consultas
+        db.save_ficha_cache(username, licitacion, codigo_renglon, datasheet)
+        db.log_ai_usage(
+            username=username,
+            action="generar_ficha",
+            licitacion=licitacion,
+            model="gemini-2.5-flash",
+            usage_metadata=response.usage_metadata,
+            metadata={"codigo_renglon": codigo_renglon}
+        )
         logger.info(f"Ficha técnica generada y cacheada para {codigo_renglon}.")
-        return {"status": "success", "datasheet_md": datasheet, "from_cache": False}
-
-    except Exception as e:
-        logger.error(f"Error generando ficha: {str(e)}")
+        return {"status": "success", "datasheet_md": datasheet, "from_cache": False}
+
+    except Exception as e:
+        logger.error(f"Error generando ficha: {str(e)}")
+        db.log_usage_event(
+            username=username,
+            module="ai",
+            action="generar_ficha",
+            licitacion=licitacion,
+            provider="gemini",
+            model="gemini-2.5-flash",
+            status="error",
+            error_message=str(e)[:500],
+            metadata={"codigo_renglon": codigo_renglon}
+        )
         raise HTTPException(status_code=500, detail=str(e))
-
-
-# --- 8. ENDPOINTS REST ---
-class LoginRequest(BaseModel):
-    username: str
-    password: str
-
-@app.post("/api/v1/login")
+
+
+# --- 8. ENDPOINTS REST ---
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+@app.post("/api/v1/login")
 def login(req: LoginRequest, _token: str = Depends(verify_internal_token)):
     user = db.get_user(req.username, req.password)
     if user:
+        db.log_usage_event(username=user[0], role=user[2], module="auth", action="api_login")
         return {"status": "success", "username": user[0], "role": user[2]}
+    db.log_usage_event(username=req.username, module="auth", action="api_login", status="error", error_message="Credenciales incorrectas")
     raise HTTPException(status_code=401, detail="Credenciales incorrectas")
-
-@app.get("/api/v1/workspace/{username}")
-def get_workspace(username: str, _token: str = Depends(verify_internal_token)):
-    row = db.load_workspace_state(username)
-    if row and row[0] and row[1]:
-        df = pd.read_json(io.StringIO(row[0]))
-        return {"cg": json.loads(row[1]), "items": df.to_dict(orient="records")}
-    return {"cg": None, "items": []}
-
-@app.get("/api/v1/history/{username}")
-def get_history(username: str, skip: int = 0, limit: int = 50, _token: str = Depends(verify_internal_token)):
-    df = db.get_user_history_df(username)
-    return df.iloc[skip : skip+limit].to_dict(orient="records")
-
-@app.get("/api/v1/inbox/{licitacion}")
-def get_inbox(licitacion: str, skip: int = 0, limit: int = 50, _token: str = Depends(verify_internal_token)):
-    df = db.get_correos_licitacion_df(licitacion)
-    return df.iloc[skip : skip+limit].to_dict(orient="records")
-
-@app.get("/api/v1/configuracion/{username}")
-def get_config(username: str, _token: str = Depends(verify_internal_token)):
-    user_creds = db.get_user_credentials(username)
-    if user_creds:
-        return {"status": "success", "email_user": user_creds[0], "gemini_key": user_creds[2]}
-    return {"status": "error"}
-
-@app.post("/api/v1/configuracion")
-def save_config(
-    username: str = Form(...),
-    gemini_key: str = Form(...),
-    email_user: str = Form(""),
-    email_pass: str = Form(""),
-    _token: str = Depends(verify_internal_token)
-):
-    existing = db.get_user_credentials(username)
-    if not existing:
-        raise HTTPException(status_code=404, detail="Usuario no encontrado")
-
-    enc_pass = existing[1]
-    if email_pass:
-        enc_pass = crypto.encrypt_data(email_pass)
-        
-    existing_tavily = existing[3] if len(existing) > 3 else ""
-
-    db.update_user_profile(username, gemini_key, existing_tavily, email_user, enc_pass)
-    return {"status": "success"}
-
-# =============================================
-# CONSULTA AUTOMATICA AL SLI DE LA ACP
-# =============================================
-
+
+@app.get("/api/v1/workspace/{username}")
+def get_workspace(username: str, _token: str = Depends(verify_internal_token)):
+    row = db.load_workspace_state(username)
+    if row and row[0] and row[1]:
+        df = pd.read_json(io.StringIO(row[0]))
+        return {"cg": json.loads(row[1]), "items": df.to_dict(orient="records")}
+    return {"cg": None, "items": []}
+
+@app.get("/api/v1/history/{username}")
+def get_history(username: str, skip: int = 0, limit: int = 50, _token: str = Depends(verify_internal_token)):
+    df = db.get_user_history_df(username)
+    return df.iloc[skip : skip+limit].to_dict(orient="records")
+
+@app.get("/api/v1/inbox/{licitacion}")
+def get_inbox(licitacion: str, skip: int = 0, limit: int = 50, _token: str = Depends(verify_internal_token)):
+    df = db.get_correos_licitacion_df(licitacion)
+    return df.iloc[skip : skip+limit].to_dict(orient="records")
+
+@app.get("/api/v1/configuracion/{username}")
+def get_config(username: str, _token: str = Depends(verify_internal_token)):
+    user_creds = db.get_user_credentials(username)
+    if user_creds:
+        return {"status": "success", "email_user": user_creds[0], "gemini_key": user_creds[2]}
+    return {"status": "error"}
+
+@app.post("/api/v1/configuracion")
+def save_config(
+    username: str = Form(...),
+    gemini_key: str = Form(...),
+    email_user: str = Form(""),
+    email_pass: str = Form(""),
+    _token: str = Depends(verify_internal_token)
+):
+    existing = db.get_user_credentials(username)
+    if not existing:
+        raise HTTPException(status_code=404, detail="Usuario no encontrado")
+
+    enc_pass = existing[1]
+    if email_pass:
+        enc_pass = crypto.encrypt_data(email_pass)
+        
+    existing_tavily = existing[3] if len(existing) > 3 else ""
+
+    db.update_user_profile(username, gemini_key, existing_tavily, email_user, enc_pass)
+    return {"status": "success"}
+
+# =============================================
+# CONSULTA AUTOMATICA AL SLI DE LA ACP
+# =============================================
+
 @app.get("/api/v1/consultar-sli/{rfq_id}")
 def consultar_sli(rfq_id: str, _token: str = Depends(verify_internal_token)):
+    started_at = time.perf_counter()
     rfq_id = "".join(filter(str.isdigit, str(rfq_id or "")))
     if not rfq_id:
+        db.log_usage_event(module="sli", action="consultar_sli", status="error", error_message="Numero de licitacion invalido")
         raise HTTPException(
             status_code=400,
-            detail={
-                "message": "Numero de licitacion invalido.",
-                "hint": "Ingresa solo el numero RFQ de la licitacion ACP."
-            }
-        )
-
-    SLI_HOME_URL = "https://apps.pancanal.com/sli/LicitacionesBusqueda/Welcome"
-    SLI_URL = f"https://apps.pancanal.com/sli/Licitaciones/LicitacionHeader?rfqId={rfq_id}"
-
-    def extraer_resumen_acta(texto_acta, acta_url):
-        texto_acta = re.sub(r"\s+", " ", texto_acta or "").strip()
-        if not texto_acta:
-            return {
-                "disponible": False,
-                "url": acta_url,
-                "resumen": "",
-                "hallazgos": [],
-                "error": "El acta no contiene texto legible."
-            }
-
-        palabras_clave = [
-            "no cumple", "incumple", "fallo", "falla", "deficiencia",
-            "observacion", "observación", "subsan", "tecnico", "técnico",
-            "rechaz", "descalific", "no acept", "aclaracion", "aclaración"
-        ]
-
-        partes = re.split(r"(?<=[.!?])\s+|\n+", texto_acta)
-        hallazgos = []
-
-        for parte in partes:
-            parte_limpia = parte.strip()
-            parte_lower = parte_limpia.lower()
-            if len(parte_limpia) < 35:
-                continue
-            if any(palabra in parte_lower for palabra in palabras_clave):
-                hallazgos.append(parte_limpia[:450])
-            if len(hallazgos) >= 8:
-                break
-
-        if hallazgos:
-            resumen = "Se detectaron posibles observaciones tecnicas o comentarios relevantes en el acta."
-        elif any(palabra in texto_acta.lower() for palabra in ["cumple", "conforme", "adjudic"]):
-            resumen = "No se detectaron fallos tecnicos evidentes en una lectura automatica del acta."
-        else:
-            resumen = "El acta fue encontrada, pero no se detectaron observaciones tecnicas claras automaticamente."
-
-        return {
-            "disponible": True,
-            "url": acta_url,
-            "resumen": resumen,
-            "hallazgos": hallazgos,
-            "texto_muestra": texto_acta[:1200],
-            "error": None
-        }
-
-    try:
-        from playwright.sync_api import (
-            Error as PlaywrightError,
-            TimeoutError as PlaywrightTimeoutError,
-            sync_playwright,
-        )
-    except ImportError:
-        raise HTTPException(
-            status_code=503,
-            detail={
-                "message": "Playwright no esta instalado.",
-                "hint": "Ejecuta: pip install playwright && playwright install chromium"
-            }
-        )
-
-    browser = None
-    resumen_acta = {
-        "disponible": False,
-        "url": None,
-        "resumen": "",
-        "hallazgos": [],
-        "error": "No se encontro el boton de resumen de propuestas recibidas."
-    }
-
-    try:
-        with sync_playwright() as p:
-            try:
-                browser = p.chromium.launch(
-                    headless=True,
-                    args=[
-                        "--no-sandbox",
-                        "--disable-dev-shm-usage",
-                        "--disable-blink-features=AutomationControlled"
-                    ]
-                )
-            except PlaywrightError as e:
-                msg = str(e)
-                if "Executable doesn't exist" in msg or "playwright install" in msg:
-                    raise HTTPException(
-                        status_code=503,
-                        detail={
-                            "message": "Chromium de Playwright no esta instalado.",
-                            "hint": "Ejecuta: playwright install chromium"
-                        }
-                    )
-                raise
-
-            page = browser.new_page()
-            page.set_default_timeout(15000)
-            page.set_extra_http_headers({
-                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124"
-            })
-
-            response = page.goto(SLI_HOME_URL, wait_until="domcontentloaded", timeout=30000)
-            if response and response.status >= 500:
-                raise HTTPException(
-                    status_code=502,
-                    detail={
-                        "message": f"El SLI respondio con HTTP {response.status}.",
-                        "hint": "El portal de ACP puede estar caido o inestable. Intenta de nuevo mas tarde."
-                    }
-                )
-
-            page.wait_for_selector("#rfqId", timeout=15000)
-            page.fill("#rfqId", rfq_id)
-
-            if page.locator("#hfEstatusSeleccionadoID").count() > 0:
-                page.evaluate(
-                    'document.getElementById("hfEstatusSeleccionadoID").value = "TODOS";'
-                )
-
-            page.click("input[type='submit']")
-
-            try:
-                page.wait_for_function(
-                    "() => document.body.innerText.includes('Detalle de RFQ') || "
-                    "document.body.innerText.includes('EVALUACI') || "
-                    "document.body.innerText.includes('No se encontraron') || "
-                    "document.body.innerText.includes('InternalServer')",
-                    timeout=20000
-                )
-            except PlaywrightTimeoutError:
-                logger.warning(f"Timeout esperando resultados del SLI para RFQ {rfq_id}")
-
-            content = page.content()
-            SLI_URL = page.url
-
-            resumen_visible = page.locator(".ResPropRec").count() > 0
-            po_header_match = re.search(r"po_header\s*[=:]\s*['\"]?(\d+)", content, re.IGNORECASE)
-            if not po_header_match:
-                po_header_match = re.search(r"po_header=(\d+)", content, re.IGNORECASE)
-
-            if resumen_visible and po_header_match:
-                po_header = po_header_match.group(1)
-                acta_url = urljoin(
-                    SLI_URL,
-                    f"../Comunes/ImpresionActaResumen?p_rfq={rfq_id}&po_header={po_header}"
-                )
-
-                try:
-                    acta_response = page.request.get(
-                        acta_url,
-                        headers={"Referer": SLI_URL},
-                        timeout=30000
-                    )
-                    acta_bytes = acta_response.body()
-                    content_type = (acta_response.headers.get("content-type") or "").lower()
-
-                    if "pdf" in content_type or acta_bytes[:4] == b"%PDF":
-                        try:
-                            from pypdf import PdfReader
-
-                            reader = PdfReader(io.BytesIO(acta_bytes))
-                            texto_acta = "\n".join(
-                                page_pdf.extract_text() or ""
-                                for page_pdf in reader.pages
-                            )
-                            resumen_acta = extraer_resumen_acta(texto_acta, acta_url)
-                        except ImportError:
-                            resumen_acta = {
-                                "disponible": False,
-                                "url": acta_url,
-                                "resumen": "",
-                                "hallazgos": [],
-                                "error": "pypdf no esta instalado para leer el PDF del resumen."
-                            }
-                    else:
-                        html_acta = acta_bytes.decode("utf-8", errors="ignore")
-                        texto_acta = BeautifulSoup(html_acta, "html.parser").get_text(
-                            separator=" ",
-                            strip=True
-                        )
-                        resumen_acta = extraer_resumen_acta(texto_acta, acta_url)
-
-                except Exception as e:
-                    logger.warning(f"No se pudo leer acta resumen SLI {rfq_id}: {e}")
-                    resumen_acta = {
-                        "disponible": False,
-                        "url": acta_url,
-                        "resumen": "",
-                        "hallazgos": [],
-                        "error": "Se encontro el resumen, pero no se pudo leer automaticamente."
-                    }
-
-    except HTTPException:
-        raise
-    except PlaywrightTimeoutError as e:
-        logger.warning(f"Timeout consultando SLI {rfq_id}: {e}")
-        raise HTTPException(
-            status_code=504,
-            detail={
-                "message": "El SLI tardo demasiado en responder.",
-                "hint": "Verifica la conexion o intenta nuevamente en unos minutos."
-            }
-        )
-    except PlaywrightError as e:
-        logger.exception(f"Error de Playwright consultando SLI {rfq_id}")
-        raise HTTPException(
-            status_code=502,
-            detail={
-                "message": "No se pudo consultar el portal SLI.",
-                "hint": "El portal pudo cambiar, bloquear la automatizacion o estar temporalmente fuera de servicio.",
-                "technical": str(e)[:500]
-            }
-        )
-    except Exception as e:
-        logger.exception(f"Error inesperado consultando SLI {rfq_id}")
-        raise HTTPException(
-            status_code=500,
-            detail={
-                "message": "Error inesperado consultando el SLI.",
-                "hint": "Revisa backend.log para ver el traceback completo.",
-                "technical": str(e)[:500]
-            }
-        )
-    finally:
-        if browser:
-            try:
-                browser.close()
-            except Exception:
-                pass
-
-    try:
-
-        soup_sli = BeautifulSoup(content, "html.parser")
-
-        texto_sli = soup_sli.get_text(separator="|", strip=True)
-
-        tokens = [t.strip() for t in texto_sli.split("|") if t.strip()]
-
-        def buscar_valor(etiquetas):
-
-            for i, tok in enumerate(tokens):
-
-                for etiq in etiquetas:
-
-                    if (
-                        tok.strip().lower() == etiq.lower()
-                        or tok.strip().lower() == f"{etiq.lower()}:"
-                    ):
-
-                        for j in range(i + 1, min(i + 4, len(tokens))):
-
-                            cand = tokens[j]
-
-                            if (
-                                cand
-                                and not any(
-                                    e.lower() == cand.strip().lower()
-                                    for e in etiquetas
-                                )
-                                and len(cand) > 2
-                            ):
-                                return cand
-
-            return None
-
-        resultado = {
-            "rfq_id": rfq_id,
-            "url": SLI_URL,
-            "estatus": buscar_valor(["Estatus", "Estado"]),
-            "descripcion": buscar_valor(["Descripción", "Descripcion"]),
-            "fecha_cierre": buscar_valor([
-                "Fecha y hora de cierre",
-                "Fecha de cierre",
-                "Cierre"
-            ]),
-            "fecha_publicacion": buscar_valor([
-                "Fecha de publicación",
-                "Publicación",
-                "Publicacion"
-            ]),
-            "ultima_revision": buscar_valor([
-                "Última revisión",
-                "Ultima Revision",
-                "Última Revisión"
-            ]),
-            "agente_compras": buscar_valor([
-                "Agente de compras",
-                "Agente Compras",
-                "Purchasing Agent"
-            ]),
-            "resumen_acta": resumen_acta,
-            "error": None
-        }
-
-        ESTADOS_SLI = [
-            "EVALUACIÓN",
-            "EVALUACION",
-            "ADJUDICACIÓN",
-            "ADJUDICACION",
-            "CANCELACIÓN",
-            "CANCELACION",
-            "ACTO DESIERTO",
-            "DESIERTA",
-            "ENMENDADA",
-            "ANUNCIO VENCIDO",
-            "ABIERTA",
-            "PRECALIFICACIÓN"
-        ]
-
-        if not resultado["estatus"]:
-
-            texto_upper = texto_sli.upper()
-
-            for estado in ESTADOS_SLI:
-
-                if estado in texto_upper:
-                    resultado["estatus"] = estado.title()
-                    break
-
-        if not resultado["estatus"] and not resultado["descripcion"]:
-
-            resultado["error"] = (
-                "No se encontró información. "
-                "Verifica el número de licitación o intenta más tarde."
-            )
-
+            detail={
+                "message": "Numero de licitacion invalido.",
+                "hint": "Ingresa solo el numero RFQ de la licitacion ACP."
+            }
+        )
+
+    SLI_HOME_URL = "https://apps.pancanal.com/sli/LicitacionesBusqueda/Welcome"
+    SLI_URL = f"https://apps.pancanal.com/sli/Licitaciones/LicitacionHeader?rfqId={rfq_id}"
+
+    def extraer_resumen_acta(texto_acta, acta_url):
+        texto_acta = re.sub(r"\s+", " ", texto_acta or "").strip()
+        if not texto_acta:
+            return {
+                "disponible": False,
+                "url": acta_url,
+                "resumen": "",
+                "hallazgos": [],
+                "error": "El acta no contiene texto legible."
+            }
+
+        palabras_clave = [
+            "no cumple", "incumple", "fallo", "falla", "deficiencia",
+            "observacion", "observación", "subsan", "tecnico", "técnico",
+            "rechaz", "descalific", "no acept", "aclaracion", "aclaración"
+        ]
+
+        partes = re.split(r"(?<=[.!?])\s+|\n+", texto_acta)
+        hallazgos = []
+
+        for parte in partes:
+            parte_limpia = parte.strip()
+            parte_lower = parte_limpia.lower()
+            if len(parte_limpia) < 35:
+                continue
+            if any(palabra in parte_lower for palabra in palabras_clave):
+                hallazgos.append(parte_limpia[:450])
+            if len(hallazgos) >= 8:
+                break
+
+        if hallazgos:
+            resumen = "Se detectaron posibles observaciones tecnicas o comentarios relevantes en el acta."
+        elif any(palabra in texto_acta.lower() for palabra in ["cumple", "conforme", "adjudic"]):
+            resumen = "No se detectaron fallos tecnicos evidentes en una lectura automatica del acta."
+        else:
+            resumen = "El acta fue encontrada, pero no se detectaron observaciones tecnicas claras automaticamente."
+
+        return {
+            "disponible": True,
+            "url": acta_url,
+            "resumen": resumen,
+            "hallazgos": hallazgos,
+            "texto_muestra": texto_acta[:1200],
+            "error": None
+        }
+
+    try:
+        from playwright.sync_api import (
+            Error as PlaywrightError,
+            TimeoutError as PlaywrightTimeoutError,
+            sync_playwright,
+        )
+    except ImportError:
+        raise HTTPException(
+            status_code=503,
+            detail={
+                "message": "Playwright no esta instalado.",
+                "hint": "Ejecuta: pip install playwright && playwright install chromium"
+            }
+        )
+
+    browser = None
+    resumen_acta = {
+        "disponible": False,
+        "url": None,
+        "resumen": "",
+        "hallazgos": [],
+        "error": "No se encontro el boton de resumen de propuestas recibidas."
+    }
+
+    try:
+        with sync_playwright() as p:
+            try:
+                browser = p.chromium.launch(
+                    headless=True,
+                    args=[
+                        "--no-sandbox",
+                        "--disable-dev-shm-usage",
+                        "--disable-blink-features=AutomationControlled"
+                    ]
+                )
+            except PlaywrightError as e:
+                msg = str(e)
+                if "Executable doesn't exist" in msg or "playwright install" in msg:
+                    raise HTTPException(
+                        status_code=503,
+                        detail={
+                            "message": "Chromium de Playwright no esta instalado.",
+                            "hint": "Ejecuta: playwright install chromium"
+                        }
+                    )
+                raise
+
+            page = browser.new_page()
+            page.set_default_timeout(15000)
+            page.set_extra_http_headers({
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124"
+            })
+
+            response = page.goto(SLI_HOME_URL, wait_until="domcontentloaded", timeout=30000)
+            if response and response.status >= 500:
+                raise HTTPException(
+                    status_code=502,
+                    detail={
+                        "message": f"El SLI respondio con HTTP {response.status}.",
+                        "hint": "El portal de ACP puede estar caido o inestable. Intenta de nuevo mas tarde."
+                    }
+                )
+
+            page.wait_for_selector("#rfqId", timeout=15000)
+            page.fill("#rfqId", rfq_id)
+
+            if page.locator("#hfEstatusSeleccionadoID").count() > 0:
+                page.evaluate(
+                    'document.getElementById("hfEstatusSeleccionadoID").value = "TODOS";'
+                )
+
+            page.click("input[type='submit']")
+
+            try:
+                page.wait_for_function(
+                    "() => document.body.innerText.includes('Detalle de RFQ') || "
+                    "document.body.innerText.includes('EVALUACI') || "
+                    "document.body.innerText.includes('No se encontraron') || "
+                    "document.body.innerText.includes('InternalServer')",
+                    timeout=20000
+                )
+            except PlaywrightTimeoutError:
+                logger.warning(f"Timeout esperando resultados del SLI para RFQ {rfq_id}")
+
+            content = page.content()
+            SLI_URL = page.url
+
+            resumen_visible = page.locator(".ResPropRec").count() > 0
+            po_header_match = re.search(r"po_header\s*[=:]\s*['\"]?(\d+)", content, re.IGNORECASE)
+            if not po_header_match:
+                po_header_match = re.search(r"po_header=(\d+)", content, re.IGNORECASE)
+
+            if resumen_visible and po_header_match:
+                po_header = po_header_match.group(1)
+                acta_url = urljoin(
+                    SLI_URL,
+                    f"../Comunes/ImpresionActaResumen?p_rfq={rfq_id}&po_header={po_header}"
+                )
+
+                try:
+                    acta_response = page.request.get(
+                        acta_url,
+                        headers={"Referer": SLI_URL},
+                        timeout=30000
+                    )
+                    acta_bytes = acta_response.body()
+                    content_type = (acta_response.headers.get("content-type") or "").lower()
+
+                    if "pdf" in content_type or acta_bytes[:4] == b"%PDF":
+                        try:
+                            from pypdf import PdfReader
+
+                            reader = PdfReader(io.BytesIO(acta_bytes))
+                            texto_acta = "\n".join(
+                                page_pdf.extract_text() or ""
+                                for page_pdf in reader.pages
+                            )
+                            resumen_acta = extraer_resumen_acta(texto_acta, acta_url)
+                        except ImportError:
+                            resumen_acta = {
+                                "disponible": False,
+                                "url": acta_url,
+                                "resumen": "",
+                                "hallazgos": [],
+                                "error": "pypdf no esta instalado para leer el PDF del resumen."
+                            }
+                    else:
+                        html_acta = acta_bytes.decode("utf-8", errors="ignore")
+                        texto_acta = BeautifulSoup(html_acta, "html.parser").get_text(
+                            separator=" ",
+                            strip=True
+                        )
+                        resumen_acta = extraer_resumen_acta(texto_acta, acta_url)
+
+                except Exception as e:
+                    logger.warning(f"No se pudo leer acta resumen SLI {rfq_id}: {e}")
+                    resumen_acta = {
+                        "disponible": False,
+                        "url": acta_url,
+                        "resumen": "",
+                        "hallazgos": [],
+                        "error": "Se encontro el resumen, pero no se pudo leer automaticamente."
+                    }
+
+    except HTTPException:
+        raise
+    except PlaywrightTimeoutError as e:
+        logger.warning(f"Timeout consultando SLI {rfq_id}: {e}")
+        raise HTTPException(
+            status_code=504,
+            detail={
+                "message": "El SLI tardo demasiado en responder.",
+                "hint": "Verifica la conexion o intenta nuevamente en unos minutos."
+            }
+        )
+    except PlaywrightError as e:
+        logger.exception(f"Error de Playwright consultando SLI {rfq_id}")
+        raise HTTPException(
+            status_code=502,
+            detail={
+                "message": "No se pudo consultar el portal SLI.",
+                "hint": "El portal pudo cambiar, bloquear la automatizacion o estar temporalmente fuera de servicio.",
+                "technical": str(e)[:500]
+            }
+        )
+    except Exception as e:
+        logger.exception(f"Error inesperado consultando SLI {rfq_id}")
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "message": "Error inesperado consultando el SLI.",
+                "hint": "Revisa backend.log para ver el traceback completo.",
+                "technical": str(e)[:500]
+            }
+        )
+    finally:
+        if browser:
+            try:
+                browser.close()
+            except Exception:
+                pass
+
+    try:
+
+        soup_sli = BeautifulSoup(content, "html.parser")
+
+        texto_sli = soup_sli.get_text(separator="|", strip=True)
+
+        tokens = [t.strip() for t in texto_sli.split("|") if t.strip()]
+
+        def buscar_valor(etiquetas):
+
+            for i, tok in enumerate(tokens):
+
+                for etiq in etiquetas:
+
+                    if (
+                        tok.strip().lower() == etiq.lower()
+                        or tok.strip().lower() == f"{etiq.lower()}:"
+                    ):
+
+                        for j in range(i + 1, min(i + 4, len(tokens))):
+
+                            cand = tokens[j]
+
+                            if (
+                                cand
+                                and not any(
+                                    e.lower() == cand.strip().lower()
+                                    for e in etiquetas
+                                )
+                                and len(cand) > 2
+                            ):
+                                return cand
+
+            return None
+
+        resultado = {
+            "rfq_id": rfq_id,
+            "url": SLI_URL,
+            "estatus": buscar_valor(["Estatus", "Estado"]),
+            "descripcion": buscar_valor(["Descripción", "Descripcion"]),
+            "fecha_cierre": buscar_valor([
+                "Fecha y hora de cierre",
+                "Fecha de cierre",
+                "Cierre"
+            ]),
+            "fecha_publicacion": buscar_valor([
+                "Fecha de publicación",
+                "Publicación",
+                "Publicacion"
+            ]),
+            "ultima_revision": buscar_valor([
+                "Última revisión",
+                "Ultima Revision",
+                "Última Revisión"
+            ]),
+            "agente_compras": buscar_valor([
+                "Agente de compras",
+                "Agente Compras",
+                "Purchasing Agent"
+            ]),
+            "resumen_acta": resumen_acta,
+            "error": None
+        }
+
+        ESTADOS_SLI = [
+            "EVALUACIÓN",
+            "EVALUACION",
+            "ADJUDICACIÓN",
+            "ADJUDICACION",
+            "CANCELACIÓN",
+            "CANCELACION",
+            "ACTO DESIERTO",
+            "DESIERTA",
+            "ENMENDADA",
+            "ANUNCIO VENCIDO",
+            "ABIERTA",
+            "PRECALIFICACIÓN"
+        ]
+
+        if not resultado["estatus"]:
+
+            texto_upper = texto_sli.upper()
+
+            for estado in ESTADOS_SLI:
+
+                if estado in texto_upper:
+                    resultado["estatus"] = estado.title()
+                    break
+
+        if not resultado["estatus"] and not resultado["descripcion"]:
+
+            resultado["error"] = (
+                "No se encontró información. "
+                "Verifica el número de licitación o intenta más tarde."
+            )
+
         logger.info(
             f"Consulta SLI {rfq_id}: "
             f"estatus={resultado['estatus']} | "
             f"desc={resultado['descripcion']}"
         )
+        db.log_usage_event(
+            module="sli",
+            action="consultar_sli",
+            licitacion=rfq_id,
+            status="error" if resultado.get("error") else "success",
+            error_message=resultado.get("error") or "",
+            duration_ms=int((time.perf_counter() - started_at) * 1000),
+            metadata={
+                "estatus": resultado.get("estatus"),
+                "descripcion_detectada": bool(resultado.get("descripcion")),
+                "acta_disponible": bool((resultado.get("resumen_acta") or {}).get("disponible"))
+            }
+        )
 
         return resultado
     except Exception as e:
         logger.exception(f"Error parseando respuesta SLI {rfq_id}")
-        raise HTTPException(
-            status_code=500,
-            detail={
-                "message": "El SLI respondio, pero no se pudo interpretar la pagina.",
-                "hint": "Puede haber cambiado el formato del portal ACP.",
-                "technical": str(e)[:500]
-            }
+        db.log_usage_event(
+            module="sli",
+            action="consultar_sli",
+            licitacion=rfq_id,
+            status="error",
+            error_message=str(e)[:500],
+            duration_ms=int((time.perf_counter() - started_at) * 1000)
         )
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "message": "El SLI respondio, pero no se pudo interpretar la pagina.",
+                "hint": "Puede haber cambiado el formato del portal ACP.",
+                "technical": str(e)[:500]
+            }
+        )

database.py

@@ -1,13 +1,16 @@
-import psycopg2
-import pandas as pd
-from datetime import datetime, timedelta
-import os
-import bcrypt
-import crypto
-import warnings
+import psycopg2
+from psycopg2.extras import execute_values
+import pandas as pd
+from datetime import datetime, timedelta
+import os
+import json
+import bcrypt
+import crypto
+import warnings
 
-# Suprimir advertencias de Pandas al usar psycopg2 directo
-warnings.filterwarnings("ignore", category=UserWarning, module="pandas")
+# Suprimir advertencias de Pandas al usar psycopg2 directo
+warnings.filterwarnings("ignore", category=UserWarning, module="pandas")
+warnings.filterwarnings("ignore", message="pandas only supports SQLAlchemy.*")
 
 DATABASE_URL = os.getenv("DATABASE_URL")
 
@@ -15,9 +18,10 @@ MAX_INTENTOS   = 5        # Intentos fallidos antes de bloquear
 TIEMPO_BLOQUEO = 15      # Minutos de bloqueo
 
 def get_connection():
-    if not DATABASE_URL:
+    db_url = os.getenv("DATABASE_URL") or DATABASE_URL
+    if not db_url:
         raise ValueError("Falta DATABASE_URL en las variables de entorno")
-    conn = psycopg2.connect(DATABASE_URL)
+    conn = psycopg2.connect(db_url)
     return conn
 
 def init_db():
@@ -150,6 +154,125 @@ def init_db():
         hashed_pw = bcrypt.hashpw(b"admin", salt).decode('utf-8')
         c.execute("INSERT INTO users VALUES ('admin', %s, 'Gerencia', '', '', '', '')", (hashed_pw,))
 
+
+    # Metrics de consumo
+    c.execute('''CREATE TABLE IF NOT EXISTS metrics_log (
+        id SERIAL PRIMARY KEY,
+        timestamp TEXT,
+        username TEXT,
+        action TEXT,
+        tokens INTEGER
+    )''')
+
+    # Metricas operativas enriquecidas para Supabase/Postgres.
+    # Mantiene detalle por usuario, modulo, funcion, licitacion y estado.
+    c.execute('''CREATE TABLE IF NOT EXISTS usage_metrics (
+        id SERIAL PRIMARY KEY,
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        username TEXT,
+        role TEXT,
+        module TEXT NOT NULL,
+        action TEXT NOT NULL,
+        licitacion TEXT,
+        provider TEXT,
+        model TEXT,
+        tokens_input INTEGER DEFAULT 0,
+        tokens_output INTEGER DEFAULT 0,
+        tokens_total INTEGER DEFAULT 0,
+        estimated_cost_usd NUMERIC(12, 6) DEFAULT 0,
+        status TEXT DEFAULT 'success',
+        error_message TEXT,
+        duration_ms INTEGER,
+        metadata JSONB DEFAULT '{}'::jsonb
+    )''')
+    c.execute("CREATE INDEX IF NOT EXISTS idx_usage_metrics_created_at ON usage_metrics(created_at DESC)")
+    c.execute("CREATE INDEX IF NOT EXISTS idx_usage_metrics_user ON usage_metrics(username)")
+    c.execute("CREATE INDEX IF NOT EXISTS idx_usage_metrics_module_action ON usage_metrics(module, action)")
+    c.execute("CREATE INDEX IF NOT EXISTS idx_usage_metrics_licitacion ON usage_metrics(licitacion)")
+
+    # Historico de licitaciones importado desde el Excel corporativo.
+    # Permite retirar el archivo fisico del repo y consultar precios/records desde Supabase.
+    c.execute('''CREATE TABLE IF NOT EXISTS historico_licitaciones (
+        id SERIAL PRIMARY KEY,
+        numero_licitacion TEXT,
+        mes TEXT,
+        anio INTEGER,
+        codigo_acp TEXT,
+        codigo_match TEXT,
+        cantidad NUMERIC(14, 2),
+        precio_proyelec NUMERIC(14, 4),
+        precio_competencia NUMERIC(14, 4),
+        adjudicada_a_proyelec TEXT,
+        analista_procura TEXT,
+        observaciones TEXT,
+        fuente TEXT DEFAULT 'excel_historico',
+        imported_at TIMESTAMPTZ DEFAULT NOW(),
+        UNIQUE(numero_licitacion, anio, codigo_acp, cantidad, precio_proyelec)
+    )''')
+    c.execute("CREATE INDEX IF NOT EXISTS idx_historico_codigo_match ON historico_licitaciones(codigo_match)")
+    c.execute("CREATE INDEX IF NOT EXISTS idx_historico_numero_anio ON historico_licitaciones(numero_licitacion, anio)")
+    c.execute("CREATE INDEX IF NOT EXISTS idx_historico_anio ON historico_licitaciones(anio)")
+
+    # Tarifas por modelo/API. Mantener aqui permite ajustar costos sin tocar codigo.
+    c.execute('''CREATE TABLE IF NOT EXISTS api_pricing (
+        model TEXT PRIMARY KEY,
+        provider TEXT NOT NULL,
+        plan TEXT DEFAULT 'standard',
+        currency TEXT DEFAULT 'USD',
+        input_price_per_million NUMERIC(12, 6) DEFAULT 0,
+        output_price_per_million NUMERIC(12, 6) DEFAULT 0,
+        cache_price_per_million NUMERIC(12, 6) DEFAULT 0,
+        search_price_per_1000 NUMERIC(12, 6) DEFAULT 0,
+        source_url TEXT,
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+    )''')
+    c.execute("""INSERT INTO api_pricing
+        (model, provider, plan, currency, input_price_per_million, output_price_per_million,
+         cache_price_per_million, search_price_per_1000, source_url)
+        VALUES
+        ('gemini-2.5-flash', 'gemini', 'standard', 'USD', 0.30, 2.50, 0.03, 35.00, 'https://ai.google.dev/gemini-api/docs/pricing'),
+        ('gemini-2.5-flash-lite', 'gemini', 'standard', 'USD', 0.10, 0.40, 0.01, 35.00, 'https://ai.google.dev/gemini-api/docs/pricing')
+        ON CONFLICT (model) DO UPDATE SET
+            provider = EXCLUDED.provider,
+            plan = EXCLUDED.plan,
+            currency = EXCLUDED.currency,
+            input_price_per_million = EXCLUDED.input_price_per_million,
+            output_price_per_million = EXCLUDED.output_price_per_million,
+            cache_price_per_million = EXCLUDED.cache_price_per_million,
+            search_price_per_1000 = EXCLUDED.search_price_per_1000,
+            source_url = EXCLUDED.source_url,
+            updated_at = NOW()
+    """)
+
+    # === RADAR DE LICITACIONES SLI ===
+    c.execute('''CREATE TABLE IF NOT EXISTS radar_licitaciones (
+        id SERIAL PRIMARY KEY,
+        numero_licitacion TEXT UNIQUE NOT NULL,
+        objeto TEXT,
+        categoria TEXT,
+        monto_estimado REAL DEFAULT 0,
+        moneda TEXT DEFAULT 'USD',
+        fecha_apertura TEXT,
+        fecha_cierre TEXT,
+        link_sli TEXT,
+        es_prioritaria BOOLEAN DEFAULT FALSE,
+        fecha_descubierta TEXT,
+        fecha_ultimo_escaneo TEXT,
+        score_interes INTEGER DEFAULT 0,
+        estado_radar TEXT DEFAULT 'nueva',
+        revisada_por TEXT,
+        notas TEXT
+    )''')
+
+    # Log de escaneos del radar
+    c.execute('''CREATE TABLE IF NOT EXISTS radar_escaneos (
+        id SERIAL PRIMARY KEY,
+        fecha TEXT,
+        total_encontradas INTEGER DEFAULT 0,
+        nuevas INTEGER DEFAULT 0,
+        errores TEXT
+    )''')
+
     conn.commit()
     conn.close()
 
@@ -157,7 +280,194 @@ def init_db():
 # WORKSPACES (MÚLTIPLES POR USUARIO)
 # =============================================
 
-def save_workspace(username, licitacion, data_json, cg_json):
+# =============================================
+# HISTORICO CORPORATIVO DE LICITACIONES
+# =============================================
+
+def _clean_codigo_match(value):
+    return "".join(ch for ch in str(value or "").upper() if ch.isascii() and ch.isalnum())
+
+def _clean_text(value):
+    if pd.isna(value):
+        return ""
+    return str(value).strip()
+
+def _to_float_or_none(value):
+    if pd.isna(value) or value == "":
+        return None
+    try:
+        return float(value)
+    except Exception:
+        cleaned = str(value).replace(",", "").replace("$", "").strip()
+        try:
+            return float(cleaned)
+        except Exception:
+            return None
+
+def _to_int_or_none(value):
+    if pd.isna(value) or value == "":
+        return None
+    try:
+        return int(float(value))
+    except Exception:
+        return None
+
+def normalize_historico_excel_df(df):
+    df = df.rename(columns=lambda x: str(x).strip())
+    rename_map = {
+        "N° DE LIC": "numero_licitacion",
+        "N° DE LIC": "numero_licitacion",
+        "Nº DE LIC": "numero_licitacion",
+        "CODIGO ACP": "codigo_acp",
+        "MES": "mes",
+        "AÑO": "anio",
+        "AÑO": "anio",
+        "CANT": "cantidad",
+        "PRECIO PROYELEC": "precio_proyelec",
+        "PRECIO COMPETENCIA": "precio_competencia",
+        "ADJUDICADA A PROYELEC": "adjudicada_a_proyelec",
+        "ANALISTA DE PROCURA": "analista_procura",
+        "OBSERVACIONES": "observaciones",
+    }
+    df = df.rename(columns={k: v for k, v in rename_map.items() if k in df.columns})
+    expected = [
+        "numero_licitacion", "mes", "anio", "codigo_acp", "cantidad",
+        "precio_proyelec", "precio_competencia", "adjudicada_a_proyelec",
+        "analista_procura", "observaciones",
+    ]
+    for col in expected:
+        if col not in df.columns:
+            df[col] = None
+
+    out = df[expected].copy()
+    out = out.dropna(how="all", subset=["numero_licitacion", "codigo_acp", "precio_proyelec", "precio_competencia"])
+    out["numero_licitacion"] = out["numero_licitacion"].apply(lambda v: _clean_text(v).replace(".0", ""))
+    out["mes"] = out["mes"].apply(_clean_text)
+    out["codigo_acp"] = out["codigo_acp"].apply(_clean_text)
+    out["codigo_match"] = out["codigo_acp"].apply(_clean_codigo_match)
+    out["anio"] = out["anio"].apply(_to_int_or_none)
+    out["cantidad"] = out["cantidad"].apply(_to_float_or_none)
+    out["precio_proyelec"] = out["precio_proyelec"].apply(_to_float_or_none)
+    out["precio_competencia"] = out["precio_competencia"].apply(_to_float_or_none)
+    out["adjudicada_a_proyelec"] = out["adjudicada_a_proyelec"].apply(_clean_text)
+    out["analista_procura"] = out["analista_procura"].apply(_clean_text)
+    out["observaciones"] = out["observaciones"].apply(_clean_text)
+    out = out[out["codigo_match"] != ""]
+    out = out.drop_duplicates(
+        subset=["numero_licitacion", "anio", "codigo_acp", "cantidad", "precio_proyelec"],
+        keep="last",
+    )
+    return out
+
+def import_historico_excel_to_db(excel_path="ACP DATA LIC PASADAS v2_2.xlsx", replace=False):
+    df = pd.read_excel(excel_path, skiprows=8)
+    df = normalize_historico_excel_df(df)
+    conn = get_connection()
+    c = conn.cursor()
+    if replace:
+        c.execute("DELETE FROM historico_licitaciones")
+    values = [
+        (
+            row.get("numero_licitacion"), row.get("mes"), row.get("anio"),
+            row.get("codigo_acp"), row.get("codigo_match"), row.get("cantidad"),
+            row.get("precio_proyelec"), row.get("precio_competencia"),
+            row.get("adjudicada_a_proyelec"), row.get("analista_procura"),
+            row.get("observaciones"),
+        )
+        for row in df.to_dict("records")
+    ]
+    execute_values(c, """
+        INSERT INTO historico_licitaciones
+            (numero_licitacion, mes, anio, codigo_acp, codigo_match, cantidad,
+             precio_proyelec, precio_competencia, adjudicada_a_proyelec,
+             analista_procura, observaciones)
+        VALUES %s
+        ON CONFLICT (numero_licitacion, anio, codigo_acp, cantidad, precio_proyelec)
+        DO UPDATE SET
+            mes = EXCLUDED.mes,
+            codigo_match = EXCLUDED.codigo_match,
+            precio_competencia = EXCLUDED.precio_competencia,
+            adjudicada_a_proyelec = EXCLUDED.adjudicada_a_proyelec,
+            analista_procura = EXCLUDED.analista_procura,
+            observaciones = EXCLUDED.observaciones,
+            imported_at = NOW()
+    """, values, page_size=1000)
+    conn.commit()
+    conn.close()
+    return {"rows_source": int(len(df)), "rows_processed": int(len(df)), "replace": bool(replace)}
+
+def get_historico_licitaciones_df(limit=5000, search=None, anio=None):
+    conn = get_connection()
+    params = []
+    filters = []
+    if search:
+        q = f"%{search}%"
+        filters.append("(numero_licitacion ILIKE %s OR codigo_acp ILIKE %s OR observaciones ILIKE %s)")
+        params.extend([q, q, q])
+    if anio and str(anio) != "Todos":
+        filters.append("anio = %s")
+        params.append(int(anio))
+    where_clause = ("WHERE " + " AND ".join(filters)) if filters else ""
+    params.append(int(limit))
+    df = pd.read_sql_query(f"""
+        SELECT numero_licitacion AS "N° Licitación",
+               anio AS "Año",
+               mes AS "Mes",
+               codigo_acp AS "Código ACP",
+               cantidad AS "Cantidad",
+               precio_proyelec AS "Precio Proyelec",
+               precio_competencia AS "Precio Competencia",
+               adjudicada_a_proyelec AS "Adjudicada a Proyelec",
+               analista_procura AS "Analista",
+               observaciones AS "Observaciones"
+        FROM historico_licitaciones
+        {where_clause}
+        ORDER BY anio DESC NULLS LAST, numero_licitacion DESC NULLS LAST
+        LIMIT %s
+    """, conn, params=tuple(params))
+    conn.close()
+    return df
+
+def get_historico_anios():
+    conn = get_connection()
+    df = pd.read_sql_query("""
+        SELECT DISTINCT anio
+        FROM historico_licitaciones
+        WHERE anio IS NOT NULL
+        ORDER BY anio DESC
+    """, conn)
+    conn.close()
+    return df["anio"].dropna().astype(int).tolist() if not df.empty else []
+
+def get_historical_prices_df():
+    conn = get_connection()
+    df = pd.read_sql_query("""
+        SELECT DISTINCT ON (codigo_match)
+               codigo_match,
+               precio_competencia AS "PRECIO COMPETENCIA",
+               precio_proyelec AS "PRECIO PROYELEC",
+               numero_licitacion AS licitacion_hist,
+               anio AS anio_hist
+        FROM historico_licitaciones
+        WHERE codigo_match IS NOT NULL
+          AND codigo_match <> ''
+          AND (precio_competencia IS NOT NULL OR precio_proyelec IS NOT NULL)
+        ORDER BY codigo_match,
+                 anio DESC NULLS LAST,
+                 imported_at DESC
+    """, conn)
+    conn.close()
+    return df
+
+def get_historico_count():
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("SELECT COUNT(*) FROM historico_licitaciones")
+    count = c.fetchone()[0]
+    conn.close()
+    return int(count or 0)
+
+def save_workspace(username, licitacion, data_json, cg_json):
     """Guarda o actualiza el workspace de una licitación específica."""
     conn = get_connection()
     c = conn.cursor()
@@ -529,3 +839,513 @@ def eliminar_seguimiento(licitacion_id):
     conn.commit()
     conn.close()
 
+
+
+def get_api_pricing_df():
+    conn = get_connection()
+    df = pd.read_sql_query(
+        """SELECT model, provider, plan, currency, input_price_per_million,
+                  output_price_per_million, cache_price_per_million,
+                  search_price_per_1000, source_url, updated_at
+           FROM api_pricing ORDER BY provider, model""",
+        conn
+    )
+    conn.close()
+    return df
+
+def get_api_pricing(model):
+    if not model:
+        return None
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("""SELECT input_price_per_million, output_price_per_million,
+                        cache_price_per_million, search_price_per_1000, currency, plan
+                 FROM api_pricing WHERE model=%s""", (model,))
+    row = c.fetchone()
+    conn.close()
+    return row
+
+def calculate_api_cost(model, tokens_input=0, tokens_output=0, cache_tokens=0, search_requests=0):
+    """Calcula costo billable estimado con tarifas guardadas en api_pricing."""
+    pricing = get_api_pricing(model)
+    if not pricing:
+        return 0.0
+
+    input_price, output_price, cache_price, search_price, _, _ = pricing
+    tokens_input = int(tokens_input or 0)
+    tokens_output = int(tokens_output or 0)
+    cache_tokens = int(cache_tokens or 0)
+    search_requests = int(search_requests or 0)
+
+    cost = 0.0
+    cost += (tokens_input / 1_000_000) * float(input_price or 0)
+    cost += (tokens_output / 1_000_000) * float(output_price or 0)
+    cost += (cache_tokens / 1_000_000) * float(cache_price or 0)
+    cost += (search_requests / 1_000) * float(search_price or 0)
+    return round(cost, 6)
+
+def extract_usage_counts(usage_metadata):
+    """Normaliza usage_metadata de Gemini a input/output/total tokens."""
+    if not usage_metadata:
+        return 0, 0, 0
+
+    def read_attr(*names):
+        for name in names:
+            if isinstance(usage_metadata, dict) and name in usage_metadata:
+                return usage_metadata.get(name) or 0
+            if hasattr(usage_metadata, name):
+                return getattr(usage_metadata, name) or 0
+        return 0
+
+    input_tokens = read_attr("prompt_token_count", "input_token_count")
+    output_tokens = read_attr("candidates_token_count", "output_token_count")
+    total_tokens = read_attr("total_token_count")
+    if not total_tokens:
+        total_tokens = int(input_tokens or 0) + int(output_tokens or 0)
+    if not output_tokens and total_tokens and input_tokens:
+        output_tokens = max(int(total_tokens) - int(input_tokens), 0)
+    return int(input_tokens or 0), int(output_tokens or 0), int(total_tokens or 0)
+
+def log_usage_event(username="", role="", module="general", action="", licitacion="",
+                    provider="", model="", tokens_input=0, tokens_output=0,
+                    tokens_total=0, estimated_cost_usd=None, status="success",
+                    error_message="", duration_ms=None, metadata=None):
+    """Registra un evento operativo. Nunca debe romper el flujo principal."""
+    if metadata is None:
+        metadata = {}
+    tokens_input = int(tokens_input or 0)
+    tokens_output = int(tokens_output or 0)
+    tokens_total = int(tokens_total or 0)
+    if not tokens_total:
+        tokens_total = tokens_input + tokens_output
+    if estimated_cost_usd is None:
+        estimated_cost_usd = calculate_api_cost(
+            model=model,
+            tokens_input=tokens_input,
+            tokens_output=tokens_output,
+            cache_tokens=int(metadata.get("cache_tokens", 0) or 0) if isinstance(metadata, dict) else 0,
+            search_requests=int(metadata.get("search_requests", 0) or 0) if isinstance(metadata, dict) else 0,
+        )
+
+    conn = None
+    try:
+        conn = get_connection()
+        c = conn.cursor()
+        c.execute("""INSERT INTO usage_metrics
+            (username, role, module, action, licitacion, provider, model,
+             tokens_input, tokens_output, tokens_total, estimated_cost_usd,
+             status, error_message, duration_ms, metadata)
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s::jsonb)""",
+            (username or "", role or "", module or "general", action or "",
+             licitacion or "", provider or "", model or "",
+             tokens_input, tokens_output, tokens_total,
+             estimated_cost_usd, status or "success", error_message or "",
+             duration_ms, json.dumps(metadata, ensure_ascii=False)))
+        conn.commit()
+    except Exception as e:
+        print(f"[METRICS] No se pudo registrar evento: {e}")
+    finally:
+        if conn:
+            conn.close()
+
+def log_metric(username, action, tokens):
+    """Compatibilidad con llamadas existentes; tambien alimenta usage_metrics."""
+    conn = None
+    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    try:
+        conn = get_connection()
+        c = conn.cursor()
+        c.execute("INSERT INTO metrics_log (timestamp, username, action, tokens) VALUES (%s, %s, %s, %s)",
+                  (now, username, action, int(tokens or 0)))
+        conn.commit()
+    except Exception as e:
+        print(f"[METRICS_LOG] No se pudo registrar legacy metric: {e}")
+    finally:
+        if conn:
+            conn.close()
+
+    log_usage_event(
+        username=username,
+        module="ai",
+        action=action,
+        provider="gemini",
+        model="gemini-2.5-flash",
+        tokens_total=int(tokens or 0),
+        metadata={"legacy_action": action, "cost_accuracy": "legacy_total_only"}
+    )
+
+def log_ai_usage(username="", role="", action="", licitacion="", model="gemini-2.5-flash",
+                 usage_metadata=None, status="success", error_message="", duration_ms=None,
+                 metadata=None):
+    tokens_input, tokens_output, tokens_total = extract_usage_counts(usage_metadata)
+    metadata = metadata or {}
+    metadata.setdefault("cost_accuracy", "input_output_tokens")
+    log_usage_event(
+        username=username,
+        role=role,
+        module="ai",
+        action=action,
+        licitacion=licitacion,
+        provider="gemini",
+        model=model,
+        tokens_input=tokens_input,
+        tokens_output=tokens_output,
+        tokens_total=tokens_total,
+        status=status,
+        error_message=error_message,
+        duration_ms=duration_ms,
+        metadata=metadata,
+    )
+
+def get_metrics_data():
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("SELECT timestamp, username, action, tokens FROM metrics_log ORDER BY id DESC")
+    rows = c.fetchall()
+    conn.close()
+    return rows
+
+def get_usage_metrics_df(days=90, username=None, module=None):
+    conn = get_connection()
+    params = [int(days)]
+    filters = ["created_at >= NOW() - (%s * INTERVAL '1 day')"]
+    if username and username != "Todos":
+        filters.append("username = %s")
+        params.append(username)
+    if module and module != "Todos":
+        filters.append("module = %s")
+        params.append(module)
+
+    where_clause = " AND ".join(filters)
+    df = pd.read_sql_query(f"""
+        SELECT id, created_at, username, role, module, action, licitacion,
+               provider, model, tokens_input, tokens_output, tokens_total,
+               estimated_cost_usd, status, error_message, duration_ms
+        FROM usage_metrics
+        WHERE {where_clause}
+        ORDER BY created_at DESC
+    """, conn, params=tuple(params))
+    conn.close()
+    return df
+
+def get_usage_filter_options(days=180):
+    df = get_usage_metrics_df(days)
+    users = sorted([u for u in df["username"].dropna().unique().tolist() if str(u).strip()]) if not df.empty else []
+    modules = sorted([m for m in df["module"].dropna().unique().tolist() if str(m).strip()]) if not df.empty else []
+    return {
+        "users": ["Todos"] + users,
+        "modules": ["Todos"] + modules,
+    }
+
+def get_usage_summary(days=30, username=None, module=None):
+    df = get_usage_metrics_df(days, username=username, module=module)
+    if df.empty:
+        return {
+            "total_events": 0,
+            "active_users": 0,
+            "active_licitaciones": 0,
+            "tokens_total": 0,
+            "estimated_cost_usd": 0.0,
+            "errors": 0,
+            "peak_users_hour": 0,
+            "uncosted_events": 0,
+            "df": df,
+            "by_module": pd.DataFrame(),
+            "by_user": pd.DataFrame(),
+            "by_day": pd.DataFrame(),
+            "by_month": pd.DataFrame(),
+            "by_hour": pd.DataFrame(),
+            "by_status": pd.DataFrame(),
+        }
+
+    df["created_at"] = pd.to_datetime(df["created_at"], errors="coerce", utc=True).dt.tz_convert(None)
+    df["estimated_cost_usd"] = pd.to_numeric(df["estimated_cost_usd"], errors="coerce").fillna(0)
+    df["tokens_input"] = pd.to_numeric(df["tokens_input"], errors="coerce").fillna(0).astype(int)
+    df["tokens_output"] = pd.to_numeric(df["tokens_output"], errors="coerce").fillna(0).astype(int)
+    df["tokens_total"] = pd.to_numeric(df["tokens_total"], errors="coerce").fillna(0).astype(int)
+    legacy_total_only = (
+        (df["module"] == "ai")
+        & (df["tokens_total"] > 0)
+        & ((df["tokens_input"] + df["tokens_output"]) == 0)
+    )
+    df["cost_is_real"] = ~legacy_total_only
+    df.loc[legacy_total_only, "estimated_cost_usd"] = 0
+    by_module = df.groupby(["module", "action"], dropna=False).agg(
+        eventos=("id", "count"),
+        tokens_entrada=("tokens_input", "sum"),
+        tokens_salida=("tokens_output", "sum"),
+        tokens=("tokens_total", "sum"),
+        costo_estimado=("estimated_cost_usd", "sum"),
+        errores=("status", lambda s: (s != "success").sum())
+    ).reset_index().sort_values(["tokens", "eventos"], ascending=False)
+    by_user = df.groupby("username", dropna=False).agg(
+        eventos=("id", "count"),
+        tokens_entrada=("tokens_input", "sum"),
+        tokens_salida=("tokens_output", "sum"),
+        tokens=("tokens_total", "sum"),
+        costo_estimado=("estimated_cost_usd", "sum")
+    ).reset_index().sort_values(["tokens", "eventos"], ascending=False)
+    by_day = df.assign(day=df["created_at"].dt.date).groupby("day").agg(
+        eventos=("id", "count"),
+        tokens_entrada=("tokens_input", "sum"),
+        tokens_salida=("tokens_output", "sum"),
+        tokens=("tokens_total", "sum"),
+        costo_estimado=("estimated_cost_usd", "sum")
+    ).reset_index()
+    by_month = df.assign(month=df["created_at"].dt.to_period("M").astype(str)).groupby("month").agg(
+        eventos=("id", "count"),
+        usuarios=("username", lambda s: s.replace("", pd.NA).dropna().nunique()),
+        tokens_entrada=("tokens_input", "sum"),
+        tokens_salida=("tokens_output", "sum"),
+        tokens=("tokens_total", "sum"),
+        costo_estimado=("estimated_cost_usd", "sum"),
+        errores=("status", lambda s: (s != "success").sum())
+    ).reset_index()
+    by_hour = df.assign(hour=df["created_at"].dt.floor("h")).groupby("hour").agg(
+        eventos=("id", "count"),
+        usuarios=("username", lambda s: s.replace("", pd.NA).dropna().nunique())
+    ).reset_index()
+    by_status = df.groupby("status", dropna=False).agg(eventos=("id", "count")).reset_index()
+
+    return {
+        "total_events": int(len(df)),
+        "active_users": int(df["username"].replace("", pd.NA).dropna().nunique()),
+        "active_licitaciones": int(df["licitacion"].replace("", pd.NA).dropna().nunique()),
+        "tokens_total": int(df["tokens_total"].fillna(0).sum()),
+        "estimated_cost_usd": float(df["estimated_cost_usd"].fillna(0).sum()),
+        "errors": int((df["status"] != "success").sum()),
+        "peak_users_hour": int(by_hour["usuarios"].max()) if not by_hour.empty else 0,
+        "uncosted_events": int(legacy_total_only.sum()),
+        "df": df,
+        "by_module": by_module,
+        "by_user": by_user,
+        "by_day": by_day,
+        "by_month": by_month,
+        "by_hour": by_hour,
+        "by_status": by_status,
+    }
+
+def log_login_attempt(username, is_success):
+    log_usage_event(
+        username=username,
+        module="auth",
+        action="login",
+        status="success" if is_success else "error",
+        error_message="" if is_success else "Credenciales incorrectas"
+    )
+
+# =============================================
+# RADAR DE LICITACIONES SLI
+# =============================================
+
+def _calcular_score_radar(monto_estimado, es_prioritaria):
+    score = 1
+    monto_estimado = float(monto_estimado or 0)
+    if monto_estimado > 1000000:
+        score = 10
+    elif monto_estimado > 500000:
+        score = 8
+    elif monto_estimado > 100000:
+        score = 6
+    elif monto_estimado > 50000:
+        score = 4
+    elif monto_estimado > 10000:
+        score = 2
+    if es_prioritaria:
+        score = min(score + 2, 10)
+    return score
+
+def guardar_licitacion_radar(numero_licitacion, objeto, categoria, monto_estimado,
+                              moneda, fecha_apertura, fecha_cierre, link_sli, es_prioritaria):
+    """Guarda una licitación descubierta por el radar. Retorna True si es nueva, False si ya existía."""
+    conn = get_connection()
+    c = conn.cursor()
+    fecha = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    score = _calcular_score_radar(monto_estimado, es_prioritaria)
+
+    try:
+        c.execute("""INSERT INTO radar_licitaciones
+            (numero_licitacion, objeto, categoria, monto_estimado, moneda,
+             fecha_apertura, fecha_cierre, link_sli, es_prioritaria,
+             fecha_descubierta, fecha_ultimo_escaneo, score_interes, estado_radar)
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'nueva')
+            ON CONFLICT (numero_licitacion) DO UPDATE SET
+                objeto = EXCLUDED.objeto,
+                categoria = EXCLUDED.categoria,
+                moneda = EXCLUDED.moneda,
+                fecha_apertura = EXCLUDED.fecha_apertura,
+                fecha_cierre = EXCLUDED.fecha_cierre,
+                link_sli = EXCLUDED.link_sli,
+                es_prioritaria = EXCLUDED.es_prioritaria,
+                fecha_ultimo_escaneo = EXCLUDED.fecha_ultimo_escaneo,
+                score_interes = EXCLUDED.score_interes,
+                monto_estimado = CASE WHEN EXCLUDED.monto_estimado > 0 THEN EXCLUDED.monto_estimado ELSE radar_licitaciones.monto_estimado END
+        """, (numero_licitacion, objeto, categoria, monto_estimado, moneda,
+              fecha_apertura, fecha_cierre, link_sli, es_prioritaria, fecha, fecha, score))
+
+        # Verificar si fue INSERT o UPDATE
+        fue_nueva = c.rowcount > 0
+        conn.commit()
+        conn.close()
+
+        # Verificar si realmente es nueva (no existía antes)
+        conn2 = get_connection()
+        c2 = conn2.cursor()
+        c2.execute("SELECT fecha_descubierta FROM radar_licitaciones WHERE numero_licitacion=%s", (numero_licitacion,))
+        row = c2.fetchone()
+        conn2.close()
+        if row and row[0] == fecha:
+            return True  # Es nueva
+        return False  # Ya existía
+    except Exception as e:
+        print(f"[RADAR DB] Error guardando {numero_licitacion}: {e}")
+        conn.close()
+        return False
+
+
+def guardar_licitaciones_radar_bulk(licitaciones):
+    """Guarda muchas licitaciones del radar con una sola conexion. Retorna (nuevas, total)."""
+    if not licitaciones:
+        return 0, 0
+
+    fecha = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    numeros = [str(lic.get("numero_licitacion", "")).strip() for lic in licitaciones if lic.get("numero_licitacion")]
+    if not numeros:
+        return 0, 0
+
+    conn = get_connection()
+    c = conn.cursor()
+    placeholders = ",".join(["%s"] * len(numeros))
+    c.execute(f"SELECT numero_licitacion FROM radar_licitaciones WHERE numero_licitacion IN ({placeholders})", tuple(numeros))
+    existentes = {str(row[0]) for row in c.fetchall()}
+
+    values = []
+    for lic in licitaciones:
+        numero = str(lic.get("numero_licitacion", "")).strip()
+        if not numero:
+            continue
+        monto = float(lic.get("monto_estimado", 0) or 0)
+        es_prioritaria = bool(lic.get("es_prioritaria", False))
+        score = _calcular_score_radar(monto, es_prioritaria)
+        values.append((
+            numero,
+            lic.get("objeto", ""),
+            lic.get("categoria", "General (Autodetectado)"),
+            monto,
+            lic.get("moneda", "USD"),
+            lic.get("fecha_apertura", ""),
+            lic.get("fecha_cierre", ""),
+            lic.get("link_sli", ""),
+            es_prioritaria,
+            fecha,
+            fecha,
+            score,
+            "nueva",
+        ))
+
+    if not values:
+        conn.close()
+        return 0, 0
+
+    execute_values(c, """
+        INSERT INTO radar_licitaciones
+            (numero_licitacion, objeto, categoria, monto_estimado, moneda,
+             fecha_apertura, fecha_cierre, link_sli, es_prioritaria,
+             fecha_descubierta, fecha_ultimo_escaneo, score_interes, estado_radar)
+        VALUES %s
+        ON CONFLICT (numero_licitacion) DO UPDATE SET
+            objeto = EXCLUDED.objeto,
+            categoria = EXCLUDED.categoria,
+            moneda = EXCLUDED.moneda,
+            fecha_apertura = EXCLUDED.fecha_apertura,
+            fecha_cierre = EXCLUDED.fecha_cierre,
+            link_sli = EXCLUDED.link_sli,
+            es_prioritaria = EXCLUDED.es_prioritaria,
+            fecha_ultimo_escaneo = EXCLUDED.fecha_ultimo_escaneo,
+            score_interes = EXCLUDED.score_interes,
+            monto_estimado = CASE WHEN EXCLUDED.monto_estimado > 0 THEN EXCLUDED.monto_estimado ELSE radar_licitaciones.monto_estimado END
+    """, values)
+    conn.commit()
+    conn.close()
+
+    nuevas = len([n for n in numeros if n not in existentes])
+    return nuevas, len(values)
+
+
+def get_licitaciones_radar(solo_nuevas=False, solo_hoy=False):
+    """Retorna las licitaciones del radar."""
+    conn = get_connection()
+    query = "SELECT * FROM radar_licitaciones"
+    conditions = []
+    if solo_nuevas:
+        conditions.append("estado_radar = 'nueva'")
+    if solo_hoy:
+        hoy = datetime.now().strftime("%Y-%m-%d")
+        conditions.append(f"fecha_descubierta LIKE '{hoy}%'")
+    if conditions:
+        query += " WHERE " + " AND ".join(conditions)
+    query += " ORDER BY score_interes DESC, monto_estimado DESC"
+    df = pd.read_sql_query(query, conn)
+    conn.close()
+    return df
+
+
+def marcar_licitacion_radar(licitacion_id, estado, usuario, notas=""):
+    """Marca una licitación del radar como revisada/descartada/en_seguimiento."""
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("UPDATE radar_licitaciones SET estado_radar=%s, revisada_por=%s, notas=%s WHERE id=%s",
+              (estado, usuario, notas, licitacion_id))
+    conn.commit()
+    conn.close()
+
+
+def eliminar_licitaciones_radar(ids):
+    """Elimina licitaciones del radar por ID. Retorna cuantas filas fueron borradas."""
+    ids = [int(i) for i in ids if str(i).isdigit()]
+    if not ids:
+        return 0
+    conn = get_connection()
+    c = conn.cursor()
+    placeholders = ",".join(["%s"] * len(ids))
+    c.execute(f"DELETE FROM radar_licitaciones WHERE id IN ({placeholders})", tuple(ids))
+    deleted = c.rowcount
+    conn.commit()
+    conn.close()
+    return deleted
+
+
+def eliminar_radar_fuera_de_numeros(numeros):
+    """Elimina del radar licitaciones que ya no aparecen en el escaneo completo de abiertas."""
+    numeros = [str(n).strip() for n in numeros if str(n).strip()]
+    if not numeros:
+        return 0
+    conn = get_connection()
+    c = conn.cursor()
+    placeholders = ",".join(["%s"] * len(numeros))
+    c.execute(f"DELETE FROM radar_licitaciones WHERE numero_licitacion NOT IN ({placeholders})", tuple(numeros))
+    deleted = c.rowcount
+    conn.commit()
+    conn.close()
+    return deleted
+
+
+def registrar_escaneo_radar(total, nuevas, errores=""):
+    """Registra un escaneo del radar en el log."""
+    conn = get_connection()
+    c = conn.cursor()
+    fecha = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    c.execute("INSERT INTO radar_escaneos (fecha, total_encontradas, nuevas, errores) VALUES (%s, %s, %s, %s)",
+              (fecha, total, nuevas, errores))
+    conn.commit()
+    conn.close()
+
+
+def get_ultimos_escaneos(limite=10):
+    """Retorna los últimos escaneos del radar."""
+    conn = get_connection()
+    df = pd.read_sql_query(
+        f"SELECT * FROM radar_escaneos ORDER BY id DESC LIMIT {limite}", conn)
+    conn.close()
+    return df

requirements.txt

@@ -1,17 +1,19 @@
-streamlit
-pandas
-plotly
-tavily-python
-google-generativeai
-cryptography
-requests
-fastapi
-uvicorn
-python-multipart
-python-dotenv
-openpyxl
-playwright
-beautifulsoup4
-pypdf
-bcrypt
+streamlit
+pandas
+plotly
+tavily-python
+google-generativeai
+cryptography
+requests
+fastapi
+uvicorn
+python-multipart
+python-dotenv
+openpyxl
+playwright
+beautifulsoup4
+pypdf
+bcrypt
 psycopg2-binary
+certifi
+truststore

sli_scraper.py

@@ -0,0 +1,360 @@
+"""
+SLI Scraper - Radar de licitaciones abiertas de la ACP.
+
+Consulta el portal publico del SLI, recorre todas las paginas de resultados
+y guarda las licitaciones abiertas en la tabla radar_licitaciones.
+"""
+
+import re
+from datetime import datetime
+from urllib.parse import parse_qs, urljoin, urlparse
+
+import requests
+import urllib3
+from bs4 import BeautifulSoup
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+SLI_BASE = "https://apps.pancanal.com/sli"
+SLI_SEARCH_URL = f"{SLI_BASE}/LicitacionesBusqueda/LicitacionesBusquedaParametros"
+
+CATEGORIAS_PRIORITARIAS = [
+    "Electrical & Electronics",
+    "Fabricated (ACP)",
+    "Communications Equipment",
+    "Pumps/Compressors",
+    "Hydraulic",
+    "Mechanical Power Transmission",
+    "Engines & related component(non-vehicle)",
+    "Construction/Mining",
+    "Construction Material",
+    "Alarm, Signal & Detection",
+    "Instruments/Lab Equip",
+    "Metalworking",
+]
+
+MESES_SLI = {
+    "ene": 1,
+    "feb": 2,
+    "mar": 3,
+    "abr": 4,
+    "may": 5,
+    "jun": 6,
+    "jul": 7,
+    "ago": 8,
+    "sep": 9,
+    "oct": 10,
+    "nov": 11,
+    "dic": 12,
+}
+
+
+def parse_sli_datetime(value):
+    if not value:
+        return None
+    text = re.sub(r"\s+", " ", str(value).replace("\xa0", " ")).strip().lower()
+    match = re.search(
+        r"(\d{1,2})-([a-záéíóúñ]{3,})-(\d{4})\s+(\d{1,2}):(\d{2})\s*([ap])\.?m\.?",
+        text,
+        re.IGNORECASE,
+    )
+    if not match:
+        return None
+
+    dia, mes_txt, anio, hora, minuto, ampm = match.groups()
+    mes = MESES_SLI.get(mes_txt[:3])
+    if not mes:
+        return None
+
+    hora = int(hora)
+    if ampm.lower() == "p" and hora != 12:
+        hora += 12
+    if ampm.lower() == "a" and hora == 12:
+        hora = 0
+
+    try:
+        return datetime(int(anio), mes, int(dia), hora, int(minuto))
+    except ValueError:
+        return None
+
+
+def _extraer_monto_texto(texto):
+    if not texto:
+        return 0.0
+    patterns = [
+        r"[\$B/\.]+\s*([\d,]+(?:\.\d{2})?)",
+        r"([\d,]+(?:\.\d{2})?)\s*(?:USD|PAB|B/\.)",
+    ]
+    for pattern in patterns:
+        match = re.search(pattern, texto)
+        if match:
+            try:
+                return float(match.group(1).replace(",", ""))
+            except ValueError:
+                continue
+    return 0.0
+
+
+def _extraer_max_pagina(soup):
+    paginas = {1}
+    for link in soup.find_all("a", href=True):
+        href = link.get("href") or ""
+        if "BusquedaLicitacionesResultados" not in href or "pagina=" not in href:
+            continue
+        qs = parse_qs(urlparse(href).query)
+        for value in qs.get("pagina", []):
+            if str(value).isdigit():
+                paginas.add(int(value))
+    return max(paginas) if paginas else 1
+
+
+def _parsear_resultados_sli(soup):
+    resultados = []
+    items = soup.find_all("a", id="link_BiddingNumber")
+
+    for item in items:
+        numero = item.text.strip()
+        link = item.get("href", "")
+        if link and not link.startswith("http"):
+            link = urljoin("https://apps.pancanal.com", link)
+
+        container = item.find_parent("div", class_="col-lg-9") or item.find_parent("div")
+        if not container:
+            continue
+
+        objeto_tag = container.find("p", class_="title")
+        objeto = objeto_tag.text.strip() if objeto_tag else ""
+        if not objeto:
+            textos = [t.strip() for t in container.stripped_strings if t.strip()]
+            try:
+                idx = textos.index(numero)
+                objeto = textos[idx + 1] if idx + 1 < len(textos) else ""
+            except ValueError:
+                objeto = ""
+
+        texto_completo = container.text
+        apertura = ""
+        apertura_match = re.search(
+            r"Fecha\s+de\s+publicaci\S+n\s*([\d\-A-Za-z]+\s+[\d:]+\s+[APM]+)",
+            texto_completo,
+            re.IGNORECASE,
+        )
+        if apertura_match:
+            apertura = apertura_match.group(1).strip()
+
+        cierre = ""
+        cierre_match = re.search(
+            r"Fecha\s+y\s+hora\s+de\s+cierre\s*([\d\-A-Za-z]+\s+[\d:]+\s+[APM]+)",
+            texto_completo,
+            re.IGNORECASE,
+        )
+        if cierre_match:
+            cierre = re.sub(r"\s+", " ", cierre_match.group(1).replace("\xa0", " ")).strip()
+
+        objeto_lower = objeto.lower()
+        es_prioritaria = any(
+            key in objeto_lower
+            for key in [
+                "elect",
+                "cable",
+                "motor",
+                "bomba",
+                "panel",
+                "transformador",
+                "breaker",
+                "sensor",
+                "hidraul",
+                "valvula",
+                "repuesto",
+            ]
+        )
+
+        resultados.append(
+            {
+                "numero_licitacion": numero,
+                "objeto": objeto,
+                "categoria": "General (Autodetectado)",
+                "monto_estimado": _extraer_monto_texto(objeto),
+                "moneda": "USD",
+                "fecha_apertura": apertura,
+                "fecha_cierre": cierre,
+                "link_sli": link,
+                "es_prioritaria": es_prioritaria,
+                "fecha_descubierta": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            }
+        )
+
+    return resultados
+
+
+def escanear_licitaciones_abiertas(
+    palabra_clave="",
+    numero_licitacion="",
+    categoria="TODOS",
+    max_paginas=30,
+):
+    session = requests.Session()
+    session.verify = False
+    palabra_clave = (palabra_clave or "").strip()
+    numero_licitacion = re.sub(r"\D", "", str(numero_licitacion or ""))
+    categoria = (categoria or "TODOS").strip() or "TODOS"
+
+    print("[RADAR] Obteniendo token de sesion del SLI...")
+    try:
+        resp_home = session.get(SLI_BASE, timeout=30)
+        resp_home.raise_for_status()
+    except Exception as exc:
+        print(f"[RADAR] Error accediendo al SLI: {exc}")
+        return []
+
+    soup_home = BeautifulSoup(resp_home.text, "html.parser")
+    token_input = soup_home.find("input", {"name": "__RequestVerificationToken"})
+    if not token_input:
+        print("[RADAR] No se encontro __RequestVerificationToken en la pagina principal.")
+        return []
+
+    payload = {
+        "Descripcion": [palabra_clave, palabra_clave],
+        "NumeroLicitacion": numero_licitacion,
+        "status": "AN",
+        "EstatusSeleccionadoID": "AN",
+        "categorias": categoria,
+        "CategoriaSeleccionadaID": categoria,
+        "Text": "100",
+        "__RequestVerificationToken": token_input["value"],
+        "submitBusqueda3": "Buscar",
+    }
+
+    print("[RADAR] Buscando licitaciones abiertas...")
+    try:
+        resp = session.post(SLI_SEARCH_URL, data=payload, timeout=60)
+        resp.raise_for_status()
+    except Exception as exc:
+        print(f"[RADAR] Error enviando formulario de busqueda: {exc}")
+        return []
+
+    soups = [BeautifulSoup(resp.text, "html.parser")]
+    max_pagina = min(_extraer_max_pagina(soups[0]), int(max_paginas or 30))
+    print(f"[RADAR] Paginas detectadas: {max_pagina}")
+
+    for pagina in range(2, max_pagina + 1):
+        page_url = f"{SLI_BASE}/LicitacionesBusqueda/BusquedaLicitacionesResultados?pagina={pagina}"
+        try:
+            page_resp = session.get(page_url, timeout=45)
+            page_resp.raise_for_status()
+            soups.append(BeautifulSoup(page_resp.text, "html.parser"))
+        except Exception as exc:
+            print(f"[RADAR] Error obteniendo pagina {pagina}: {exc}")
+
+    unicos = {}
+    now = datetime.now()
+    for soup in soups:
+        for lic in _parsear_resultados_sli(soup):
+            cierre_dt = parse_sli_datetime(lic.get("fecha_cierre"))
+            if cierre_dt and cierre_dt < now:
+                continue
+            numero = lic["numero_licitacion"]
+            if numero not in unicos:
+                unicos[numero] = lic
+
+    resultados = list(unicos.values())
+
+    def sort_key(lic):
+        cierre_dt = parse_sli_datetime(lic.get("fecha_cierre"))
+        apertura_dt = parse_sli_datetime(lic.get("fecha_apertura"))
+        return (
+            cierre_dt or datetime.max,
+            apertura_dt or datetime.max,
+            str(lic.get("numero_licitacion", "")),
+        )
+
+    resultados.sort(key=sort_key)
+    print(f"[RADAR] Parseo completado: {len(resultados)} licitaciones abiertas unicas listas.")
+    return resultados
+
+
+def ejecutar_radar_detallado(db_module=None, palabra_clave="", numero_licitacion="", categoria="TODOS"):
+    if db_module is None:
+        import database as db_module
+
+    errores = ""
+    try:
+        licitaciones = escanear_licitaciones_abiertas(
+            palabra_clave=palabra_clave,
+            numero_licitacion=numero_licitacion,
+            categoria=categoria,
+        )
+    except Exception as exc:
+        licitaciones = []
+        errores = str(exc)
+
+    nuevas = 0
+    total = len(licitaciones)
+
+    if hasattr(db_module, "guardar_licitaciones_radar_bulk"):
+        nuevas, total = db_module.guardar_licitaciones_radar_bulk(licitaciones)
+    else:
+        for lic in licitaciones:
+            fue_nueva = db_module.guardar_licitacion_radar(
+                numero_licitacion=lic["numero_licitacion"],
+                objeto=lic["objeto"],
+                categoria=lic["categoria"],
+                monto_estimado=lic["monto_estimado"],
+                moneda=lic["moneda"],
+                fecha_apertura=lic["fecha_apertura"],
+                fecha_cierre=lic["fecha_cierre"],
+                link_sli=lic["link_sli"],
+                es_prioritaria=lic["es_prioritaria"],
+            )
+            if fue_nueva:
+                nuevas += 1
+
+    obsoletas_eliminadas = 0
+    es_escaneo_completo = not palabra_clave and not numero_licitacion and categoria == "TODOS"
+    if es_escaneo_completo and licitaciones and hasattr(db_module, "eliminar_radar_fuera_de_numeros"):
+        numeros_abiertos = [lic["numero_licitacion"] for lic in licitaciones]
+        obsoletas_eliminadas = db_module.eliminar_radar_fuera_de_numeros(numeros_abiertos)
+
+    if hasattr(db_module, "registrar_escaneo_radar"):
+        try:
+            db_module.registrar_escaneo_radar(total, nuevas, errores)
+        except Exception as exc:
+            errores = f"{errores} | Error registrando escaneo: {exc}".strip(" |")
+
+    print(f"[RADAR] Resultados: {nuevas} nuevas de {total} totales")
+    return {
+        "total": total,
+        "nuevas": nuevas,
+        "actualizadas": max(total - nuevas, 0),
+        "obsoletas_eliminadas": obsoletas_eliminadas,
+        "errores": errores,
+        "licitaciones": licitaciones,
+    }
+
+
+def ejecutar_radar(db_module=None):
+    resultado = ejecutar_radar_detallado(db_module=db_module)
+    return resultado["nuevas"], resultado["total"]
+
+
+if __name__ == "__main__":
+    import io
+    import sys
+
+    from dotenv import load_dotenv
+
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
+    load_dotenv()
+
+    print("[RADAR] Ejecutando Radar SLI manualmente...")
+    lics = escanear_licitaciones_abiertas()
+    if lics:
+        print(f"\n[RADAR] {len(lics)} licitaciones encontradas:\n")
+        for i, lic in enumerate(lics[:30], 1):
+            prio = "[PRIO]" if lic["es_prioritaria"] else "      "
+            monto_str = f"${lic['monto_estimado']:,.2f}" if lic["monto_estimado"] > 0 else "Sin monto"
+            print(f"{prio} {i}. [{lic['numero_licitacion']}] {lic['objeto'][:90]}")
+            print(f"       Monto: {monto_str} | Apertura: {lic['fecha_apertura']} | Cierre: {lic['fecha_cierre']}")
+            print()
+    else:
+        print("[RADAR] No se encontraron licitaciones. Verificar la conexion al SLI.")

style.css

@@ -13,23 +13,8 @@ html, body, [data-testid="stAppViewContainer"] {
 [data-testid="stHeader"] { background-color: transparent !important; }
 [data-testid="stAppViewBlockContainer"] { padding-top: 10px; }
 
-/* ===== NAVBAR ===== */
-.top-navbar {
-    position: fixed;
-    top: 0; left: 0;
-    width: 100%;
-    background: rgba(13, 17, 23, 0.85);
-    backdrop-filter: blur(12px);
-    -webkit-backdrop-filter: blur(12px);
-    padding: 14px 60px;
-    border-bottom: 1px solid rgba(88, 166, 255, 0.3);
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    z-index: 9999;
-    box-shadow: 0 4px 30px rgba(0, 0, 0, 0.5);
-}
-.main-content-spacer { margin-top: 65px; }
+/* ===== NAVBAR LATERAL ===== */
+.main-content-spacer { margin-top: 0; }
 
 /* ===== MÉTRICAS ===== */
 div[data-testid="metric-container"] {
@@ -154,7 +139,50 @@ div[data-testid="metric-container"]:hover {
 ::-webkit-scrollbar-thumb:hover { background: #58A6FF; }
 
 /* ===== DATAFRAME ===== */
-[data-testid="stDataFrame"] { border-radius: 12px; overflow: hidden; }
+[data-testid="stDataFrame"] { border-radius: 12px; overflow: hidden; }
+
+/* ===== LOADING / RERUN SIN OSCURECER LA APP ===== */
+.stApp,
+main,
+html,
+body,
+[data-testid="stAppViewContainer"],
+[data-testid="stAppViewBlockContainer"],
+[data-testid="stVerticalBlock"] {
+    opacity: 1 !important;
+    filter: none !important;
+}
+
+[data-testid="stAppViewContainer"]::before,
+[data-testid="stAppViewContainer"]::after,
+[data-testid="stAppViewBlockContainer"]::before,
+[data-testid="stAppViewBlockContainer"]::after {
+    background: transparent !important;
+    opacity: 0 !important;
+    pointer-events: none !important;
+}
+
+[data-testid="stStatusWidget"] {
+    position: fixed !important;
+    top: auto !important;
+    right: 18px !important;
+    bottom: 18px !important;
+    background: rgba(15, 20, 28, 0.96) !important;
+    border: 1px solid #344255 !important;
+    border-radius: 8px !important;
+    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.35) !important;
+    color: #E8EDF5 !important;
+    z-index: 10000 !important;
+}
+
+[data-testid="stSpinner"],
+.stSpinner {
+    background: rgba(15, 20, 28, 0.92) !important;
+    border: 1px solid #2F7FD8 !important;
+    border-radius: 8px !important;
+    padding: 10px 12px !important;
+    box-shadow: none !important;
+}
 
 /* ===== OPERATIONS UI REFRESH ===== */
 :root {
@@ -420,4 +448,1555 @@ div[data-testid="metric-container"]:hover {
 }
 .provider-card a:hover {
     text-decoration: underline;
-}
+}
+
+.provider-source-link {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+    background: #101720;
+    border: 1px solid var(--procura-border);
+    border-radius: 8px;
+    padding: 10px 12px;
+    margin-bottom: 8px;
+    color: var(--procura-text) !important;
+    text-decoration: none !important;
+    font-size: 13px;
+    font-weight: 750;
+}
+
+.provider-source-link:hover {
+    border-color: #3F8FE5;
+    background: #121C28;
+}
+
+.provider-source-link b {
+    color: #8EC8FF;
+    font-size: 11px;
+}
+
+.provider-source-card {
+    background: #101720;
+    border: 1px solid var(--procura-border);
+    border-left: 3px solid var(--procura-blue);
+    border-radius: 8px;
+    padding: 11px 12px;
+    margin-bottom: 9px;
+}
+
+.provider-rfq-card {
+    background: #101720;
+    border: 1px solid var(--procura-border);
+    border-left: 3px solid var(--procura-green);
+    border-radius: 8px;
+    padding: 12px 14px;
+    margin: 9px 0 14px 0;
+}
+
+.provider-rfq-eyebrow {
+    color: #7CE0B7;
+    font-size: 10px;
+    font-weight: 840;
+    text-transform: uppercase;
+    margin-bottom: 5px;
+}
+
+.provider-rfq-title {
+    color: var(--procura-text);
+    font-size: 15px;
+    line-height: 1.3;
+    font-weight: 850;
+    margin-bottom: 9px;
+}
+
+.provider-rfq-meta {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 6px;
+}
+
+.provider-rfq-meta span {
+    display: inline-flex;
+    align-items: center;
+    gap: 5px;
+    min-height: 24px;
+    padding: 3px 8px;
+    border-radius: 999px;
+    background: #0B1017;
+    border: 1px solid #26384E;
+    color: var(--procura-muted);
+    font-size: 10.5px;
+    font-weight: 760;
+}
+
+.provider-rfq-meta b {
+    color: #DCE7F4;
+    font-size: 10.5px;
+}
+
+.source-readiness-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(128px, 1fr));
+    gap: 8px;
+    margin: 10px 0 8px 0;
+}
+
+.source-pill {
+    background: #0D141D;
+    border: 1px solid var(--procura-border);
+    border-left: 3px solid var(--procura-blue);
+    border-radius: 8px;
+    padding: 9px 10px;
+    min-height: 62px;
+    transition: border-color 0.15s ease, background 0.15s ease, opacity 0.15s ease;
+}
+
+.source-pill.is-muted {
+    opacity: 0.52;
+}
+
+.source-pill.is-selected {
+    background: #111B27;
+    border-color: #3F8FE5;
+}
+
+.source-pill.tone-green { border-left-color: var(--procura-green); }
+.source-pill.tone-amber { border-left-color: var(--procura-amber); }
+.source-pill.tone-blue { border-left-color: var(--procura-blue); }
+
+.source-pill-top {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 7px;
+    margin-bottom: 4px;
+}
+
+.source-pill-top b {
+    color: var(--procura-text);
+    font-size: 12px;
+    line-height: 1.15;
+}
+
+.source-pill-top span {
+    color: #CFE6FF;
+    background: #102033;
+    border: 1px solid #284C73;
+    border-radius: 999px;
+    padding: 2px 6px;
+    font-size: 9.5px;
+    font-weight: 820;
+    white-space: nowrap;
+}
+
+.source-pill.tone-green .source-pill-top span {
+    color: #7CE0B7;
+    background: #0E241A;
+    border-color: #1F805E;
+}
+
+.source-pill.tone-amber .source-pill-top span {
+    color: #FFD48A;
+    background: #2A1E0F;
+    border-color: #6A4A15;
+}
+
+.source-pill small {
+    display: block;
+    color: var(--procura-muted);
+    font-size: 10.5px;
+    line-height: 1.2;
+    font-weight: 720;
+}
+
+.free-source-grid {
+    display: grid;
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+    gap: 8px;
+    margin: 8px 0 12px 0;
+}
+
+.provider-source-card.compact {
+    margin-bottom: 0;
+    padding: 10px;
+    min-height: 132px;
+    display: flex;
+    flex-direction: column;
+}
+
+.provider-source-card.tone-green { border-left-color: var(--procura-green); }
+.provider-source-card.tone-amber { border-left-color: var(--procura-amber); }
+.provider-source-card.tone-blue { border-left-color: var(--procura-blue); }
+
+.source-card-top {
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    gap: 12px;
+    margin-bottom: 7px;
+}
+
+.provider-source-card.compact .source-card-top {
+    justify-content: flex-start;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 8px;
+}
+
+.source-mark {
+    width: 30px;
+    height: 30px;
+    border-radius: 8px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: #0B1017;
+    border: 1px solid #2B3B4F;
+    color: #E9EEF5;
+    font-size: 11px;
+    font-weight: 850;
+    flex: 0 0 auto;
+}
+
+.source-name {
+    color: var(--procura-text);
+    font-size: 13px;
+    font-weight: 850;
+    line-height: 1.15;
+}
+
+.source-kind {
+    color: var(--procura-muted);
+    font-size: 10px;
+    font-weight: 750;
+    text-transform: uppercase;
+    margin-top: 3px;
+}
+
+.source-status {
+    color: #CFE6FF;
+    background: #112033;
+    border: 1px solid #284C73;
+    border-radius: 999px;
+    padding: 2px 7px;
+    font-size: 10px;
+    font-weight: 800;
+    white-space: nowrap;
+}
+
+.provider-source-card.compact .source-status {
+    align-self: flex-start;
+    margin-bottom: 7px;
+}
+
+.source-detail {
+    color: var(--procura-muted);
+    font-size: 12px;
+    line-height: 1.4;
+    min-height: 34px;
+}
+
+.provider-source-card.compact .source-detail {
+    min-height: auto;
+    flex: 1;
+}
+
+.source-action {
+    border-top: 1px solid var(--procura-border);
+    margin-top: 9px;
+    padding-top: 8px;
+    font-size: 12px;
+    font-weight: 800;
+}
+
+.source-action a {
+    display: inline-flex;
+    justify-content: center;
+    width: 100%;
+    border: 1px solid #2D5F91;
+    border-radius: 7px;
+    background: #112033;
+    color: #CFE6FF !important;
+    text-decoration: none !important;
+    padding: 6px 8px;
+}
+
+.source-action span {
+    color: var(--procura-muted);
+}
+
+.provider-query-chips {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 7px;
+    margin: 8px 0 12px 0;
+}
+
+.provider-query-chips span {
+    display: inline-flex;
+    align-items: center;
+    min-height: 24px;
+    padding: 3px 9px;
+    border-radius: 999px;
+    background: #0B1017;
+    border: 1px solid var(--procura-border);
+    color: #B8C4D2;
+    font-size: 11px;
+    font-weight: 750;
+}
+
+.item-detail-panel {
+    background: #101720;
+    border: 1px solid var(--procura-border);
+    border-left: 3px solid var(--procura-blue);
+    border-radius: 8px;
+    padding: 15px;
+    margin: 14px 0 10px 0;
+}
+
+.item-detail-head {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 16px;
+    margin-bottom: 12px;
+}
+
+.item-detail-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(145px, 1fr));
+    gap: 8px;
+    margin-bottom: 10px;
+}
+
+.item-detail-grid div {
+    background: #0B1017;
+    border: 1px solid var(--procura-border);
+    border-radius: 8px;
+    padding: 9px 10px;
+}
+
+.item-detail-grid span {
+    display: block;
+    color: var(--procura-muted);
+    font-size: 10px;
+    font-weight: 800;
+    text-transform: uppercase;
+    margin-bottom: 4px;
+}
+
+.item-detail-grid b {
+    color: var(--procura-text);
+    font-size: 13px;
+}
+
+.item-warning-line {
+    background: #141A22;
+    border: 1px solid #30363D;
+    border-left: 3px solid var(--procura-amber);
+    border-radius: 8px;
+    color: #E6EDF3;
+    font-size: 13px;
+    line-height: 1.45;
+    padding: 10px 12px;
+    margin-bottom: 10px;
+}
+
+.item-description-box {
+    background: #0B1017;
+    border: 1px solid var(--procura-border);
+    border-radius: 8px;
+    color: #DCE6F2;
+    font-size: 13px;
+    line-height: 1.55;
+    max-height: 260px;
+    overflow: auto;
+    padding: 12px;
+    white-space: pre-wrap;
+}
+
+.technical-spec-box {
+    background-color: #0D1117;
+    border: 1px solid #30363D;
+    border-radius: 8px;
+    color: #E6EDF3;
+    font-size: 14.5px;
+    line-height: 1.7;
+    margin-bottom: 10px;
+    padding: 20px;
+    white-space: pre-wrap;
+    box-shadow: inset 0 2px 4px rgba(0,0,0,0.2);
+}
+
+.technical-spec-box.checklist-mode {
+    padding: 12px;
+}
+
+.checklist-title {
+    color: var(--procura-text);
+    font-size: 13px;
+    font-weight: 850;
+    margin: 10px 0 8px 0;
+}
+
+.checklist-block {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+    gap: 8px;
+    margin-bottom: 10px;
+}
+
+.checklist-row {
+    display: flex;
+    align-items: flex-start;
+    gap: 9px;
+    background: #0B1017;
+    border: 1px solid var(--procura-border);
+    border-radius: 8px;
+    padding: 10px 11px;
+}
+
+.check-dot {
+    width: 16px;
+    height: 16px;
+    border-radius: 999px;
+    border: 1px solid #3F8FE5;
+    background: #112033;
+    flex: 0 0 auto;
+    margin-top: 2px;
+}
+
+.checklist-row.state-ok .check-dot {
+    border-color: #1F805E;
+    background: #0E241A;
+}
+
+.checklist-row.state-warn .check-dot {
+    border-color: #9B6A1E;
+    background: #261F0B;
+}
+
+.checklist-row b {
+    display: block;
+    color: var(--procura-text);
+    font-size: 12.5px;
+    line-height: 1.25;
+    margin-bottom: 3px;
+}
+
+.checklist-row em {
+    display: block;
+    color: var(--procura-muted);
+    font-size: 12px;
+    font-style: normal;
+    line-height: 1.35;
+}
+
+.analysis-state-panel {
+    background: #0D1520;
+    border: 1px solid rgba(126, 148, 173, 0.28);
+    border-radius: 8px;
+    padding: 12px;
+    margin: 8px 0 16px 0;
+}
+
+.analysis-state-panel .checklist-block {
+    margin-bottom: 0;
+}
+
+.analysis-state-panel .checklist-row {
+    min-height: 68px;
+}
+
+.analysis-state-panel .checklist-row.state-ok {
+    border-left: 3px solid var(--procura-green);
+}
+
+.analysis-state-panel .checklist-row.state-warn {
+    border-left: 3px solid var(--procura-amber);
+}
+
+.future-note {
+    margin-top: 10px;
+    color: var(--procura-muted);
+    background: #0B1017;
+    border: 1px dashed var(--procura-border-strong);
+    border-radius: 8px;
+    font-size: 12px;
+    line-height: 1.45;
+    padding: 9px 10px;
+}
+
+/* ===== FRONTEND PHASE 1: NAV + DASHBOARD ===== */
+:root {
+    --procura-bg: #090D13;
+    --procura-sidebar: #0C1118;
+    --procura-surface: #111821;
+    --procura-surface-2: #151D28;
+    --procura-border: #263241;
+    --procura-border-strong: #344357;
+    --procura-text: #E9EEF5;
+    --procura-muted: #93A0B2;
+    --procura-blue: #3F8FE5;
+    --procura-green: #2FBF8F;
+    --procura-amber: #E6A94A;
+}
+
+html, body, [data-testid="stAppViewContainer"] {
+    background: var(--procura-bg) !important;
+}
+
+[data-testid="stSidebar"] {
+    background: var(--procura-sidebar) !important;
+    border-right: 1px solid var(--procura-border) !important;
+    min-width: 285px;
+}
+
+[data-testid="stAppViewBlockContainer"] {
+    padding-top: 8px;
+    max-width: 1500px;
+}
+
+.role-pill {
+    background: #102033;
+    border: 1px solid #214A73;
+    color: #8EC8FF;
+    border-radius: 999px;
+    padding: 3px 9px;
+    font-size: 11px;
+    font-weight: 700;
+}
+
+.main-content-spacer {
+    margin-top: 0 !important;
+}
+
+.sidebar-brand {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 12px 6px 14px 6px;
+    margin-bottom: 8px;
+    border-bottom: 1px solid #1C2633;
+}
+
+.brand-mark {
+    width: 38px;
+    height: 38px;
+    border-radius: 8px;
+    background: #163B5F;
+    border: 1px solid #2B7EC6;
+    color: #F7FBFF;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-weight: 850;
+    box-shadow: 0 8px 18px rgba(15, 95, 160, 0.22);
+}
+
+.brand-title {
+    color: var(--procura-text);
+    font-size: 13px;
+    font-weight: 850;
+    line-height: 1.15;
+}
+
+.brand-subtitle {
+    color: var(--procura-muted);
+    font-size: 11px;
+    line-height: 1.2;
+}
+
+.sidebar-user-card {
+    background: linear-gradient(180deg, #121A24 0%, #0C1118 100%);
+    border: 1px solid #2A384A;
+    border-radius: 8px;
+    padding: 12px;
+    margin: 0 0 14px 0;
+}
+
+.sidebar-user-top {
+    display: flex;
+    align-items: center;
+    gap: 9px;
+    margin-bottom: 10px;
+}
+
+.sidebar-avatar {
+    width: 30px;
+    height: 30px;
+    border-radius: 8px;
+    background: #173150;
+    border: 1px solid #2B679E;
+    color: #F4FAFF;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 13px;
+    font-weight: 850;
+}
+
+.sidebar-user-name {
+    color: var(--procura-text);
+    font-size: 13px;
+    font-weight: 800;
+    line-height: 1.15;
+}
+
+.sidebar-user-role {
+    color: var(--procura-muted);
+    font-size: 11px;
+    line-height: 1.2;
+}
+
+.sidebar-system-row {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    border-top: 1px solid var(--procura-border);
+    padding-top: 9px;
+    color: var(--procura-muted);
+    font-size: 11px;
+}
+
+.system-pill {
+    border-radius: 999px;
+    padding: 2px 8px;
+    font-size: 10px;
+    border: 1px solid var(--procura-border);
+    color: var(--procura-muted);
+}
+
+.system-pill.online {
+    background: #0E241A;
+    border-color: #1F805E;
+    color: #7CE0B7;
+}
+
+.system-pill.offline {
+    background: #2A1111;
+    border-color: #7A2929;
+    color: #FF9D9D;
+}
+
+.sidebar-status-card {
+    background: #0B1017;
+    border: 1px solid var(--procura-border);
+    border-radius: 8px;
+    padding: 9px 11px;
+    margin-bottom: 10px;
+}
+
+.sidebar-status-card div {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+    padding: 5px 0;
+    color: var(--procura-muted);
+    font-size: 11px;
+}
+
+.sidebar-status-card div + div {
+    border-top: 1px solid #1C2633;
+}
+
+.sidebar-status-card b {
+    color: var(--procura-text);
+    font-size: 11px;
+}
+
+.sidebar-section-label {
+    color: var(--procura-muted);
+    font-size: 10px;
+    font-weight: 800;
+    text-transform: uppercase;
+    letter-spacing: 0;
+    margin: 12px 0 8px 0;
+}
+
+.nav-group-label {
+    color: #6F7D8F;
+    font-size: 10px;
+    font-weight: 850;
+    text-transform: uppercase;
+    margin: 12px 0 5px 4px;
+}
+
+[data-testid="stSidebar"] [data-testid="stButton"] > button {
+    justify-content: flex-start;
+    border-radius: 8px !important;
+    min-height: 40px;
+    margin-bottom: 3px;
+    font-size: 13px;
+    font-weight: 760;
+    padding-left: 12px !important;
+}
+
+[data-testid="stSidebar"] [data-testid="stBaseButton-secondary"] {
+    background: transparent !important;
+    border-color: transparent !important;
+    color: #B8C4D2 !important;
+}
+
+[data-testid="stSidebar"] [data-testid="stBaseButton-secondary"]:hover {
+    background: #121A24 !important;
+    border-color: var(--procura-border) !important;
+    color: var(--procura-text) !important;
+}
+
+[data-testid="stSidebar"] [data-testid="stBaseButton-primary"] {
+    background: #14263A !important;
+    border-color: #2F6EA8 !important;
+    color: #F4FAFF !important;
+    box-shadow: inset 4px 0 0 #2FBF8F !important;
+}
+
+.sidebar-analysis-card {
+    background: #0F151D;
+    border: 1px dashed #344357;
+    border-radius: 8px;
+    padding: 11px 12px;
+    margin-bottom: 9px;
+}
+
+.analysis-card-title {
+    color: var(--procura-text);
+    font-size: 13px;
+    font-weight: 850;
+    margin-bottom: 4px;
+}
+
+.analysis-card-copy {
+    color: var(--procura-muted);
+    font-size: 11px;
+    line-height: 1.4;
+}
+
+.page-hero {
+    margin: 4px 0 18px 0;
+}
+
+.page-title-row {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 16px;
+    padding: 2px 0 6px 0;
+}
+
+.page-eyebrow {
+    color: var(--procura-blue);
+    font-size: 11px;
+    font-weight: 800;
+    text-transform: uppercase;
+    letter-spacing: 0;
+    margin-bottom: 4px;
+}
+
+.page-title {
+    color: var(--procura-text);
+    font-size: 28px;
+    line-height: 1.1;
+    margin: 0;
+    font-weight: 800;
+}
+
+.page-subtitle {
+    color: var(--procura-muted);
+    font-size: 13px;
+    margin-top: 6px;
+}
+
+.system-status {
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    background: var(--procura-surface);
+    border: 1px solid var(--procura-border);
+    border-radius: 999px;
+    padding: 7px 11px;
+    color: var(--procura-muted);
+    font-size: 12px;
+    white-space: nowrap;
+}
+
+.system-status .status-dot {
+    background: var(--procura-amber);
+}
+
+.system-status.is-online .status-dot {
+    background: var(--procura-green);
+}
+
+.system-status.is-offline .status-dot {
+    background: #EF5B5B;
+}
+
+.dashboard-grid {
+    margin-top: 14px;
+}
+
+.ops-hero {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) 280px;
+    gap: 14px;
+    align-items: stretch;
+    background: #0F151D;
+    border: 1px solid var(--procura-border);
+    border-radius: 8px;
+    padding: 18px;
+    margin: 4px 0 16px 0;
+}
+
+.ops-hero-main {
+    min-width: 0;
+}
+
+.ops-hero-pills {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 7px;
+    margin-top: 12px;
+}
+
+.ops-hero-pills span {
+    background: #0B1017;
+    border: 1px solid var(--procura-border);
+    border-radius: 999px;
+    color: #B8C4D2;
+    font-size: 11px;
+    font-weight: 750;
+    padding: 4px 9px;
+}
+
+.ops-hero-pills .pill-ok {
+    border-color: #1F805E;
+    color: #7CE0B7;
+}
+
+.ops-hero-pills .pill-alert {
+    border-color: #7A2929;
+    color: #FF9D9D;
+}
+
+.ops-hero-side {
+    background: #0B1017;
+    border: 1px solid var(--procura-border);
+    border-radius: 8px;
+    padding: 11px 13px;
+}
+
+.ops-hero-side div {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 14px;
+    padding: 9px 0;
+    border-bottom: 1px solid #1C2633;
+}
+
+.ops-hero-side div:last-child {
+    border-bottom: 0;
+}
+
+.ops-hero-side span {
+    color: var(--procura-muted);
+    font-size: 12px;
+}
+
+.ops-hero-side b {
+    color: var(--procura-text);
+    font-size: 18px;
+}
+
+.ops-route-card {
+    min-height: 126px;
+    background: #101720;
+    border: 1px solid var(--procura-border);
+    border-top: 3px solid var(--procura-blue);
+    border-radius: 8px;
+    padding: 13px;
+    margin-bottom: 8px;
+}
+
+.route-title {
+    color: var(--procura-text);
+    font-size: 15px;
+    font-weight: 850;
+    margin-bottom: 7px;
+}
+
+.route-body {
+    color: var(--procura-muted);
+    font-size: 12.5px;
+    line-height: 1.45;
+}
+
+.dashboard-panel {
+    min-height: 132px;
+    margin-bottom: 10px;
+}
+
+.panel-label {
+    color: var(--procura-muted);
+    font-size: 10px;
+    font-weight: 800;
+    text-transform: uppercase;
+    letter-spacing: 0;
+    margin-bottom: 8px;
+}
+
+.panel-title {
+    color: var(--procura-text);
+    font-size: 17px;
+    font-weight: 800;
+    margin-bottom: 6px;
+}
+
+.panel-copy {
+    color: var(--procura-muted);
+    font-size: 13px;
+    line-height: 1.45;
+}
+
+.dashboard-stat-row {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    border-top: 1px solid var(--procura-border);
+    padding: 9px 0;
+    color: var(--procura-muted);
+    font-size: 13px;
+}
+
+.dashboard-stat-row:first-of-type {
+    border-top: 0;
+    padding-top: 0;
+}
+
+.dashboard-stat-row b {
+    color: var(--procura-text);
+    font-size: 15px;
+}
+
+div[data-testid="metric-container"] {
+    background: var(--procura-surface) !important;
+    border: 1px solid var(--procura-border) !important;
+    border-radius: 8px !important;
+    padding: 14px 16px !important;
+}
+
+div[data-testid="metric-container"] [data-testid="stMetricLabel"] {
+    color: var(--procura-muted) !important;
+}
+
+.work-panel,
+.info-tile,
+.monitor-row,
+.detail-card,
+.provider-card,
+.email-card,
+.step-card,
+.sli-summary {
+    border-radius: 8px !important;
+}
+
+/* ===== BETA PRESENTATION SYSTEM ===== */
+.module-header {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 18px;
+    padding: 16px 18px;
+    margin: 0 0 16px 0;
+    background: linear-gradient(180deg, #111821 0%, #0D131B 100%);
+    border: 1px solid var(--procura-border);
+    border-radius: 8px;
+}
+
+.page-meta {
+    display: flex;
+    flex-wrap: wrap;
+    justify-content: flex-end;
+    gap: 6px;
+    max-width: 420px;
+}
+
+.page-meta span {
+    display: inline-flex;
+    align-items: center;
+    min-height: 24px;
+    padding: 3px 9px;
+    border-radius: 999px;
+    background: #0B1017;
+    border: 1px solid var(--procura-border);
+    color: var(--procura-muted);
+    font-size: 11px;
+    font-weight: 700;
+}
+
+.summary-strip {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+    gap: 10px;
+    margin: 12px 0 16px 0;
+}
+
+.summary-card {
+    background: var(--procura-surface);
+    border: 1px solid var(--procura-border);
+    border-left: 3px solid var(--procura-blue);
+    border-radius: 8px;
+    padding: 12px 13px;
+}
+
+.summary-card.tone-green { border-left-color: var(--procura-green); }
+.summary-card.tone-amber { border-left-color: var(--procura-amber); }
+.summary-card.tone-orange { border-left-color: #F08A3C; }
+.summary-card.tone-red { border-left-color: #EF5B5B; }
+.summary-card.tone-blue { border-left-color: var(--procura-blue); }
+
+.summary-label {
+    color: var(--procura-muted);
+    font-size: 10px;
+    font-weight: 800;
+    text-transform: uppercase;
+    letter-spacing: 0;
+    margin-bottom: 5px;
+}
+
+.summary-value {
+    color: var(--procura-text);
+    font-size: 18px;
+    line-height: 1.15;
+    font-weight: 820;
+}
+
+.selected-record {
+    background: #101720;
+    border: 1px solid var(--procura-border);
+    border-left: 3px solid var(--procura-blue);
+    border-radius: 8px;
+    padding: 13px 15px;
+    margin: 14px 0 10px 0;
+}
+
+.selected-kicker {
+    color: var(--procura-muted);
+    font-size: 10px;
+    font-weight: 800;
+    text-transform: uppercase;
+    letter-spacing: 0;
+    margin-bottom: 4px;
+}
+
+.selected-title {
+    color: var(--procura-text);
+    font-size: 20px;
+    font-weight: 850;
+    line-height: 1.2;
+}
+
+.selected-subtitle {
+    color: #B8C4D2;
+    font-size: 13px;
+    line-height: 1.4;
+    margin-top: 4px;
+}
+
+.empty-state {
+    background: #0F151D;
+    border: 1px dashed var(--procura-border-strong);
+    border-radius: 8px;
+    padding: 34px 22px;
+    text-align: center;
+    margin: 16px 0;
+}
+
+.empty-title {
+    color: var(--procura-text);
+    font-size: 18px;
+    font-weight: 800;
+    margin-bottom: 6px;
+}
+
+.empty-body {
+    color: var(--procura-muted);
+    font-size: 13px;
+    line-height: 1.45;
+}
+
+[data-testid="stDataFrame"] {
+    border: 1px solid var(--procura-border);
+    border-radius: 8px !important;
+    background: var(--procura-surface);
+    box-shadow: 0 1px 0 rgba(255,255,255,0.02) inset;
+}
+
+[data-testid="stDataFrame"] [role="grid"] {
+    font-size: 12px;
+}
+
+[data-testid="stExpander"] {
+    background: #0F151D;
+    border: 1px solid var(--procura-border) !important;
+    border-radius: 8px !important;
+}
+
+[data-testid="stTextInput"] input,
+[data-testid="stTextArea"] textarea,
+[data-testid="stSelectbox"] {
+    border-radius: 8px !important;
+}
+
+/* ===== Streamlit beta polish: roles, sidebar and operational dashboard ===== */
+.sidebar-brand {
+    padding: 14px 8px 16px 8px;
+    border-bottom: 1px solid #233143;
+}
+
+.brand-mark {
+    background: linear-gradient(135deg, #17466D 0%, #1F6E5C 100%);
+    border-color: #3F8FE5;
+}
+
+.sidebar-user-card,
+.sidebar-role-card,
+.sidebar-analysis-card,
+.sidebar-status-card {
+    box-shadow: 0 10px 24px rgba(0, 0, 0, 0.18);
+}
+
+.sidebar-role-card {
+    background: #0F151D;
+    border: 1px solid #2B3B4F;
+    border-left: 3px solid var(--procura-green);
+    border-radius: 8px;
+    padding: 11px 12px;
+    margin: 0 0 14px 0;
+}
+
+.role-card-top {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+    margin-bottom: 7px;
+}
+
+.role-card-top span {
+    color: #7CE0B7;
+    background: #0E241A;
+    border: 1px solid #1F805E;
+    border-radius: 999px;
+    padding: 3px 8px;
+    font-size: 10px;
+    font-weight: 800;
+}
+
+.role-card-top b {
+    color: var(--procura-text);
+    font-size: 12px;
+    text-align: right;
+}
+
+.role-card-copy {
+    color: var(--procura-muted);
+    font-size: 11px;
+    line-height: 1.38;
+}
+
+.nav-group-label {
+    color: #9BA8B8;
+    padding-left: 2px;
+}
+
+[data-testid="stSidebar"] [data-testid="stButton"] > button {
+    min-height: 38px;
+    border-radius: 7px !important;
+}
+
+[data-testid="stSidebar"] [data-testid="stBaseButton-primary"] {
+    background: #172334 !important;
+    border-color: #3F8FE5 !important;
+    box-shadow: inset 4px 0 0 var(--procura-green) !important;
+}
+
+.sidebar-flow {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 6px;
+    margin-top: 10px;
+}
+
+.sidebar-flow span {
+    background: #0A1018;
+    border: 1px solid #243246;
+    border-radius: 6px;
+    color: #B8C4D2;
+    font-size: 10px;
+    font-weight: 760;
+    padding: 5px 6px;
+}
+
+.ops-hero {
+    background:
+        linear-gradient(135deg, rgba(63, 143, 229, 0.10) 0%, rgba(47, 191, 143, 0.06) 52%, rgba(230, 169, 74, 0.05) 100%),
+        #0F151D;
+    border-color: #2B3B4F;
+}
+
+.ops-route-card {
+    min-height: 118px;
+    border-top: 0;
+    border-left: 3px solid var(--procura-blue);
+    box-shadow: 0 10px 22px rgba(0, 0, 0, 0.14);
+}
+
+.ops-route-card:hover {
+    border-left-color: var(--procura-green);
+    background: #121B26;
+}
+
+.summary-card {
+    min-height: 78px;
+}
+
+.admin-hero {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 16px;
+    background:
+        linear-gradient(135deg, rgba(63, 143, 229, 0.12) 0%, rgba(47, 191, 143, 0.06) 100%),
+        #0F151D;
+    border: 1px solid #2B3B4F;
+    border-radius: 8px;
+    padding: 18px;
+    margin: 4px 0 16px 0;
+}
+
+.admin-hero-badge {
+    white-space: nowrap;
+    background: #0E241A;
+    border: 1px solid #1F805E;
+    color: #7CE0B7;
+    border-radius: 999px;
+    padding: 6px 11px;
+    font-size: 11px;
+    font-weight: 820;
+}
+
+.notice-panel {
+    background: #0F151D;
+    border: 1px solid var(--procura-border);
+    border-left: 3px solid var(--procura-blue);
+    border-radius: 8px;
+    padding: 13px 15px;
+    margin: 12px 0;
+}
+
+.notice-panel.tone-green { border-left-color: var(--procura-green); }
+.notice-panel.tone-amber { border-left-color: var(--procura-amber); }
+.notice-panel.tone-red { border-left-color: #EF5B5B; }
+
+.notice-title {
+    color: var(--procura-text);
+    font-size: 14px;
+    font-weight: 850;
+    margin-bottom: 4px;
+}
+
+.notice-body {
+    color: var(--procura-muted);
+    font-size: 12.5px;
+    line-height: 1.45;
+}
+
+.table-toolbar {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 14px;
+    background: #0F151D;
+    border: 1px solid var(--procura-border);
+    border-radius: 8px;
+    padding: 12px 14px;
+    margin: 14px 0 8px 0;
+}
+
+.table-toolbar-title {
+    color: var(--procura-text);
+    font-size: 15px;
+    font-weight: 850;
+    margin-bottom: 3px;
+}
+
+.table-toolbar-subtitle {
+    color: var(--procura-muted);
+    font-size: 12px;
+    line-height: 1.4;
+}
+
+.table-toolbar-meta {
+    display: flex;
+    flex-wrap: wrap;
+    justify-content: flex-end;
+    gap: 6px;
+}
+
+.table-toolbar-meta span {
+    color: #B8C4D2;
+    background: #0A1018;
+    border: 1px solid #26384E;
+    border-radius: 999px;
+    padding: 4px 8px;
+    font-size: 10.5px;
+    font-weight: 760;
+}
+
+.access-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+    gap: 8px;
+    margin: 8px 0 16px 0;
+}
+
+.access-item {
+    background: #0F151D;
+    border: 1px solid var(--procura-border);
+    border-radius: 8px;
+    padding: 10px 12px;
+}
+
+.access-item span {
+    display: block;
+    color: var(--procura-muted);
+    font-size: 11px;
+    font-weight: 780;
+    margin-bottom: 4px;
+}
+
+.access-item b {
+    color: #748091;
+    font-size: 13px;
+}
+
+.access-item.is-on {
+    border-left: 3px solid var(--procura-green);
+}
+
+.access-item.is-on b {
+    color: #7CE0B7;
+}
+
+.access-item.is-off {
+    opacity: 0.72;
+}
+
+.bid-info-band {
+    background: #0D1520;
+    background-image: linear-gradient(180deg, rgba(24, 36, 51, 0.98), rgba(11, 18, 27, 0.98));
+    border: 1px solid rgba(126, 148, 173, 0.34);
+    border-radius: 8px;
+    padding: 16px;
+    margin: 10px 0 18px 0;
+    box-shadow: 0 18px 42px rgba(0, 0, 0, 0.22);
+}
+
+.rfq-summary-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(190px, 1fr));
+    gap: 11px;
+    margin: 0;
+}
+
+.rfq-summary-grid + .rfq-summary-grid {
+    margin-top: 11px;
+}
+
+.bid-contact-grid {
+    grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+}
+
+.rfq-summary-tile {
+    background: #101A27;
+    border: 1px solid rgba(126, 148, 173, 0.32);
+    border-left: 4px solid var(--procura-blue);
+    border-radius: 8px;
+    padding: 14px 15px;
+    min-height: 92px;
+    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.055), 0 10px 24px rgba(0, 0, 0, 0.12);
+}
+
+.rfq-summary-tile span {
+    display: block;
+    color: var(--procura-muted);
+    font-size: 10px;
+    font-weight: 820;
+    text-transform: uppercase;
+    margin-bottom: 6px;
+}
+
+.rfq-summary-tile b {
+    display: block;
+    color: var(--procura-text);
+    font-size: 13.5px;
+    line-height: 1.35;
+    word-break: break-word;
+}
+
+.rfq-summary-tile small {
+    display: block;
+    color: var(--procura-muted);
+    font-size: 11px;
+    line-height: 1.35;
+    margin-top: 7px;
+}
+
+.rfq-summary-tile.tone-green {
+    border-left-color: var(--procura-green);
+    background: linear-gradient(180deg, rgba(16, 72, 55, 0.34), rgba(16, 72, 55, 0.16));
+}
+
+.rfq-summary-tile.tone-blue {
+    border-left-color: var(--procura-blue);
+    background: linear-gradient(180deg, rgba(37, 99, 235, 0.28), rgba(37, 99, 235, 0.13));
+}
+
+.rfq-summary-tile.tone-amber {
+    border-left-color: var(--procura-amber);
+    background: linear-gradient(180deg, rgba(245, 158, 11, 0.24), rgba(245, 158, 11, 0.11));
+}
+
+.rfq-summary-tile.decision-card b {
+    font-size: 15.5px;
+    color: #FFFFFF;
+}
+
+.rfq-email-preview {
+    background: #F7FAFC;
+    border: 1px solid #D8DEE8;
+    border-radius: 10px;
+    overflow: hidden;
+    box-shadow: 0 18px 50px rgba(0, 0, 0, 0.18);
+    margin: 14px 0;
+}
+
+.rfq-email-header {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 16px;
+    background: #0B1320;
+    padding: 22px 24px;
+}
+
+.rfq-email-kicker {
+    color: #7CE0B7;
+    font-size: 11px;
+    font-weight: 820;
+    text-transform: uppercase;
+    margin-bottom: 6px;
+}
+
+.rfq-email-title {
+    color: #FFFFFF;
+    font-size: 23px;
+    font-weight: 850;
+    line-height: 1.15;
+}
+
+.rfq-email-subject {
+    color: #A8B3C5;
+    font-size: 13px;
+    line-height: 1.4;
+    margin-top: 6px;
+}
+
+.rfq-email-badge {
+    color: #0B1320;
+    background: #7CE0B7;
+    border-radius: 999px;
+    padding: 5px 10px;
+    font-size: 10px;
+    font-weight: 850;
+    text-transform: uppercase;
+}
+
+.rfq-email-meta {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+    gap: 8px;
+    padding: 16px 18px 8px 18px;
+    background: #FFFFFF;
+}
+
+.rfq-email-meta div {
+    border: 1px solid #D8DEE8;
+    border-radius: 8px;
+    padding: 9px 10px;
+    background: #F8FAFC;
+}
+
+.rfq-email-meta span {
+    display: block;
+    color: #64748B;
+    font-size: 10px;
+    font-weight: 850;
+    text-transform: uppercase;
+    margin-bottom: 4px;
+}
+
+.rfq-email-meta b {
+    color: #0F172A;
+    font-size: 12px;
+    line-height: 1.35;
+}
+
+.rfq-email-body {
+    background: #FFFFFF;
+    color: #172033;
+    font-size: 13.5px;
+    line-height: 1.58;
+    padding: 18px 24px 24px 24px;
+    white-space: normal;
+    max-height: 620px;
+    overflow: auto;
+}
+
+[data-testid="stDataFrame"] {
+    overflow: hidden;
+}
+
+[data-testid="stDataFrame"] [role="columnheader"] {
+    font-weight: 800 !important;
+}
+
+@media (max-width: 900px) {
+    .module-header,
+    .page-title-row,
+    .ops-hero {
+        flex-direction: column;
+        grid-template-columns: 1fr;
+    }
+    .admin-hero,
+    .table-toolbar {
+        flex-direction: column;
+    }
+    .free-source-grid,
+    .checklist-block {
+        grid-template-columns: 1fr;
+    }
+    .rfq-email-header {
+        flex-direction: column;
+    }
+    .table-toolbar-meta {
+        justify-content: flex-start;
+    }
+    .page-meta {
+        justify-content: flex-start;
+    }
+}