Upload 12 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+ACP[[:space:]]DATA[[:space:]]LIC[[:space:]]PASADAS[[:space:]]v2_2.xlsx filter=lfs diff=lfs merge=lfs -text

ACP DATA LIC PASADAS v2_2.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4bb7cc4520ec8508c72dfca9e9875d69b7680aa06dc45a2b8e789aaa4500ce2
+size 595577

Dockerfile

@@ -0,0 +1,31 @@
+# Usamos la imagen oficial de Playwright que ya tiene Chromium preinstalado
+FROM mcr.microsoft.com/playwright/python:v1.44.0-jammy
+
+# Establecer la carpeta de trabajo dentro del servidor
+WORKDIR /app
+
+# Copiar el archivo de requerimientos primero
+COPY requirements.txt .
+
+# Instalar los requerimientos de Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Asegurar que Chromium coincida con la version de Playwright instalada por pip
+RUN playwright install chromium
+
+# Copiar todo el resto del código del proyecto al servidor
+COPY . .
+
+# Crear configuración de Streamlit para Hugging Face (Evita AxiosError 403 / CORS)
+RUN mkdir -p .streamlit && \
+    echo "[server]\nport = 7860\naddress = \"0.0.0.0\"\nenableCORS = false\nenableXsrfProtection = false\n\n[browser]\ngatherUsageStats = false" > .streamlit/config.toml
+
+# Dar permisos de ejecución al script de arranque
+RUN chmod +x entrypoint.sh
+
+# Exponer los puertos necesarios (7860 es el que exige Hugging Face)
+EXPOSE 7860
+EXPOSE 8000
+
+# Comando para iniciar todo
+CMD ["./entrypoint.sh"]

README.md

@@ -1,8 +1,8 @@
 ---
-title: PROCURA
-emoji: 😻
+title: Procura Ai Acp
+emoji: 📈
 colorFrom: green
-colorTo: gray
+colorTo: blue
 sdk: docker
 pinned: false
 ---

api.py

@@ -0,0 +1,716 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Form, BackgroundTasks, Header, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List
+from pydantic import BaseModel
+import google.generativeai as genai
+import tempfile
+import os
+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) ---
+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.
+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": ""}]}
+"""
+
+@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)):
+    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
+        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}")
+
+        logger.info(f"{len(archivos_subidos)} pliego(s) analizados exitosamente.")
+        return json.loads(response.text)
+
+    except Exception as e:
+        logger.error(f"Error analizando pliego: {str(e)}")
+        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
+
+        # Solo últimos 15 correos para respetar el límite de 15 RPM de Gemini Free
+        lista_ids = mensajes[0].split()[-15:]
+
+        for id_correo in lista_ids:
+            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 local: descarta correos claramente irrelevantes antes de llamar a Gemini
+                    num_lic_clean = "".join(re.findall(r'\d+', licitacion_activa))
+                    palabras_clave = ["RFQ", "COTIZA", "QUOTE", "PROCURA", "PRECIO", "OFERTA", "SUMINISTRO"]
+                    es_relevante = num_lic_clean in asunto or any(p in asunto.upper() for p in palabras_clave)
+                    if not es_relevante:
+                        continue
+
+                    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())
+                    # Limitar cuerpo a 2000 chars (era 3000) — reduce tokens sin perder contexto
+                    cuerpo_ia = cuerpo_limpio[:2000]
+
+                    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)
+                        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)
+):
+    background_tasks.add_task(procesar_correos_background, username, servidor_imap, licitacion_activa, contexto_items)
+    return {"status": "success", "mensaje": "🤖 Gemini está escaneando los correos en segundo plano. Los resultados aparecerán en la bandeja en breve."}
+
+
+# --- 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.")
+        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)
+        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)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# --- 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:
+        return {"status": "success", "username": user[0], "role": user[2]}
+    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)
+
+    db.update_user_profile(username, gemini_key, "", 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)):
+    rfq_id = "".join(filter(str.isdigit, str(rfq_id or "")))
+    if not rfq_id:
+        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."
+            )
+
+        logger.info(
+            f"Consulta SLI {rfq_id}: "
+            f"estatus={resultado['estatus']} | "
+            f"desc={resultado['descripcion']}"
+        )
+
+        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]
+            }
+        )

app.py

@@ -0,0 +1,1156 @@
+import streamlit as st
+import pandas as pd
+import json
+import urllib.parse
+import plotly.graph_objects as go
+from tavily import TavilyClient
+from email.message import EmailMessage
+
+from datetime import datetime
+import requests
+import os
+import re
+import io
+from html import escape
+import crypto
+from dotenv import load_dotenv
+import database as db
+
+load_dotenv()
+
+# --- 1. CONFIGURACIÓN INICIAL Y CIBERSEGURIDAD ---
+st.set_page_config(page_title="Proyelec Sourcing Pro", layout="wide", page_icon="💎", initial_sidebar_state="expanded")
+
+
+
+if "logged_in" not in st.session_state:
+    st.session_state.logged_in = False
+    st.session_state.username = ""
+    st.session_state.role = ""
+    st.session_state.gemini_key = ""
+    st.session_state.tavily_key = ""
+    st.session_state.email_user = ""
+    st.session_state.email_pass = ""
+if "procesado" not in st.session_state:
+    st.session_state.procesado = False
+if "df_exportar" not in st.session_state:
+    st.session_state.df_exportar = pd.DataFrame()
+if "cg" not in st.session_state:
+    st.session_state.cg = {}
+
+def encrypt_data(text):
+    return crypto.encrypt_data(text)
+
+def decrypt_data(text):
+    return crypto.decrypt_data(text)
+
+API_URL_BASE = os.getenv("API_URL_BASE", "http://localhost:8000/api/v1")
+API_HEADERS = {"X-Internal-Token": os.getenv("INTERNAL_API_TOKEN", "default-dev-token")}
+MAPA_ESTADOS_SLI = {
+    "EVALUACIÓN": "En Evaluacion Economica",
+    "EVALUACION": "En Evaluacion Economica",
+    "ADJUDICADA": "Adjudicada",
+    "CANCELADA":  "No Adjudicada",
+    "DESIERTA":   "Desierta",
+    "CERRADA":    "Oferta Enviada al SLI",
+    "ABIERTA":    "En Preparacion",
+}
+
+
+# --- 2. BASE DE DATOS LOCAL Y PERSISTENCIA ---
+def init_db():
+    db.init_db()
+
+init_db()
+
+# Workspace multi
+def save_workspace_state(username, cg_dict, df):
+    lic = cg_dict.get('numero_licitacion', 'Sin_Numero')
+    db.save_workspace(username, str(lic), df.to_json(orient="records"), json.dumps(cg_dict))
+
+def load_workspace_state(username):
+    row = db.load_workspace_state(username)
+    if row and row[0] and row[1]:
+        return pd.read_json(io.StringIO(row[0])), json.loads(row[1])
+    return None, None
+
+def load_workspace_by_licitacion(username, licitacion):
+    row = db.load_workspace(username, licitacion)
+    if row and row[0] and row[1]:
+        return pd.read_json(io.StringIO(row[0])), json.loads(row[1])
+    return None, None
+
+def verify_login(username, password):
+    user_data = db.get_user(username, password)
+    if user_data:
+        u_list = list(user_data)
+        role = u_list[2]
+        
+        # Compartir llaves de Gerencia con los Analistas si no tienen las suyas propias
+        if role == "Analista":
+            conn = db.get_connection()
+            c = conn.cursor()
+            c.execute("SELECT gemini_key, tavily_key, email_user, email_pass_enc FROM users WHERE role='Gerencia' AND gemini_key != '' LIMIT 1")
+            gerencia = c.fetchone()
+            conn.close()
+            
+            if gerencia:
+                if not u_list[3]: u_list[3] = gerencia[0] # gemini_key
+                if not u_list[4]: u_list[4] = gerencia[1] # tavily_key
+                if not u_list[5]: u_list[5] = gerencia[2] # email_user
+                if not u_list[6]: u_list[6] = gerencia[3] # email_pass_enc
+                
+        return tuple(u_list)
+    return None
+
+def update_user_profile(username, gemini, tavily, email, raw_email_pass):
+    enc_pass = encrypt_data(raw_email_pass) if raw_email_pass else ""
+    db.update_user_profile(username, gemini, tavily, email, enc_pass)
+
+def save_history(username, licitacion, items_count):
+    db.save_history(username, licitacion, items_count)
+
+def get_user_history(username):
+    return db.get_user_history_df(username)
+
+def obtener_correos_licitacion(licitacion):
+    return db.get_correos_licitacion_df(licitacion)
+
+def activar_organizacion_imap():
+    try:
+        items_json = st.session_state.df_exportar.to_json(orient="records") if not st.session_state.df_exportar.empty else "[]"
+        num_lic = "".join(re.findall(r'\d+', str(st.session_state.cg.get('numero_licitacion', ''))))
+        datos = {"username": st.session_state.username, "licitacion_activa": num_lic, "contexto_items": items_json}
+        res = requests.post(f"{API_URL_BASE}/organizar-correos", data=datos, headers=API_HEADERS)
+        if res.status_code == 200: return True, res.json().get("mensaje", "Organización completada.")
+        else: return False, f"Error del servidor: {res.text}"
+    except Exception as e: return False, str(e)
+
+# --- 3. CSS PREMIUM Y NAVBAR FULL-WIDTH ---
+try:
+    with open('style.css', 'r') as f:
+        st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
+except:
+    pass
+
+# --- 4. LOGIN CON IDENTIDAD PROYELEC ---
+if not st.session_state.logged_in:
+    st.markdown("""
+    <style>
+    [data-testid="stAppViewContainer"] {
+        background: radial-gradient(ellipse at 20% 50%, #0d1f3c 0%, #0A0E1A 60%);
+    }
+    [data-testid="stSidebar"] { display: none; }
+    [data-testid="stHeader"] { display: none; }
+    .block-container {
+        padding-top: 5vh !important;
+        max-width: 460px !important;
+    }
+    .login-title {
+        font-size: 24px; font-weight: 800; color: #F0F6FC;
+        letter-spacing: -0.5px; margin: 12px 0 2px 0; text-align: center;
+    }
+    .login-subtitle {
+        font-size: 12px; color: #58A6FF; font-weight: 500;
+        letter-spacing: 1.5px; text-transform: uppercase; margin-bottom: 24px; text-align: center;
+    }
+    .login-footer {
+        font-size: 11px; color: #484f58; margin-top: 24px; text-align: center;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+    col_logo = st.columns([1,3,1])[1]
+    with col_logo:
+        try:
+            st.image("proyelec_logo.png", use_container_width=True)
+        except Exception:
+            st.markdown("<div style='text-align:center; font-size:48px;'>⚡</div>", unsafe_allow_html=True)
+
+    st.markdown("""
+        <div class="login-title">PROYELEC</div>
+        <div class="login-subtitle">Sourcing Intelligence Pro</div>
+    """, unsafe_allow_html=True)
+
+    user_input = st.text_input("Usuario", placeholder="Usuario corporativo", label_visibility="collapsed")
+    pass_input = st.text_input("Contraseña", type="password", placeholder="Contraseña", label_visibility="collapsed")
+    st.write("")
+    if st.button("Ingresar al Sistema", type="primary", use_container_width=True):
+        user_data = verify_login(user_input, pass_input)
+        if user_data:
+            st.session_state.logged_in = True
+            st.session_state.username  = user_data[0]
+            st.session_state.role      = user_data[2] if user_data[2] else "Analista"
+            st.session_state.gemini_key  = user_data[3] if user_data[3] else ""
+            st.session_state.tavily_key  = user_data[4] if user_data[4] else ""
+            st.session_state.email_user  = user_data[5] if user_data[5] else ""
+            st.session_state.email_pass  = decrypt_data(user_data[6]) if user_data[6] else ""
+            df_saved, cg_saved = load_workspace_state(user_data[0])
+            if df_saved is not None:
+                st.session_state.df_exportar = df_saved
+                st.session_state.cg = cg_saved
+                st.session_state.procesado = True
+            st.rerun()
+        else:
+            st.error("Credenciales incorrectas. Intenta de nuevo.")
+
+    st.markdown('<div class="login-footer">Acceso restringido — Solo personal autorizado Proyelec</div>', unsafe_allow_html=True)
+    st.stop()
+
+# --- NAVBAR RENDER ---
+st.markdown(f"""
+    <div class="top-navbar">
+        <div style="font-size: 20px; font-weight: 800; color: #58A6FF; letter-spacing: -0.5px;">💎 PROYELEC <span style="color:white; font-weight:300;">SOURCING PRO</span></div>
+        <div style="font-size: 13px; color: #8B949E;">Usuario: <b style="color:#F0F6FC;">{st.session_state.username}</b> &nbsp;<span style="background:#1E2A3A;color:#58A6FF;padding:2px 8px;border-radius:10px;font-size:11px;">{st.session_state.role}</span> &nbsp;| {datetime.now().strftime("%d/%m/%Y")}</div>
+    </div>
+    <div class="main-content-spacer"></div>
+""", unsafe_allow_html=True)
+
+# --- PANEL DE ADMINISTRACION GLOBAL ---
+if st.session_state.username == "admin":
+    st.markdown("""<style>[data-testid="stSidebar"] { display: none !important; }</style>""", unsafe_allow_html=True)
+    st.title("🛡️ Panel de Control Global")
+    st.markdown("Gestión de usuarios y monitorización del sistema central.")
+    
+    tab_users, tab_stats = st.tabs(["👥 Gestión de Personal", "📊 Estadísticas del Sistema"])
+    
+    with tab_users:
+        col1, col2 = st.columns([0.6, 0.4])
+        with col1:
+            st.subheader("Personal Registrado")
+            df_users = db.get_all_users()
+            st.dataframe(df_users, use_container_width=True, hide_index=True)
+            
+            st.markdown("---")
+            st.subheader("Acciones Rápidas")
+            ac1, ac2 = st.columns(2)
+            with ac1:
+                del_user = st.text_input("Eliminar Usuario", placeholder="Nombre de usuario")
+                if st.button("🗑️ Eliminar Acceso", type="secondary"):
+                    if del_user == "admin": st.error("No puedes eliminar al administrador maestro.")
+                    elif del_user:
+                        if db.delete_user(del_user):
+                            st.success(f"Usuario {del_user} eliminado.")
+                            st.rerun()
+                        else: st.warning("Usuario no encontrado.")
+            with ac2:
+                reset_user = st.text_input("Resetear Contraseña", placeholder="Nombre de usuario")
+                new_pass = st.text_input("Nueva contraseña", type="password")
+                if st.button("🔄 Cambiar Contraseña", type="primary"):
+                    if reset_user and new_pass:
+                        db.reset_user_password(reset_user, new_pass)
+                        st.success("Contraseña actualizada.")
+                        st.rerun()
+        
+        with col2:
+            st.markdown("""
+            <div style='background:#161B22; border:1px solid #30363D; padding:20px; border-radius:12px;'>
+                <h3 style='margin-top:0; color:#58A6FF;'>➕ Nuevo Usuario</h3>
+            """, unsafe_allow_html=True)
+            new_u = st.text_input("Nombre de Usuario (Login)")
+            new_p = st.text_input("Contraseña Temporal", type="password")
+            new_r = st.selectbox("Nivel de Acceso", ["Analista", "Gerencia"])
+            if st.button("Crear Cuenta", use_container_width=True, type="primary"):
+                if new_u and new_p:
+                    if db.create_user(new_u, new_p, new_r):
+                        st.success(f"✅ Cuenta de {new_r} creada para '{new_u}'")
+                        st.rerun()
+                    else:
+                        st.error("⚠️ El usuario ya existe.")
+                else:
+                    st.warning("Completa los campos.")
+            st.markdown("</div>", unsafe_allow_html=True)
+            
+            st.markdown("<br>", unsafe_allow_html=True)
+            with st.expander("🔑 Configurar API Keys por Usuario"):
+                target_u = st.selectbox("Seleccionar Usuario", [""] + df_users['Usuario'].tolist())
+                if target_u:
+                    conn = db.get_connection()
+                    c = conn.cursor()
+                    c.execute("SELECT gemini_key, tavily_key, email_user, email_pass_enc FROM users WHERE username=?", (target_u,))
+                    curr = c.fetchone()
+                    conn.close()
+                    
+                    if curr:
+                        new_g = st.text_input("Gemini API Key", value=curr[0], type="password", key="g_key")
+                        new_t = st.text_input("Tavily API Key", value=curr[1], type="password", key="t_key")
+                        new_e = st.text_input("Correo (IMAP/SMTP)", value=curr[2], key="e_key")
+                        new_p = st.text_input("Contraseña de Correo", type="password", key="p_key", help="Solo escribe aquí si deseas cambiarla o configurarla por primera vez.")
+                        
+                        if st.button("Guardar Llaves", type="primary", use_container_width=True):
+                            # Si se escribió algo en new_p, lo encriptamos. Si no, mantenemos el actual (curr[3])
+                            final_p_enc = encrypt_data(new_p) if new_p else curr[3]
+                            db.update_user_profile(target_u, new_g, new_t, new_e, final_p_enc)
+                            st.success(f"Configuración guardada para {target_u}")
+                            st.rerun()
+
+    with tab_stats:
+        st.subheader("Salud del Sistema")
+        conn = db.get_connection()
+        try:
+            total_lic_monitor = pd.read_sql_query("SELECT COUNT(*) as c FROM seguimiento_licitaciones", conn).iloc[0]['c']
+            total_historial = pd.read_sql_query("SELECT COUNT(*) as c FROM history", conn).iloc[0]['c']
+            total_fichas = pd.read_sql_query("SELECT COUNT(*) as c FROM fichas_cache", conn).iloc[0]['c']
+        except Exception:
+            total_lic_monitor, total_historial, total_fichas = 0, 0, 0
+        conn.close()
+        
+        s1, s2, s3 = st.columns(3)
+        s1.metric("Licitaciones en Monitor ACP", total_lic_monitor)
+        s2.metric("Pliegos Analizados (Histórico)", total_historial)
+        s3.metric("Fichas Técnicas Generadas", total_fichas)
+
+    st.markdown("---")
+    if st.button("Cerrar Sesión Segura", type="primary", use_container_width=True):
+        st.session_state.clear()
+        st.rerun()
+
+    st.stop()
+
+# --- 5. SIDEBAR ---
+with st.sidebar:
+    st.markdown("<br><br>", unsafe_allow_html=True) 
+    
+    st.title("📄 1. Cargar Requerimiento")
+    st.caption("Sube el pliego principal y los anexos técnicos en formato PDF.")
+    archivos_pdf = st.file_uploader("", type=["pdf"], label_visibility="collapsed", accept_multiple_files=True)
+    
+    if st.button("🚀 Procesar con IA", type="primary", use_container_width=True):
+        if not st.session_state.gemini_key: st.error("⚠️ Verifica tus API Keys en la configuración.")
+        elif not archivos_pdf: st.error("⚠️ Falta subir al menos un documento.")
+        else:
+            with st.status("Conectando con Motor IA...", expanded=True) as status:
+                try:
+                    archivos = [("archivos_pdf", (f.name, f.getvalue(), "application/pdf")) for f in archivos_pdf]
+                    datos_formulario = {"gemini_key": st.session_state.gemini_key}
+                    respuesta_api = requests.post(f"{API_URL_BASE}/analizar-pliego", files=archivos, data=datos_formulario, headers=API_HEADERS)
+                    
+                    if respuesta_api.status_code == 200:
+                        datos_crudos = respuesta_api.json()
+                        cg = datos_crudos.get("condiciones_generales", {})
+                        df_exportar = pd.DataFrame(datos_crudos.get("items", []))
+
+                        try:
+                            if not os.path.exists("ACP DATA LIC PASADAS v2_2.xlsx"):
+                                st.warning("⚠️ No se encontró el histórico 'ACP DATA LIC PASADAS v2_2.xlsx'. Procesando sin precios base.")
+                            else:
+                                df_historico = pd.read_excel("ACP DATA LIC PASADAS v2_2.xlsx", skiprows=8).rename(columns=lambda x: str(x).strip())
+                                
+                                # Limpiar códigos aislando solo el ID puro (Primera palabra, sin basura de la IA) y haciendo alfanumérico
+                                df_historico['codigo_match'] = df_historico['CODIGO ACP'].astype(str).str.replace(r'[^a-zA-Z0-9]', '', regex=True).str.upper()
+                                df_exportar['codigo_match'] = df_exportar['codigo_articulo'].astype(str).str.split().str[0].str.replace(r'[^a-zA-Z0-9]', '', regex=True).str.upper()
+                                
+                                df_cruzado = pd.merge(df_exportar, df_historico.drop_duplicates(subset=['codigo_match'])[['codigo_match', 'PRECIO COMPETENCIA', 'PRECIO PROYELEC']], left_on='codigo_match', right_on='codigo_match', how='left')
+                                df_cruzado = df_cruzado.drop(columns=['codigo_match']).rename(columns={'PRECIO COMPETENCIA': "precio_comp_hist", 'PRECIO PROYELEC': "precio_proy_hist"})
+                                
+                                df_cruzado['precio_comp_hist'] = pd.to_numeric(df_cruzado['precio_comp_hist'], errors='coerce')
+                                df_cruzado['precio_proy_hist'] = pd.to_numeric(df_cruzado['precio_proy_hist'], errors='coerce')
+                                df_cruzado['margen_$'] = df_cruzado['precio_proy_hist'] - df_cruzado['precio_comp_hist']
+                                df_exportar = df_cruzado
+                        except Exception as excel_e: 
+                            st.warning(f"⚠️ Error leyendo Excel histórico: {excel_e}")
+
+                        save_history(st.session_state.username, str(cg.get('numero_licitacion', 'Desconocida')), len(df_exportar))
+                        save_workspace_state(st.session_state.username, cg, df_exportar)
+                        
+                        st.session_state.df_exportar, st.session_state.cg, st.session_state.procesado = df_exportar, cg, True
+                        status.update(label="✅ Análisis Completado", state="complete", expanded=False)
+                        st.rerun()
+                    else: status.update(label=f"❌ Error en API: {respuesta_api.text}", state="error")
+                except Exception as e: status.update(label=f"❌ Error crítico: {e}", state="error")
+    
+    st.divider()
+    
+    st.caption("Opciones del Sistema")
+    
+    # Indicador de estado de la API
+    try:
+        _r = requests.get(f"{API_URL_BASE.replace('/api/v1','')}/", timeout=2, headers=API_HEADERS)
+        if _r.status_code == 200:
+            st.markdown("<div style='background:#1a3a1a;border:1px solid #238636;border-radius:8px;padding:8px 12px;font-size:12px;color:#3fb950;margin-bottom:10px;'>🟢 Motor IA <b>Activo</b></div>", unsafe_allow_html=True)
+        else:
+            st.markdown("<div style='background:#3a1a1a;border:1px solid #f85149;border-radius:8px;padding:8px 12px;font-size:12px;color:#f85149;margin-bottom:10px;'>🔴 Motor IA <b>Sin respuesta</b></div>", unsafe_allow_html=True)
+    except Exception:
+        st.markdown("<div style='background:#3a1a1a;border:1px solid #f85149;border-radius:8px;padding:8px 12px;font-size:12px;color:#f85149;margin-bottom:10px;'>🔴 Motor IA <b>Apagado</b> — Ejecuta run.bat</div>", unsafe_allow_html=True)
+
+    if st.session_state.role == "Gerencia":
+        with st.expander("⚙️ Configuración y Llaves", expanded=False):
+            nueva_gemini = st.text_input("Gemini API Key", value=st.session_state.gemini_key, type="password")
+            nueva_tavily = st.text_input("Tavily API Key", value=st.session_state.tavily_key, type="password")
+            nuevo_email = st.text_input("Correo Proyelec", value=st.session_state.email_user)
+            nuevo_email_pass = st.text_input("Contraseña", value=st.session_state.email_pass, type="password")
+
+            if st.button("Guardar Cambios", use_container_width=True):
+                update_user_profile(st.session_state.username, nueva_gemini, nueva_tavily, nuevo_email, nuevo_email_pass)
+                st.session_state.gemini_key, st.session_state.tavily_key = nueva_gemini, nueva_tavily
+                st.session_state.email_user, st.session_state.email_pass = nuevo_email, nuevo_email_pass
+                st.toast("✅ Configuración guardada.")
+    else:
+        st.markdown("""
+        <div style='background:#0D1117;border:1px solid #1E2A3A;border-radius:8px;
+            padding:10px 14px;font-size:12px;color:#484f58;margin-bottom:8px;'>
+            ⚙️ Configuración administrada por Gerencia
+        </div>
+        """, unsafe_allow_html=True)
+
+    # --- PANEL DE ADMINISTRACIÓN (solo Gerencia) ---
+    if st.session_state.role == "Gerencia":
+        with st.expander("👥 Gestión de Usuarios", expanded=False):
+            st.caption("Panel exclusivo de Gerencia")
+
+            df_users = db.get_all_users()
+            if not df_users.empty:
+                for _, u in df_users.iterrows():
+                    u_col1, u_col2, u_col3 = st.columns([0.45, 0.3, 0.25])
+                    with u_col1:
+                        st.markdown(f"<div style='font-size:13px;color:#F0F6FC;padding-top:6px;'><b>{u['username']}</b></div>", unsafe_allow_html=True)
+                    with u_col2:
+                        roles_opt = ["Gerencia", "Analista"]
+                        idx = roles_opt.index(u['role']) if u['role'] in roles_opt else 1
+                        nuevo_rol = st.selectbox("", roles_opt, index=idx, key=f"rol_{u['username']}", label_visibility="collapsed")
+                        if nuevo_rol != u['role']:
+                            db.update_user_role(u['username'], nuevo_rol)
+                            st.toast(f"Rol de {u['username']} actualizado.")
+                            st.rerun()
+                    with u_col3:
+                        if u['username'] != st.session_state.username:
+                            if st.button("🗑️", key=f"del_{u['username']}", help=f"Eliminar {u['username']}"):
+                                db.delete_user(u['username'])
+                                st.toast(f"Usuario {u['username']} eliminado.")
+                                st.rerun()
+
+            st.divider()
+            st.caption("Crear nuevo usuario")
+            new_u = st.text_input("Username", key="new_username", placeholder="ej: analista2")
+            new_p = st.text_input("Contraseña", key="new_password", type="password", placeholder="mínimo 6 caracteres")
+            new_r = st.selectbox("Rol", ["Analista", "Gerencia"], key="new_role")
+            if st.button("➕ Crear Usuario", use_container_width=True):
+                if new_u and new_p and len(new_p) >= 6:
+                    ok = db.create_user(new_u, new_p, new_r)
+                    if ok:
+                        st.toast(f"✅ Usuario '{new_u}' creado con rol {new_r}.")
+                        st.rerun()
+                    else:
+                        st.error(f"El usuario '{new_u}' ya existe.")
+                else:
+                    st.warning("Username y contraseña (mín. 6 chars) son requeridos.")
+
+            st.divider()
+            st.caption("Resetear contraseña")
+            reset_u = st.selectbox("Usuario", df_users['username'].tolist() if not df_users.empty else [], key="reset_user")
+            reset_p = st.text_input("Nueva contraseña", key="reset_pass", type="password")
+            if st.button("🔑 Resetear", use_container_width=True):
+                if reset_u and reset_p and len(reset_p) >= 6:
+                    db.reset_user_password(reset_u, reset_p)
+                    st.toast(f"✅ Contraseña de '{reset_u}' actualizada.")
+                else:
+                    st.warning("Selecciona usuario y escribe la nueva contraseña.")
+
+    if st.button("🚪 Cerrar Sesión", use_container_width=True):
+        st.session_state.logged_in = False
+        st.session_state.procesado = False
+        st.session_state.role = ""
+        st.rerun()
+
+# --- 7. RENDERIZADO VISUAL PRINCIPAL ---
+# Colores y emojis por estado ACP
+ESTADO_CONFIG = {
+    "En Preparacion":         ("🔵", "#1E3A5F", "#58A6FF"),
+    "Oferta Enviada al SLI":  ("🟡", "#3D2E00", "#E3B341"),
+    "Cumple Tecnicamente":    ("🟢", "#1A3A1A", "#3FB950"),
+    "No Cumple Tecnicamente": ("🔴", "#3A1A1A", "#F85149"),
+    "En Evaluacion Economica":("🟠", "#3A2A00", "#F0883E"),
+    "Adjudicada":             ("🏆", "#1A3A2A", "#10B981"),
+    "No Adjudicada":          ("❌", "#2A1A1A", "#6E7681"),
+    "Desierta":               ("🚫", "#2A2A2A", "#484F58"),
+}
+
+# Redefinicion visual: badges sobrios para el tablero operativo.
+ESTADO_CONFIG.update({
+    "En Preparacion":         ("", "#101A2A", "#4F9CF9"),
+    "Oferta Enviada al SLI":  ("", "#261F0B", "#F6B44B"),
+    "Cumple Tecnicamente":    ("", "#0E241A", "#31C48D"),
+    "No Cumple Tecnicamente": ("", "#2A1111", "#EF5B5B"),
+    "En Evaluacion Economica":("", "#2A1D0F", "#F08A3C"),
+    "Adjudicada":             ("", "#0E241A", "#31C48D"),
+    "No Adjudicada":          ("", "#171C24", "#748091"),
+    "Desierta":               ("", "#171C24", "#748091"),
+})
+
+tab_main, tab_hist, tab_acp = st.tabs([
+    "🚀 Tablero de Operaciones",
+    "📚 Base de Conocimiento",
+    "🏛️ Monitor ACP"
+])
+
+with tab_acp:
+    st.markdown("<div class='section-title'>Monitor ACP</div>", unsafe_allow_html=True)
+    st.markdown("<div class='section-subtitle'>Seguimiento de licitaciones, estados SLI y alertas de evaluacion.</div>", unsafe_allow_html=True)
+    seg_df = db.get_seguimientos()
+
+    # --- KPIs del monitor ---
+    total_seg    = len(seg_df)
+    adjudicadas  = len(seg_df[seg_df['estado'] == 'Adjudicada']) if not seg_df.empty else 0
+    en_proceso   = len(seg_df[seg_df['estado'].isin(['Oferta Enviada al SLI', 'Cumple Tecnicamente', 'En Evaluacion Economica'])]) if not seg_df.empty else 0
+    tasa         = f"{int(adjudicadas/total_seg*100)}%" if total_seg > 0 else "—"
+
+    mk1, mk2, mk3, mk4 = st.columns(4)
+    mk1.metric("Total Licitaciones", total_seg)
+    mk2.metric("En Evaluación", en_proceso)
+    mk3.metric("Adjudicadas", adjudicadas)
+    mk4.metric("Tasa de Éxito", tasa)
+    st.divider()
+
+    col_monitor, col_form = st.columns([0.62, 0.38])
+
+    with col_form:
+        with st.expander("➕ Añadir Licitación al Seguimiento", expanded=(total_seg == 0)):
+            f_num  = st.text_input("Nº Licitación ACP (RFQ)*", placeholder="Ej: 213330", key="seg_num")
+            f_nota  = st.text_area("Notas internas (opcional)", key="seg_nota", height=60)
+            
+            if st.button("Añadir al Monitor", type="primary", use_container_width=True):
+                if f_num:
+                    sli_rfq = "".join(filter(str.isdigit, f_num))
+                    with st.status(f"Obteniendo datos del SLI para {sli_rfq}...", expanded=True):
+                        try:
+                            # Hacer peticion a la API local para consultar el SLI
+                            resp_sli = requests.get(f"{API_URL_BASE}/consultar-sli/{sli_rfq}", timeout=45, headers=API_HEADERS)
+                            
+                            f_obj = f"Licitación {sli_rfq}"
+                            f_link = f"https://apps.pancanal.com/sli/Licitaciones/LicitacionHeader?rfqId={sli_rfq}"
+                            f_estatus = ""
+                            
+                            if resp_sli.status_code == 200:
+                                datos_sli = resp_sli.json()
+                                if datos_sli.get("descripcion"):
+                                    f_obj = datos_sli.get("descripcion")
+                                if datos_sli.get("url"):
+                                    f_link = datos_sli.get("url")
+                                f_estatus = datos_sli.get("estatus", "")
+                                
+                            ok = db.crear_seguimiento(
+                                sli_rfq, f_obj, "", "",
+                                0.0, "USD", f_link, f_nota, st.session_state.username)
+                            
+                            if ok:
+                                # buscar la licitacion insertada
+                                seg_df_new = db.get_seguimientos()
+                                lic_row = seg_df_new[seg_df_new['numero_licitacion'] == sli_rfq]
+                                if not lic_row.empty and f_estatus:
+                                    lic_id = int(lic_row.iloc[0]['id'])
+                                    estado_mapeado = MAPA_ESTADOS_SLI.get(f_estatus.upper(), f_estatus)
+                                    db.actualizar_estado(lic_id, estado_mapeado, f"Estado inicial desde SLI: {f_estatus}", "Sistema SLI")
+                                st.toast(f"✅ Licitación {sli_rfq} añadida al monitor.")
+                                st.rerun()
+                            else:
+                                st.error(f"La licitación '{sli_rfq}' ya existe en el sistema.")
+                        except Exception as e:
+                            st.error(f"Error conectando con la API: {e}")
+                else:
+                    st.warning("El número de licitación es obligatorio.")
+
+        st.caption("🔗 Acceso rápido al portal")
+        st.link_button("Abrir SLI de la ACP", "https://sli.pancanal.com", use_container_width=True)
+
+    with col_monitor:
+        if seg_df.empty:
+            st.markdown("""
+            <div style='text-align:center;padding:50px 20px;background:rgba(22,27,34,0.6);
+                border-radius:16px;border:1px dashed #30363D;'>
+                <div style='font-size:48px;margin-bottom:12px;'>🏛️</div>
+                <h3 style='color:#8B949E;font-weight:500;'>Sin licitaciones registradas</h3>
+                <p style='color:#484f58;font-size:13px;'>Usa el formulario para registrar la primera licitación ACP en seguimiento.</p>
+            </div>
+            """, unsafe_allow_html=True)
+        else:
+            estado_filtro = st.selectbox(
+                "Filtrar por estado",
+                ["Todos"] + list(db.ESTADOS_ACP),
+                label_visibility="collapsed",
+                key="monitor_estado_filtro"
+            )
+            seg_view = seg_df if estado_filtro == "Todos" else seg_df[seg_df["estado"] == estado_filtro]
+
+            if seg_view.empty:
+                st.info("No hay licitaciones en ese estado.")
+
+            for _, row in seg_view.iterrows():
+                estado    = row.get('estado', 'En Preparacion')
+                emoji, bg_color, txt_color = ESTADO_CONFIG.get(estado, ("🔵", "#1E3A5F", "#58A6FF"))
+                lic_id    = int(row['id'])
+                num_lic   = row.get('numero_licitacion', '')
+                objeto    = row.get('objeto', '')[:80]
+                resp      = row.get('responsable', '')
+                link_sli  = row.get('link_sli', '')
+                monto     = row.get('monto_ofertado', 0) or 0
+                moneda    = row.get('moneda', 'USD')
+                objeto_safe = escape(str(objeto or "Sin descripcion"))
+                resp_safe = escape(str(resp or "Sin responsable"))
+                estado_safe = escape(str(estado or ""))
+
+                # Calcular días desde envío oferta
+                dias_txt = ""
+                try:
+                    f_env_dt = datetime.strptime(str(row.get('fecha_envio_oferta', ''))[:10], "%Y-%m-%d")
+                    dias_el  = (datetime.now() - f_env_dt).days
+                    alerta   = " ⚠️" if dias_el > 60 and estado in ["Oferta Enviada al SLI", "En Evaluacion Economica"] else ""
+                    dias_txt = f"{dias_el} días en evaluación{alerta}"
+                except Exception:
+                    dias_txt = ""
+
+                with st.container():
+                    st.markdown(f"""
+                    <div class='monitor-row' style='--status-color:{txt_color};'>
+                        <div class='monitor-row-head'>
+                            <div>
+                                <div class='monitor-owner'>{resp_safe}</div>
+                                <div class='monitor-id'>{num_lic}</div>
+                                <div class='monitor-object'>{objeto_safe}</div>
+                            </div>
+                            <div>
+                                <div class='status-badge'><span class='status-dot'></span>{estado_safe}</div>
+                                <div class='monitor-meta'>
+                                    <span class='mini-pill'>{dias_txt or "Sin fecha base"}</span>
+                                    <span class='mini-pill'>{moneda} {monto:,.2f}</span>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    """, unsafe_allow_html=True)
+
+                    # Controles — fila 1: manual
+                    resumen_acta_cache = st.session_state.get(f"sli_resumen_acta_{lic_id}")
+                    if resumen_acta_cache:
+                        resumen_txt = escape(str(resumen_acta_cache.get("resumen", "Resumen de propuestas consultado.")))
+                        st.markdown(f"""
+                        <div class='sli-summary'>
+                            <div class='sli-summary-title'>Resumen SLI</div>
+                            <div class='sli-summary-body'>{resumen_txt}</div>
+                        </div>
+                        """, unsafe_allow_html=True)
+                        hallazgos_cache = resumen_acta_cache.get("hallazgos", [])
+                        if hallazgos_cache:
+                            with st.expander("Ver observaciones detectadas en resumen SLI"):
+                                for hallazgo in hallazgos_cache:
+                                    st.markdown(f"- {hallazgo}")
+                        if resumen_acta_cache.get("url"):
+                            st.link_button("Abrir resumen SLI", resumen_acta_cache.get("url"))
+
+                    ac1, ac2, ac3 = st.columns([0.4, 0.35, 0.25])
+                    nuevo_estado = ac1.selectbox("Estado manual", db.ESTADOS_ACP,
+                        index=db.ESTADOS_ACP.index(estado) if estado in db.ESTADOS_ACP else 0,
+                        key=f"est_{lic_id}", label_visibility="collapsed")
+                    nota_upd = ac2.text_input("Nota", key=f"nota_{lic_id}",
+                        placeholder="Observación...", label_visibility="collapsed")
+                    with ac3:
+                        if st.button("Guardar", key=f"upd_{lic_id}", use_container_width=True):
+                            db.actualizar_estado(lic_id, nuevo_estado, nota_upd, st.session_state.username)
+                            st.toast(f"✅ Estado actualizado a '{nuevo_estado}'")
+                            st.rerun()
+
+                    # Controles — fila 2: consulta automática SLI
+                    sli_col1, sli_col2, sli_col3 = st.columns([0.38, 0.34, 0.28])
+                    with sli_col1:
+                        sli_rfq = "".join(filter(str.isdigit, num_lic))
+                        if st.button("Consultar SLI", key=f"sli_{lic_id}", use_container_width=True, type="primary"):
+                            with st.status(f"Consultando SLI para licitación {num_lic}...", expanded=True):
+                                try:
+                                    resp_sli = requests.get(
+                                        f"{API_URL_BASE}/consultar-sli/{sli_rfq}",
+                                        timeout=75,
+                                        headers=API_HEADERS
+                                    )
+                                    if resp_sli.status_code == 200:
+                                        datos_sli = resp_sli.json()
+                                        estatus_sli = datos_sli.get("estatus")
+                                        desc_sli    = datos_sli.get("descripcion", "")
+                                        cierre_sli  = datos_sli.get("fecha_cierre", "")
+                                        rev_sli     = datos_sli.get("ultima_revision", "")
+                                        resumen_acta = datos_sli.get("resumen_acta", {})
+                                        err_sli     = datos_sli.get("error")
+
+                                        if err_sli:
+                                            st.warning(f"⚠️ {err_sli}")
+                                        elif estatus_sli:
+                                            # Mapear estatus SLI al catálogo interno
+                                            estado_mapeado = MAPA_ESTADOS_SLI.get(
+                                                estatus_sli.upper(), estatus_sli)
+                                            nota_auto = f"[SLI Auto] Estatus: {estatus_sli}"
+                                            if cierre_sli:
+                                                nota_auto += f" | Cierre: {cierre_sli}"
+                                            if rev_sli:
+                                                nota_auto += f" | Última rev: {rev_sli}"
+                                            if resumen_acta.get("disponible"):
+                                                st.session_state[f"sli_resumen_acta_{lic_id}"] = resumen_acta
+                                                nota_auto += f" | Resumen: {resumen_acta.get('resumen', '')}"
+                                                if resumen_acta.get("hallazgos"):
+                                                    nota_auto += " | Observaciones: " + " / ".join(resumen_acta.get("hallazgos", [])[:3])
+                                            elif resumen_acta.get("error"):
+                                                st.session_state.pop(f"sli_resumen_acta_{lic_id}", None)
+                                                nota_auto += f" | Resumen SLI: {resumen_acta.get('error')}"
+                                            db.actualizar_estado(lic_id, estado_mapeado,
+                                                nota_auto, "Sistema SLI")
+                                            if resumen_acta.get("disponible"):
+                                                st.info(resumen_acta.get("resumen", "Resumen de propuestas consultado."))
+                                                for hallazgo in resumen_acta.get("hallazgos", [])[:3]:
+                                                    st.markdown(f"- {hallazgo}")
+                                            st.success(f"✅ Estado SLI: **{estatus_sli}** — Registro actualizado")
+                                            st.rerun()
+                                        else:
+                                            st.warning("El SLI no devolvió un estatus reconocible.")
+                                    elif resp_sli.status_code == 503:
+                                        try:
+                                            err_detail = resp_sli.json().get("detail", {})
+                                        except Exception:
+                                            err_detail = {}
+                                        if isinstance(err_detail, dict):
+                                            st.error(f"⚠️ {err_detail.get('message', 'Servicio SLI no disponible')}")
+                                            if err_detail.get("hint"):
+                                                st.caption(err_detail.get("hint"))
+                                        else:
+                                            st.error(f"⚠️ {err_detail or 'Servicio SLI no disponible'}")
+                                    else:
+                                        try:
+                                            err_detail = resp_sli.json().get("detail", {})
+                                        except Exception:
+                                            err_detail = {}
+                                        if isinstance(err_detail, dict):
+                                            st.error(f"Error SLI {resp_sli.status_code}: {err_detail.get('message', 'No se pudo consultar el SLI')}")
+                                            if err_detail.get("hint"):
+                                                st.caption(err_detail.get("hint"))
+                                            if err_detail.get("technical"):
+                                                with st.expander("Detalle tecnico"):
+                                                    st.code(err_detail.get("technical"))
+                                        else:
+                                            st.error(f"Error SLI {resp_sli.status_code}: {err_detail or 'No se pudo consultar el SLI'}")
+                                except requests.exceptions.Timeout:
+                                    st.error("⏱️ El SLI tardó demasiado. Intenta de nuevo.")
+                                except Exception as e_sli:
+                                    st.error(f"Error: {e_sli}")
+                    with sli_col2:
+                        sli_url_directo = link_sli or f"https://apps.pancanal.com/sli/Licitaciones/LicitacionHeader?rfqId={sli_rfq}"
+                        st.link_button("Ver en SLI", sli_url_directo, use_container_width=True)
+                    with sli_col3:
+                        if st.button("Eliminar", key=f"del_seg_{lic_id}", help="Eliminar del Monitor ACP", use_container_width=True):
+                            db.eliminar_seguimiento(lic_id)
+                            st.toast(f"Seguimiento {num_lic} eliminado.", icon="🗑️")
+                            st.rerun()
+
+
+                    # Historial colapsable
+                    df_hist_seg = db.get_historial_seguimiento(lic_id)
+                    if not df_hist_seg.empty:
+                        with st.expander(f"📋 Historial ({len(df_hist_seg)} actualizaciones)"):
+                            for _, h in df_hist_seg.iterrows():
+                                h_emoji, _, h_color = ESTADO_CONFIG.get(h['estado_nuevo'], ("🔵","","#58A6FF"))
+                                st.markdown(f"""
+                                <div style='border-left:3px solid {h_color};padding:6px 12px;margin-bottom:6px;'>
+                                    <div style='font-size:11px;color:#484f58;'>{h['fecha'][:16]} — {h['registrado_por']}</div>
+                                    <div style='font-size:13px;color:#F0F6FC;'>{h_emoji} <b>{h['estado_nuevo']}</b></div>
+                                    <div style='font-size:12px;color:#8B949E;'>{h['nota'] or ''}</div>
+                                </div>
+                                """, unsafe_allow_html=True)
+                    st.markdown("---")
+
+with tab_hist:
+    df_history = get_user_history(st.session_state.username)
+
+    # --- STATS GLOBALES ---
+    total_lic_h = len(df_history)
+    total_reng_h = int(df_history['Renglones'].sum()) if not df_history.empty and 'Renglones' in df_history.columns else 0
+    ultima_h = df_history['Fecha Proceso'].iloc[0][:10] if not df_history.empty else "—"
+
+    hk1, hk2, hk3 = st.columns(3)
+    hk1.metric("Total Licitaciones Procesadas", total_lic_h)
+    hk2.metric("Total Renglones Analizados", total_reng_h)
+    hk3.metric("Última Actividad", ultima_h)
+    st.divider()
+
+    if df_history.empty:
+        st.markdown("""
+        <div style='text-align:center; padding:60px 20px; background:rgba(22,27,34,0.6);
+            border-radius:16px; border:1px dashed #30363D;'>
+            <div style='font-size:48px; margin-bottom:16px;'>📂</div>
+            <h3 style='color:#8B949E; font-weight:500;'>Sin registros aun</h3>
+            <p style='color:#484f58; font-size:14px;'>Procesa tu primer pliego para comenzar a construir el historial.</p>
+        </div>
+        """, unsafe_allow_html=True)
+    else:
+        # --- BUSCADOR ---
+        busqueda = st.text_input("🔍 Buscar por número de licitación", placeholder="Ej: ACP-2024-001", label_visibility="collapsed")
+        df_filtrado = df_history[df_history['Nº Licitación'].str.contains(busqueda, case=False, na=False)] if busqueda else df_history
+
+        col_tabla, col_acciones = st.columns([0.65, 0.35])
+
+        with col_tabla:
+            st.caption(f"Mostrando {len(df_filtrado)} de {len(df_history)} licitaciones — Selecciona una fila para ver opciones")
+            ev_hist = st.dataframe(
+                df_filtrado,
+                use_container_width=True,
+                hide_index=True,
+                on_select="rerun",
+                selection_mode="single-row",
+                column_config={
+                    "Nº Licitación": st.column_config.TextColumn("Nº Licitación", width="medium"),
+                    "Fecha Proceso": st.column_config.TextColumn("Fecha", width="medium"),
+                    "Renglones": st.column_config.NumberColumn("Renglones", width="small"),
+                }
+            )
+
+        with col_acciones:
+            st.caption("Acciones")
+
+            # --- WORKSPACES GUARDADOS ---
+            es_gerencia = st.session_state.role == "Gerencia"
+            df_ws_list = db.get_all_workspaces(st.session_state.username, all_users=es_gerencia)
+
+            if df_ws_list.empty:
+                st.info("No hay workspaces guardados.")
+            else:
+                st.caption(f"{'Todos los workspaces del equipo' if es_gerencia else 'Mis workspaces guardados'} ({len(df_ws_list)})")
+                for _, ws_row in df_ws_list.iterrows():
+                    ws_lic = ws_row['licitacion']
+                    ws_user = ws_row.get('username', st.session_state.username)
+                    ws_fecha = ws_row.get('fecha_guardado', '')[:10]
+                    wc1, wc2, wc3 = st.columns([0.5, 0.25, 0.25])
+                    with wc1:
+                        st.markdown(f"<div style='font-size:12px;color:#F0F6FC;padding-top:6px;'><b>{ws_lic}</b><br><span style='color:#484f58;font-size:10px;'>{ws_user} · {ws_fecha}</span></div>", unsafe_allow_html=True)
+                    with wc2:
+                        if st.button("Cargar", key=f"ws_load_{ws_user}_{ws_lic}", use_container_width=True):
+                            df_ws_load, cg_ws_load = load_workspace_by_licitacion(ws_user, ws_lic)
+                            if df_ws_load is not None:
+                                st.session_state.df_exportar = df_ws_load
+                                st.session_state.cg = cg_ws_load
+                                st.session_state.procesado = True
+                                st.toast(f"✅ Workspace '{ws_lic}' cargado.", icon="🔄")
+                                st.rerun()
+                    with wc3:
+                        if st.button("🗑️", key=f"ws_del_{ws_user}_{ws_lic}", help="Eliminar workspace"):
+                            db.delete_workspace(ws_user, ws_lic)
+                            st.toast(f"Workspace '{ws_lic}' eliminado.")
+                            st.rerun()
+
+            st.divider()
+
+            # Si seleccionaron una fila — ver sus correos
+            if len(ev_hist.selection.rows) > 0:
+                fila_hist = df_filtrado.iloc[ev_hist.selection.rows[0]]
+                lic_sel = str(fila_hist.get('Nº Licitación', ''))
+                num_sel = "".join(re.findall(r'\d+', lic_sel))
+
+                st.markdown(f"""
+                <div style='background:#161B22; border:1px solid #238636; border-radius:10px; padding:14px; margin-bottom:12px;'>
+                    <div style='font-size:11px; color:#3fb950; text-transform:uppercase; letter-spacing:1px;'>Seleccionada</div>
+                    <div style='font-size:14px; font-weight:700; color:#F0F6FC; margin-top:4px;'>{lic_sel}</div>
+                    <div style='font-size:11px; color:#8B949E;'>{int(fila_hist.get('Renglones', 0))} renglones procesados</div>
+                </div>
+                """, unsafe_allow_html=True)
+
+                df_correos_hist = obtener_correos_licitacion(num_sel)
+                n_correos = len(df_correos_hist)
+                st.metric("Correos en Bandeja", n_correos)
+
+                if n_correos > 0:
+                    with st.expander(f"📥 Ver {n_correos} correo(s) de esta licitación"):
+                        for _, ch in df_correos_hist.iterrows():
+                            st.markdown(f"""
+                            <div class='email-card'>
+                                <div style='display:flex;justify-content:space-between;color:#8B949E;font-size:11px;margin-bottom:6px;'>
+                                    <strong>{ch.get('remitente','')[:40]}</strong>
+                                    <span>{ch.get('fecha','')}</span>
+                                </div>
+                                <div style='color:#E0E0E0;font-size:14px;font-weight:600;margin-bottom:6px;'>{ch.get('asunto','')}</div>
+                                <div style='color:#C9D1D9;font-size:12px;'>💡 {ch.get('resumen','')}</div>
+                            </div>
+                            """, unsafe_allow_html=True)
+
+                st.markdown("<br>", unsafe_allow_html=True)
+                if st.button("🗑️ Eliminar este Registro", key=f"del_hist_{lic_sel}", use_container_width=True):
+                    db.delete_history_entry(st.session_state.username, lic_sel)
+                    st.toast(f"Registro {lic_sel} eliminado.", icon="🗑️")
+                    st.rerun()
+
+        st.divider()
+        # Exportar historial completo
+        buf_hist = io.BytesIO()
+        df_history.to_excel(buf_hist, index=False, engine='openpyxl')
+        
+        col_exp, col_del = st.columns([0.7, 0.3])
+        with col_exp:
+            st.download_button("📥 Exportar Historial a Excel", data=buf_hist.getvalue(),
+                file_name="Historial_PROCURA.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                use_container_width=True)
+        with col_del:
+            if st.button("⚠️ Borrar Todo", use_container_width=True, type="secondary"):
+                db.clear_all_history(st.session_state.username)
+                st.toast("Historial borrado completamente.", icon="✅")
+                st.rerun()
+
+with tab_main:
+    if not st.session_state.procesado:
+        # --- KPIs REALES DEL SISTEMA ---
+        df_hist_kpi = get_user_history(st.session_state.username)
+        total_lic = len(df_hist_kpi)
+        total_reng = int(df_hist_kpi['Renglones'].sum()) if not df_hist_kpi.empty and 'Renglones' in df_hist_kpi.columns else 0
+        ultima_act = df_hist_kpi['Fecha Proceso'].iloc[0][:10] if not df_hist_kpi.empty else "Sin actividad"
+
+        st.markdown("<br>", unsafe_allow_html=True)
+        st.markdown(f"""
+        <div style='text-align:center; margin-bottom: 8px;'>
+            <span style='font-size:13px; color:#58A6FF; font-weight:600; letter-spacing:2px; text-transform:uppercase;'>Centro de Mando</span>
+        </div>
+        <h2 style='text-align:center; color:#F0F6FC; margin:0 0 6px 0; font-weight:800;'>Bienvenido, {st.session_state.username}</h2>
+        <p style='text-align:center; color:#8B949E; margin-bottom:28px; font-size:14px;'>Sistema de Inteligencia de Sourcing — Proyelec</p>
+        """, unsafe_allow_html=True)
+
+        k1, k2, k3, k4 = st.columns(4)
+        k1.metric("Licitaciones Procesadas", total_lic)
+        k2.metric("Renglones Analizados", total_reng)
+        k3.metric("Ultima Actividad", ultima_act)
+        k4.metric("Motor IA", "Gemini 2.5 Flash")
+
+        st.markdown("<br>", unsafe_allow_html=True)
+        st.markdown("<p style='text-align:center;color:#484f58;font-size:13px;margin-bottom:20px;'>Para comenzar, sube el pliego en el panel izquierdo y presiona <b style=\'color:#58A6FF\'>Procesar con IA</b></p>", unsafe_allow_html=True)
+
+        c1, c2, c3 = st.columns(3)
+        with c1:
+            st.markdown("""
+            <div class='step-card'>
+                <div class='step-icon'>📄</div>
+                <h4>1. Carga el Pliego</h4>
+                <p style='color:#8B949E; font-size:14px;'>Sube el PDF oficial de la licitacion. Soporta pliego principal y anexos tecnicos simultaneamente.</p>
+            </div>
+            """, unsafe_allow_html=True)
+        with c2:
+            st.markdown("""
+            <div class='step-card'>
+                <div class='step-icon'>🧠</div>
+                <h4>2. Analisis con IA</h4>
+                <p style='color:#8B949E; font-size:14px;'>Gemini extrae renglones, codigos, cantidades y cruza automaticamente con el historico de precios.</p>
+            </div>
+            """, unsafe_allow_html=True)
+        with c3:
+            st.markdown("""
+            <div class='step-card'>
+                <div class='step-icon'>🎯</div>
+                <h4>3. Sourcing Global</h4>
+                <p style='color:#8B949E; font-size:14px;'>Busca los mejores proveedores, genera RFQs y organiza cotizaciones en tu bandeja inteligente.</p>
+            </div>
+            """, unsafe_allow_html=True)
+            
+    else:
+        df_render = st.session_state.df_exportar
+        cg_render = st.session_state.cg
+
+        t1, t2, t3, t4 = st.tabs(["📋 1. Matriz de Productos", "✉️ 2. Emisión de RFQs", "📥 3. Bandeja Inteligente", "📈 4. Análisis de Costos"])
+        
+        with t1:
+            st.markdown(f"""
+            <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-bottom: 10px;">
+                <div style="background:#161B22; padding:15px; border-radius:8px; border:1px solid #30363D;">
+                    <div style="font-size:11px; color:#8B949E; text-transform:uppercase;">Nº Licitación</div>
+                    <div style="font-size:16px; color:#58A6FF; font-weight:bold; margin-top:5px;">{cg_render.get('numero_licitacion', 'N/A')}</div>
+                </div>
+                <div style="background:#161B22; padding:15px; border-radius:8px; border:1px solid #30363D;">
+                    <div style="font-size:11px; color:#8B949E; text-transform:uppercase;">Lugar Entrega</div>
+                    <div style="font-size:14px; color:#E6EDF3; margin-top:5px; word-wrap:break-word;">{cg_render.get('lugar_de_entrega', 'N/A')}</div>
+                </div>
+                <div style="background:#161B22; padding:15px; border-radius:8px; border:1px solid #30363D;">
+                    <div style="font-size:11px; color:#8B949E; text-transform:uppercase;">Tiempo Entrega</div>
+                    <div style="font-size:14px; color:#E6EDF3; margin-top:5px; word-wrap:break-word;">{cg_render.get('tiempo_de_entrega_global', 'N/A')}</div>
+                </div>
+                <div style="background:#161B22; padding:15px; border-radius:8px; border:1px solid #30363D;">
+                    <div style="font-size:11px; color:#8B949E; text-transform:uppercase;">Garantía</div>
+                    <div style="font-size:14px; color:#E6EDF3; margin-top:5px; word-wrap:break-word;">{cg_render.get('garantia_exigida', 'N/A')}</div>
+                </div>
+                <div style="background:#161B22; padding:15px; border-radius:8px; border:1px solid #30363D;">
+                    <div style="font-size:11px; color:#8B949E; text-transform:uppercase;">Req. Prop. Técnica</div>
+                    <div style="font-size:14px; color:#3FB950; margin-top:5px; font-weight:bold;">{cg_render.get('propuesta_tecnica_requerida', 'N/A')}</div>
+                </div>
+                <div style="background:#161B22; padding:15px; border-radius:8px; border:1px solid #30363D;">
+                    <div style="font-size:11px; color:#8B949E; text-transform:uppercase;">Validez de Oferta</div>
+                    <div style="font-size:14px; color:#F0883E; margin-top:5px; font-weight:bold;">{cg_render.get('validez_de_la_oferta', 'N/A')}</div>
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
+            st.divider()
+            
+            col_config = {
+                "renglon": st.column_config.TextColumn("Renglón", width="small"),
+                "codigo_articulo": st.column_config.TextColumn("Código", width="medium"),
+                "cantidad": st.column_config.NumberColumn("Cant.", format="%d"),
+                "precio_comp_hist": st.column_config.NumberColumn("Mejor Comp.", format="$ %.2f"),
+                "precio_proy_hist": st.column_config.NumberColumn("Proyelec", format="$ %.2f"),
+                "margen_$": st.column_config.NumberColumn("Margen", format="$ %.2f"),
+                "ficha_tecnica_completa": None, "termino_de_busqueda_corto": None
+            }
+
+            col_exp, col_xls = st.columns([0.7, 0.3])
+            with col_exp:
+                st.caption("Selecciona una fila para ver el detalle y buscar proveedores.")
+            with col_xls:
+                _buf = io.BytesIO()
+                df_render.to_excel(_buf, index=False, engine='openpyxl')
+                st.download_button("Exportar Excel", data=_buf.getvalue(), file_name=f"Licitacion_{cg_render.get('numero_licitacion','')}.xlsx", mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", use_container_width=True)
+            event = st.dataframe(df_render, column_config=col_config, use_container_width=True, hide_index=True, on_select="rerun", selection_mode="single-row")
+
+            if len(event.selection.rows) > 0:
+                fila = df_render.iloc[event.selection.rows[0]]
+                termino_google = urllib.parse.quote(str(fila.get('termino_de_busqueda_corto', '')))
+                
+                # --- AQUÍ ESTÁ EL FIX DEL MARKDOWN CON LOS BOTONES DEL TAMAÑO CORRECTO ---
+                st.markdown(f"""
+                <div class="detail-card">
+                    <h3 style="color:#58A6FF; margin-top:0;">Renglón {fila.get('renglon', '-')} | Cód: {fila.get('codigo_articulo', 'N/A')}</h3>
+                    <div style="background-color:#0D1117; padding:15px; border-radius:8px; color:#C9D1D9; font-family:monospace; margin-bottom:15px; border: 1px solid #30363D;">{fila.get('ficha_tecnica_completa', 'Sin descripción')}</div>
+                    <div style="display: flex; gap: 15px; flex-wrap: wrap; margin-top: 20px;">
+                        <a style="background-color: #4285F4; color: white; padding: 12px 20px; border-radius: 8px; text-decoration: none; font-weight: 700; font-size: 15px; text-align: center; flex-grow: 1; min-width: 180px; box-shadow: 0 4px 6px rgba(0,0,0,0.3);" href="https://www.google.com/search?q={termino_google}+supplier+distributor" target="_blank">🔍 Google B2B</a>
+                        <a style="background-color: #0033A0; color: white; padding: 12px 20px; border-radius: 8px; text-decoration: none; font-weight: 700; font-size: 15px; text-align: center; flex-grow: 1; min-width: 180px; box-shadow: 0 4px 6px rgba(0,0,0,0.3);" href="https://www.thomasnet.com/search.html?cov=NA&what={termino_google}" target="_blank">⚙️ ThomasNet</a>
+                        <a style="background-color: #FF6A00; color: white; padding: 12px 20px; border-radius: 8px; text-decoration: none; font-weight: 700; font-size: 15px; text-align: center; flex-grow: 1; min-width: 180px; box-shadow: 0 4px 6px rgba(0,0,0,0.3);" href="https://www.alibaba.com/trade/search?SearchText={termino_google}" target="_blank">🛒 Alibaba</a>
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+
+                st.write("")
+                if st.button(f"Escaneo profundo - Renglon {fila.get('renglon')}", type="primary"):
+                    if not st.session_state.tavily_key: st.error("⚠️ Configura la API Key de Tavily en el panel izquierdo.")
+                    else:
+                        with st.status(f"Analizando bases de datos B2B para {fila.get('termino_de_busqueda_corto')}...", expanded=True):
+                            try:
+                                t_client = TavilyClient(api_key=st.session_state.tavily_key)
+                                res_tavily = t_client.search(query=f"B2B supplier distributor {fila.get('termino_de_busqueda_corto')} industrial parts", search_depth="advanced", max_results=3)
+                                st.toast("✅ Búsqueda completada", icon="🔍")
+                                
+                                st.markdown("#### 🌐 Mejores Proveedores Detectados:")
+                                cols = st.columns(3)
+                                for i, res in enumerate(res_tavily.get('results', [])):
+                                    with cols[i % 3]:
+                                        st.markdown(f"""
+                                        <div class="provider-card">
+                                            <h4 style="color:#58A6FF; margin-top:0;">{res.get('title', 'Supplier')}</h4>
+                                            <p style="font-size:12px; color:#8B949E;">{res.get('content', '')[:120]}...</p>
+                                            <a style="color:#10B981; font-weight:bold; text-decoration:none;" href="{res.get('url', '#')}" target="_blank">Visitar Website ↗</a>
+                                        </div>
+                                        """, unsafe_allow_html=True)
+                            except Exception as e: st.error(f"Fallo en scraping: {e}")
+                            
+                st.divider()
+                st.markdown("#### 📄 Generador de Fichas Técnicas Automáticas")
+                st.caption("Usa la IA para redactar una Ficha Técnica estructurada a partir del contexto del pliego.")
+                if st.button(f"Crear ficha tecnica - Renglon {fila.get('renglon')}", type="secondary"):
+                    if not st.session_state.gemini_key: st.error("⚠️ Verifica tus API Keys en la configuración.")
+                    else:
+                        with st.status("Redactando ficha técnica profesional...", expanded=True):
+                            try:
+                                payload = {
+                                    "username": st.session_state.username,
+                                    "licitacion": str(cg_render.get('numero_licitacion', '')),
+                                    "codigo_renglon": str(fila.get('codigo_articulo', '')),
+                                    "pliego_context": json.dumps(cg_render),
+                                    "items_context": fila.to_json(),
+                                    "gemini_key": st.session_state.gemini_key
+                                }
+                                res_ficha = requests.post(f"{API_URL_BASE}/generar-ficha", data=payload, headers=API_HEADERS)
+                                if res_ficha.status_code == 200:
+                                    data_ficha = res_ficha.json()
+                                    from_cache = data_ficha.get('from_cache', False)
+                                    label = "✅ Ficha cargada desde caché (sin gasto de tokens)" if from_cache else "✅ ¡Ficha Técnica Generada y guardada!"
+                                    st.success(label)
+                                    st.markdown("<div style='background-color:#0D1117; padding:20px; border-radius:10px; border:1px solid #30363D;'>", unsafe_allow_html=True)
+                                    st.markdown(data_ficha.get("datasheet_md", ""))
+                                    st.markdown("</div>", unsafe_allow_html=True)
+                                else:
+                                    st.error("Error al generar ficha: " + res_ficha.text)
+                            except Exception as e:
+                                st.error(f"Fallo en generación: {e}")
+
+        with t2:
+            st.markdown("### ✉️ Motor de Generación de Cotizaciones (RFQs)")
+            plantilla = st.selectbox("Modelo de Documento", ["Internacional (Inglés)", "Local (Español)"])
+            txt_base = "Dear Supplier,\n\nPlease quote for Bid {{NUMERO_LICITACION}}:\n{{LISTA_ITEMS}}\nDelivery: {{LUGAR_ENTREGA}}" if "Inglés" in plantilla else "Estimado Proveedor,\n\nFavor cotizar los siguientes renglones para la licitación {{NUMERO_LICITACION}}:\n{{LISTA_ITEMS}}\nLugar de Entrega: {{LUGAR_ENTREGA}}"
+            
+            items_str = "".join([f"- {r.get('codigo_articulo','')} | Qty: {r.get('cantidad','')}\n" for _, r in df_render.iterrows()])
+            cuerpo = txt_base.replace("{{NUMERO_LICITACION}}", str(cg_render.get('numero_licitacion'))).replace("{{LISTA_ITEMS}}", items_str).replace("{{LUGAR_ENTREGA}}", str(cg_render.get('lugar_de_entrega')))
+            
+            st.text_area("Borrador Master", value=cuerpo, height=200)
+            msg = EmailMessage()
+            msg.set_content(cuerpo)
+            msg['Subject'], msg['From'] = f"[PROY-ACP-{cg_render.get('numero_licitacion')}] RFQ", st.session_state.email_user
+            
+            c1, c2 = st.columns([0.3, 0.7])
+            with c1: st.download_button("📦 DESCARGAR MASTER (.eml)", data=msg.as_bytes(), file_name="Master_RFQ.eml", type="primary", use_container_width=True)
+
+        with t3:
+            st.markdown("### 📥 Centro de Mensajería y Respuestas")
+            st.caption("Centraliza los correos de proveedores entrantes y los clasifica por renglón usando Inteligencia Artificial.")
+            
+            col_filt, col_btn = st.columns([0.7, 0.3])
+            
+            num_clean = "".join(re.findall(r'\d+', str(cg_render.get('numero_licitacion', ''))))
+            with col_filt:
+                filtro = st.selectbox("🎯 Filtrar Bandeja por Renglón:", ["Ver Todos los Correos"] + [f"Renglón {r.get('renglon')} - {r.get('termino_de_busqueda_corto')}" for _, r in df_render.iterrows()])
+            
+            with col_btn:
+                st.write("") 
+                if st.button("🔄 Escanear Nuevos Correos", use_container_width=True):
+                    if not st.session_state.email_user or not st.session_state.email_pass: st.error("⚠️ Configura el correo corporativo en el panel lateral.")
+                    else:
+                        with st.status("Leyendo bandeja con Gemini AI...", expanded=True):
+                            exito, msj = activar_organizacion_imap()
+                            if exito: 
+                                st.toast("✅ Proceso iniciado en backend.", icon="📥")
+                                st.success("Bandeja actualizada")
+                                st.rerun()
+                            else: 
+                                st.error(msj)
+            
+            st.divider()
+            
+            df_correos = obtener_correos_licitacion(num_clean)
+            if df_correos.empty: 
+                st.info("📭 Bandeja limpia. Haz clic en 'Escanear Nuevos Correos' para revisar si hay cotizaciones de proveedores.")
+            else:
+                for _, c in df_correos.iterrows():
+                    tags = str(c.get('renglones_relacionados', '')).split(',')
+                    mostrar = True if filtro == "Ver Todos los Correos" else (filtro.split(" ")[1] in [t.strip() for t in tags])
+                    
+                    if mostrar:
+                        tags_html = "".join([f"<span class='tag-badge'>Renglón {t.strip()}</span>" for t in tags if t.strip()])
+                        st.markdown(f"""
+                        <div class="email-card">
+                            <div style="display:flex; justify-content:space-between; margin-bottom:8px; color:#8B949E; font-size:12px;">
+                                <strong>{c.get('remitente', 'Desconocido')}</strong><span>{c.get('fecha', '')}</span>
+                            </div>
+                            <div style="color:#E0E0E0; font-size:15px; font-weight:bold; margin-bottom:10px;">{c.get('asunto', '')}</div>
+                            <div style="margin-bottom:10px;">{tags_html}</div>
+                            <div style="color:#C9D1D9; font-size:13px; background:#0D1117; padding:10px; border-radius:6px; border:1px solid #30363D;">
+                                💡 <b>Resumen IA:</b> {c.get('resumen', '')}
+                            </div>
+                        </div>
+                        """, unsafe_allow_html=True)
+                        
+                        # --- AQUÍ AÑADIMOS EL DESPLEGABLE PARA LEER EL CORREO ORIGINAL ---
+                        with st.expander("📄 Leer correo original completo"):
+                            st.write(c.get('cuerpo', 'El cuerpo del correo no se pudo cargar.'))
+                            
+                        # --- BORRADOR DE RESPUESTA IA ---
+                        if c.get('borrador_respuesta') and c.get('borrador_respuesta').strip():
+                            st.markdown("##### 🤖 Borrador de Respuesta Propuesto por IA")
+                            st.text_area("Puedes editar y copiar este borrador para enviarlo al proveedor:", value=c.get('borrador_respuesta', ''), height=150, key=f"draft_{c.get('id', c.name)}")
+
+        with t4:
+            st.markdown("### 📈 Visualización de Costos")
+            if 'precio_comp_hist' in df_render.columns and not df_render['precio_comp_hist'].isna().all():
+                fig = go.Figure()
+                fig.add_trace(go.Bar(x=df_render['renglon'], y=df_render['precio_comp_hist'], name='Competencia', marker_color='#30363D'))
+                fig.add_trace(go.Bar(x=df_render['renglon'], y=df_render['precio_proy_hist'], name='Proyelec', marker_color='#58A6FF'))
+                fig.update_layout(template="plotly_dark", title="Análisis de Competitividad Histórica", barmode='group', plot_bgcolor='rgba(0,0,0,0)', paper_bgcolor='rgba(0,0,0,0)')
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.info("📊 **Sin Historial de Costos**\n\nNo se encontraron registros de precios anteriores para los códigos de esta licitación en la base de datos histórica. Los artículos parecen ser nuevos o no han sido cotizados previamente.")
+                
+                st.markdown("#### Volumen Solicitado por Renglón")
+                fig = go.Figure(data=[go.Bar(x=df_render['renglon'], y=df_render['cantidad'], marker_color='#238636')])
+                fig.update_layout(template="plotly_dark", plot_bgcolor='rgba(0,0,0,0)', paper_bgcolor='rgba(0,0,0,0)')
+                st.plotly_chart(fig, use_container_width=True)

config.toml

@@ -0,0 +1,8 @@
+[server]
+port = 7860
+address = "0.0.0.0"
+enableCORS = false
+enableXsrfProtection = false
+
+[browser]
+gatherUsageStats = false

crypto.py

@@ -0,0 +1,52 @@
+import os
+import logging
+from cryptography.fernet import Fernet
+from dotenv import load_dotenv
+
+load_dotenv()
+logger = logging.getLogger(__name__)
+
+# Inicialización segura de la clave Fernet compartida
+_enc_key_str = os.getenv("ENCRYPTION_KEY", "").strip()
+
+if not _enc_key_str:
+    _enc_key_str = Fernet.generate_key().decode()
+    try:
+        with open(".env", "a") as f:
+            f.write(f"\nENCRYPTION_KEY={_enc_key_str}\n")
+    except Exception as e:
+        logger.warning(f"No se pudo escribir en .env: {e}")
+    os.environ["ENCRYPTION_KEY"] = _enc_key_str
+    logger.warning("ENCRYPTION_KEY no encontrada — se generó una nueva.")
+
+# Extraer solo la llave si el usuario pegó "ENCRYPTION_KEY=..." por error
+if _enc_key_str.startswith("ENCRYPTION_KEY="):
+    _enc_key_str = _enc_key_str.split("=", 1)[1].strip()
+
+try:
+    ENCRYPTION_KEY = _enc_key_str.encode()
+    cipher_suite = Fernet(ENCRYPTION_KEY)
+except Exception as e:
+    logger.error(f"Error inicializando Fernet con la clave proporcionada: {e}")
+    # Fallback seguro en caso de clave inválida (evita que la app crashee, pero las contraseñas fallarán)
+    cipher_suite = Fernet(Fernet.generate_key())
+
+def encrypt_data(text: str) -> str:
+    """Cifra un texto plano utilizando la clave maestra."""
+    if not text: 
+        return ""
+    try:
+        return cipher_suite.encrypt(text.encode()).decode()
+    except Exception as e:
+        logger.error(f"Error al cifrar datos: {e}")
+        return ""
+
+def decrypt_data(text: str) -> str:
+    """Descifra un texto cifrado utilizando la clave maestra."""
+    if not text: 
+        return ""
+    try:
+        return cipher_suite.decrypt(text.encode()).decode()
+    except Exception as e:
+        logger.error(f"Error al descifrar datos: {e}")
+        return ""

database.py

@@ -0,0 +1,465 @@
+import sqlite3
+import pandas as pd
+from datetime import datetime
+import os
+import bcrypt
+
+DB_PATH = os.getenv("DB_PATH", "proyelec_crm.db")
+
+def get_connection(db_path=DB_PATH):
+    conn = sqlite3.connect(db_path, check_same_thread=False)
+    if db_path != ":memory:":
+        conn.execute('PRAGMA journal_mode=WAL;')
+    return conn
+
+def init_db():
+    conn = get_connection()
+    c = conn.cursor()
+
+    # Usuarios
+    c.execute('''CREATE TABLE IF NOT EXISTS users (
+        username TEXT PRIMARY KEY,
+        password TEXT,
+        role TEXT,
+        gemini_key TEXT,
+        tavily_key TEXT,
+        email_user TEXT,
+        email_pass_enc TEXT
+    )''')
+
+    # Historial de análisis
+    c.execute('''CREATE TABLE IF NOT EXISTS history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        username TEXT,
+        licitacion TEXT,
+        fecha TEXT,
+        items INTEGER
+    )''')
+
+    # Bandeja inteligente de correos
+    c.execute('''CREATE TABLE IF NOT EXISTS smart_inbox (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        licitacion TEXT,
+        remitente TEXT,
+        asunto TEXT,
+        fecha TEXT,
+        resumen TEXT,
+        renglones_relacionados TEXT,
+        cuerpo TEXT,
+        borrador_respuesta TEXT
+    )''')
+
+    # Cache de fichas técnicas (ahorra tokens Gemini)
+    c.execute('''CREATE TABLE IF NOT EXISTS fichas_cache (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        username TEXT,
+        licitacion TEXT,
+        codigo_renglon TEXT,
+        datasheet_md TEXT,
+        fecha TEXT,
+        UNIQUE(username, licitacion, codigo_renglon)
+    )''')
+
+    # Tabla de cotizaciones extraídas de correos (para uso futuro)
+    c.execute('''CREATE TABLE IF NOT EXISTS cotizaciones (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        licitacion TEXT,
+        renglon TEXT,
+        proveedor TEXT,
+        precio_unitario REAL,
+        moneda TEXT,
+        tiempo_entrega TEXT,
+        condiciones TEXT,
+        fecha TEXT,
+        email_asunto TEXT
+    )''')
+
+    # === MÚLTIPLES WORKSPACES POR USUARIO ===
+    c.execute('''CREATE TABLE IF NOT EXISTS workspaces (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        username TEXT NOT NULL,
+        licitacion TEXT NOT NULL,
+        data_json TEXT,
+        cg_json TEXT,
+        fecha_guardado TEXT,
+        UNIQUE(username, licitacion)
+    )''')
+
+    # app_state legacy (se mantiene para compatibilidad)
+    c.execute('''CREATE TABLE IF NOT EXISTS app_state (
+        username TEXT PRIMARY KEY,
+        last_licitacion TEXT,
+        last_data TEXT,
+        last_cg TEXT
+    )''')
+
+    # === MONITOR DE LICITACIONES ACP ===
+    c.execute('''CREATE TABLE IF NOT EXISTS seguimiento_licitaciones (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        numero_licitacion TEXT UNIQUE NOT NULL,
+        objeto TEXT,
+        fecha_asignacion TEXT,
+        fecha_envio_oferta TEXT,
+        monto_ofertado REAL,
+        moneda TEXT DEFAULT "USD",
+        estado TEXT DEFAULT "En Preparacion",
+        link_sli TEXT,
+        notas TEXT,
+        responsable TEXT,
+        fecha_registro TEXT
+    )''')
+    c.execute('''CREATE TABLE IF NOT EXISTS seguimiento_historial (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        licitacion_id INTEGER,
+        fecha TEXT,
+        estado_nuevo TEXT,
+        nota TEXT,
+        registrado_por TEXT,
+        FOREIGN KEY(licitacion_id) REFERENCES seguimiento_licitaciones(id)
+    )''')
+
+    # --- Migrar workspace legacy a nueva tabla si existe ---
+    c.execute("SELECT username, last_licitacion, last_data, last_cg FROM app_state")
+    legacy_rows = c.fetchall()
+    for row in legacy_rows:
+        uname, lic, data, cg = row
+        if lic and data and cg:
+            c.execute("""INSERT OR IGNORE INTO workspaces (username, licitacion, data_json, cg_json, fecha_guardado)
+                         VALUES (?, ?, ?, ?, ?)""",
+                      (uname, lic, data, cg, datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
+
+    # Usuario admin por defecto (contraseña: admin)
+    c.execute("SELECT * FROM users WHERE username='admin'")
+    if not c.fetchone():
+        salt = bcrypt.gensalt()
+        hashed_pw = bcrypt.hashpw(b"admin", salt).decode('utf-8')
+        c.execute("INSERT INTO users VALUES ('admin', ?, 'Gerencia', '', '', '', '')", (hashed_pw,))
+
+    conn.commit()
+    conn.close()
+
+# =============================================
+# WORKSPACES (MÚLTIPLES POR USUARIO)
+# =============================================
+
+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()
+    fecha = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    c.execute("""INSERT OR REPLACE INTO workspaces (username, licitacion, data_json, cg_json, fecha_guardado)
+                 VALUES (?, ?, ?, ?, ?)""",
+              (username, licitacion, data_json, cg_json, fecha))
+    conn.commit()
+    conn.close()
+
+def get_all_workspaces(username, all_users=False):
+    """Retorna todos los workspaces. Si all_users=True, retorna de todos los usuarios (para Gerencia)."""
+    conn = get_connection()
+    if all_users:
+        df = pd.read_sql_query(
+            """SELECT username, licitacion, fecha_guardado FROM workspaces
+               ORDER BY fecha_guardado DESC""", conn)
+    else:
+        df = pd.read_sql_query(
+            """SELECT username, licitacion, fecha_guardado FROM workspaces
+               WHERE username=? ORDER BY fecha_guardado DESC""",
+            conn, params=(username,))
+    conn.close()
+    return df
+
+def load_workspace(username, licitacion):
+    """Carga un workspace específico por licitación."""
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("SELECT data_json, cg_json FROM workspaces WHERE username=? AND licitacion=?",
+              (username, licitacion))
+    row = c.fetchone()
+    conn.close()
+    return row  # (data_json, cg_json) o None
+
+def delete_workspace(username, licitacion):
+    """Elimina un workspace guardado."""
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("DELETE FROM workspaces WHERE username=? AND licitacion=?", (username, licitacion))
+    conn.commit()
+    conn.close()
+
+# Legacy — mantener compatibilidad con código existente
+def save_workspace_state(username, licitacion, data_json, cg_json):
+    save_workspace(username, licitacion, data_json, cg_json)
+
+def load_workspace_state(username):
+    """Carga el workspace más reciente del usuario (compatibilidad legacy)."""
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("SELECT data_json, cg_json FROM workspaces WHERE username=? ORDER BY fecha_guardado DESC LIMIT 1",
+              (username,))
+    row = c.fetchone()
+    conn.close()
+    return row
+
+# =============================================
+# GESTIÓN DE USUARIOS (ADMIN)
+# =============================================
+
+def get_all_users():
+    """Retorna todos los usuarios del sistema para el panel de administración."""
+    conn = get_connection()
+    df = pd.read_sql_query(
+        "SELECT username as Usuario, role as Nivel, email_user as Correo, gemini_key as Clave_Gemini, tavily_key as Clave_Tavily FROM users ORDER BY role, Usuario", conn)
+    conn.close()
+    
+    # Enmascarar las llaves visualmente para seguridad (opcional, pero recomendado)
+    df['Clave_Gemini'] = df['Clave_Gemini'].apply(lambda x: f"{x[:12]}...{x[-4:]}" if x and len(x) > 15 else ("Sin configurar" if not x else x))
+    df['Clave_Tavily'] = df['Clave_Tavily'].apply(lambda x: f"{x[:12]}...{x[-4:]}" if x and len(x) > 15 else ("Sin configurar" if not x else x))
+    df['Correo'] = df['Correo'].apply(lambda x: x if x else "Sin configurar")
+    
+    return df
+
+def create_user(username, password_plain, role):
+    """Crea un nuevo usuario. Retorna True si exitoso, False si el username ya existe."""
+    conn = get_connection()
+    c = conn.cursor()
+    salt = bcrypt.gensalt()
+    hashed = bcrypt.hashpw(password_plain.encode(), salt).decode('utf-8')
+    try:
+        c.execute("INSERT INTO users (username, password, role, gemini_key, tavily_key, email_user, email_pass_enc) VALUES (?, ?, ?, '', '', '', '')",
+                  (username, hashed, role))
+        conn.commit()
+        conn.close()
+        return True
+    except sqlite3.IntegrityError:
+        conn.close()
+        return False
+
+def delete_user(username):
+    """Elimina un usuario. No permite eliminar al admin principal."""
+    if username == 'admin':
+        return False
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("DELETE FROM users WHERE username=?", (username,))
+    conn.commit()
+    conn.close()
+    return True
+
+def update_user_role(username, new_role):
+    """Cambia el rol de un usuario."""
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("UPDATE users SET role=? WHERE username=?", (new_role, username))
+    conn.commit()
+    conn.close()
+
+def reset_user_password(username, new_password_plain):
+    """Resetea la contraseña de un usuario."""
+    conn = get_connection()
+    c = conn.cursor()
+    salt = bcrypt.gensalt()
+    hashed = bcrypt.hashpw(new_password_plain.encode(), salt).decode('utf-8')
+    c.execute("UPDATE users SET password=? WHERE username=?", (hashed, username))
+    conn.commit()
+    conn.close()
+
+# =============================================
+# FUNCIONES EXISTENTES (sin cambios)
+# =============================================
+
+def get_user(username, password_plain):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("SELECT * FROM users WHERE LOWER(username)=LOWER(?)", (username,))
+    user = c.fetchone()
+    conn.close()
+    if user:
+        stored_hash = user[1]
+        try:
+            if bcrypt.checkpw(password_plain.encode(), stored_hash.encode('utf-8')):
+                return user
+        except ValueError:
+            # En caso de hashes antiguos SHA-256 sin sal
+            pass
+    return None
+
+def update_user_profile(username, gemini, tavily, email, enc_pass):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("UPDATE users SET gemini_key=?, tavily_key=?, email_user=?, email_pass_enc=? WHERE username=?",
+              (gemini, tavily, email, enc_pass, username))
+    conn.commit()
+    conn.close()
+
+def save_history(username, licitacion, items_count):
+    conn = get_connection()
+    c = conn.cursor()
+    fecha_actual = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    c.execute("INSERT INTO history (username, licitacion, fecha, items) VALUES (?, ?, ?, ?)",
+              (username, licitacion, fecha_actual, items_count))
+    conn.commit()
+    conn.close()
+
+def get_user_history_df(username):
+    conn = get_connection()
+    df = pd.read_sql_query(
+        "SELECT licitacion as 'Nº Licitación', fecha as 'Fecha Proceso', items as 'Renglones' FROM history WHERE username=? ORDER BY id DESC",
+        conn, params=(username,))
+    conn.close()
+    return df
+
+def delete_history_entry(username, licitacion):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("DELETE FROM history WHERE username=? AND licitacion=?", (username, licitacion))
+    conn.commit()
+    conn.close()
+
+def clear_all_history(username):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("DELETE FROM history WHERE username=?", (username,))
+    conn.commit()
+    conn.close()
+
+def get_correos_licitacion_df(licitacion):
+    conn = get_connection()
+    try:
+        df = pd.read_sql_query(
+            "SELECT id, remitente, asunto, fecha, resumen, renglones_relacionados, cuerpo, borrador_respuesta FROM smart_inbox WHERE licitacion=? ORDER BY id DESC",
+            conn, params=(licitacion,))
+    except Exception:
+        df = pd.DataFrame()
+    conn.close()
+    return df
+
+def get_user_credentials(username):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("SELECT email_user, email_pass_enc, gemini_key FROM users WHERE username=?", (username,))
+    row = c.fetchone()
+    conn.close()
+    return row
+
+def check_email_exists(licitacion, asunto, remitente):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("SELECT id FROM smart_inbox WHERE licitacion=? AND asunto=? AND remitente=?",
+              (licitacion, asunto, remitente))
+    exists = c.fetchone() is not None
+    conn.close()
+    return exists
+
+def insert_smart_inbox(licitacion, remitente, asunto, fecha, resumen, renglones, cuerpo, borrador=""):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute(
+        "INSERT INTO smart_inbox (licitacion, remitente, asunto, fecha, resumen, renglones_relacionados, cuerpo, borrador_respuesta) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+        (licitacion, remitente, asunto, fecha, resumen, renglones, cuerpo, borrador))
+    conn.commit()
+    conn.close()
+
+def insert_cotizacion(licitacion, renglon, proveedor, precio_unitario, moneda, tiempo_entrega, condiciones, fecha, email_asunto):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute(
+        "INSERT INTO cotizaciones (licitacion, renglon, proveedor, precio_unitario, moneda, tiempo_entrega, condiciones, fecha, email_asunto) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (licitacion, renglon, proveedor, precio_unitario, moneda, tiempo_entrega, condiciones, fecha, email_asunto))
+    conn.commit()
+    conn.close()
+
+def check_cotizacion_exists(licitacion, renglon, proveedor):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("SELECT id FROM cotizaciones WHERE licitacion=? AND renglon=? AND proveedor=?",
+              (licitacion, renglon, proveedor))
+    exists = c.fetchone() is not None
+    conn.close()
+    return exists
+
+def get_ficha_cache(username, licitacion, codigo_renglon):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("SELECT datasheet_md FROM fichas_cache WHERE username=? AND licitacion=? AND codigo_renglon=?",
+              (username, licitacion, codigo_renglon))
+    row = c.fetchone()
+    conn.close()
+    return row[0] if row else None
+
+def save_ficha_cache(username, licitacion, codigo_renglon, datasheet_md):
+    conn = get_connection()
+    c = conn.cursor()
+    fecha = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    c.execute(
+        "INSERT OR REPLACE INTO fichas_cache (username, licitacion, codigo_renglon, datasheet_md, fecha) VALUES (?, ?, ?, ?, ?)",
+        (username, licitacion, codigo_renglon, datasheet_md, fecha))
+    conn.commit()
+    conn.close()
+
+# =============================================
+# MONITOR DE LICITACIONES ACP
+# =============================================
+
+ESTADOS_ACP = [
+    "En Preparacion",
+    "Oferta Enviada al SLI",
+    "Cumple Tecnicamente",
+    "No Cumple Tecnicamente",
+    "En Evaluacion Economica",
+    "Adjudicada",
+    "No Adjudicada",
+    "Desierta",
+]
+
+def crear_seguimiento(numero_licitacion, objeto, fecha_asignacion, fecha_envio_oferta,
+                      monto_ofertado, moneda, link_sli, notas, responsable):
+    conn = get_connection()
+    c = conn.cursor()
+    fecha = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    try:
+        c.execute("""INSERT INTO seguimiento_licitaciones
+            (numero_licitacion, objeto, fecha_asignacion, fecha_envio_oferta,
+             monto_ofertado, moneda, estado, link_sli, notas, responsable, fecha_registro)
+            VALUES (?, ?, ?, ?, ?, ?, 'En Preparacion', ?, ?, ?, ?)""",
+            (numero_licitacion, objeto, fecha_asignacion, fecha_envio_oferta,
+             monto_ofertado, moneda, link_sli, notas, responsable, fecha))
+        conn.commit()
+        conn.close()
+        return True
+    except Exception:
+        conn.close()
+        return False
+
+def get_seguimientos():
+    conn = get_connection()
+    df = pd.read_sql_query(
+        "SELECT * FROM seguimiento_licitaciones ORDER BY fecha_registro DESC", conn)
+    conn.close()
+    return df
+
+def actualizar_estado(licitacion_id, nuevo_estado, nota, registrado_por):
+    conn = get_connection()
+    c = conn.cursor()
+    fecha = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    c.execute("UPDATE seguimiento_licitaciones SET estado=? WHERE id=?", (nuevo_estado, licitacion_id))
+    c.execute("""INSERT INTO seguimiento_historial (licitacion_id, fecha, estado_nuevo, nota, registrado_por)
+                 VALUES (?, ?, ?, ?, ?)""", (licitacion_id, fecha, nuevo_estado, nota, registrado_por))
+    conn.commit()
+    conn.close()
+
+def get_historial_seguimiento(licitacion_id):
+    conn = get_connection()
+    df = pd.read_sql_query(
+        "SELECT fecha, estado_nuevo, nota, registrado_por FROM seguimiento_historial WHERE licitacion_id=? ORDER BY id DESC",
+        conn, params=(licitacion_id,))
+    conn.close()
+    return df
+
+def eliminar_seguimiento(licitacion_id):
+    conn = get_connection()
+    c = conn.cursor()
+    c.execute("DELETE FROM seguimiento_historial WHERE licitacion_id=?", (licitacion_id,))
+    c.execute("DELETE FROM seguimiento_licitaciones WHERE id=?", (licitacion_id,))
+    conn.commit()
+    conn.close()
+

entrypoint.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# Iniciar la API en segundo plano
+echo "Iniciando Motor IA (FastAPI)..."
+uvicorn api:app --host 0.0.0.0 --port 8000 &
+
+# Esperar unos segundos para que la API levante bien
+sleep 3
+
+# Iniciar Streamlit en el puerto principal
+echo "Iniciando Centro de Mando (Streamlit)..."
+streamlit run app.py --server.port 7860 --server.address 0.0.0.0

requirements.txt

@@ -0,0 +1,16 @@
+streamlit
+pandas
+plotly
+tavily-python
+google-generativeai
+cryptography
+requests
+fastapi
+uvicorn
+python-multipart
+python-dotenv
+openpyxl
+playwright
+beautifulsoup4
+pypdf
+bcrypt

style.css

@@ -0,0 +1,372 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap');
+
+/* ===== BASE ===== */
+html, body, [data-testid="stAppViewContainer"] {
+    background-color: #0A0E1A;
+    color: #E0E6F0;
+    font-family: 'Inter', sans-serif;
+}
+[data-testid="stSidebar"] {
+    background: linear-gradient(180deg, #0D1117 0%, #0A0E1A 100%);
+    border-right: 1px solid #1E2A3A;
+}
+[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; }
+
+/* ===== MÉTRICAS ===== */
+div[data-testid="metric-container"] {
+    background: linear-gradient(135deg, #161B22 0%, #0D1117 100%);
+    border: 1px solid #1E2A3A;
+    padding: 18px;
+    border-radius: 14px;
+    transition: transform 0.25s ease, border-color 0.25s ease, box-shadow 0.25s ease;
+}
+div[data-testid="metric-container"]:hover {
+    transform: translateY(-4px);
+    border-color: #58A6FF;
+    box-shadow: 0 8px 25px rgba(88, 166, 255, 0.15);
+}
+
+/* ===== CARDS ===== */
+.detail-card {
+    background: linear-gradient(135deg, #161B22 0%, #0D1117 100%);
+    padding: 25px;
+    border-radius: 16px;
+    border-top: 3px solid #58A6FF;
+    border-left: 1px solid #1E2A3A;
+    border-right: 1px solid #1E2A3A;
+    border-bottom: 1px solid #1E2A3A;
+    margin-top: 20px;
+    animation: fadeInUp 0.3s ease;
+}
+.provider-card {
+    border: 1px solid #1E2A3A;
+    border-radius: 14px;
+    padding: 20px;
+    background: linear-gradient(135deg, #0D1117 0%, #0A0E1A 100%);
+    border-left: 3px solid #58A6FF;
+    height: 100%;
+    transition: all 0.25s ease;
+    margin-top: 15px;
+}
+.provider-card:hover {
+    border-left-color: #10B981;
+    transform: translateY(-4px);
+    box-shadow: 0 10px 30px rgba(16, 185, 129, 0.15);
+}
+.email-card {
+    background: linear-gradient(135deg, #161B22 0%, #0D1117 100%);
+    border-left: 3px solid #10B981;
+    padding: 18px;
+    border-radius: 12px;
+    margin-bottom: 12px;
+    border-top: 1px solid #1E2A3A;
+    border-right: 1px solid #1E2A3A;
+    border-bottom: 1px solid #1E2A3A;
+    transition: all 0.2s ease;
+    animation: fadeInUp 0.3s ease;
+}
+.email-card:hover {
+    border-left-color: #58A6FF;
+    box-shadow: 0 4px 20px rgba(88, 166, 255, 0.1);
+}
+.step-card {
+    background: linear-gradient(135deg, #161B22 0%, #0D1117 100%);
+    border: 1px solid #1E2A3A;
+    padding: 30px 20px;
+    border-radius: 18px;
+    text-align: center;
+    height: 100%;
+    transition: all 0.3s ease;
+    animation: fadeInUp 0.4s ease;
+}
+.step-card:hover {
+    border-color: #58A6FF;
+    transform: translateY(-5px);
+    box-shadow: 0 15px 40px rgba(88, 166, 255, 0.12);
+}
+.step-icon { font-size: 44px; margin-bottom: 15px; display: block; }
+
+/* ===== BADGES ===== */
+.tag-badge {
+    background: linear-gradient(90deg, #1a3a1a, #238636);
+    color: #3fb950;
+    border: 1px solid #238636;
+    padding: 3px 10px;
+    border-radius: 20px;
+    font-size: 11px;
+    font-weight: 600;
+    letter-spacing: 0.5px;
+    margin-right: 4px;
+}
+
+/* ===== BOTONES LEGACY ===== */
+.action-btn {
+    display: inline-block;
+    margin-top: 10px; margin-right: 10px;
+    background: linear-gradient(90deg, #238636, #2ea043);
+    color: white !important;
+    padding: 10px 18px;
+    border-radius: 8px;
+    text-decoration: none;
+    font-weight: 700;
+    font-size: 13px;
+    transition: all 0.25s ease;
+    box-shadow: 0 2px 8px rgba(35, 134, 54, 0.3);
+}
+.action-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 8px 20px rgba(35, 134, 54, 0.4);
+}
+
+/* ===== ANIMACIONES ===== */
+@keyframes fadeInUp {
+    from { opacity: 0; transform: translateY(12px); }
+    to   { opacity: 1; transform: translateY(0); }
+}
+@keyframes pulse-blue {
+    0%, 100% { box-shadow: 0 0 0 0 rgba(88, 166, 255, 0.3); }
+    50%       { box-shadow: 0 0 0 8px rgba(88, 166, 255, 0); }
+}
+
+/* ===== SCROLLBAR ===== */
+::-webkit-scrollbar { width: 6px; height: 6px; }
+::-webkit-scrollbar-track { background: #0A0E1A; }
+::-webkit-scrollbar-thumb { background: #1E2A3A; border-radius: 4px; }
+::-webkit-scrollbar-thumb:hover { background: #58A6FF; }
+
+/* ===== DATAFRAME ===== */
+[data-testid="stDataFrame"] { border-radius: 12px; overflow: hidden; }
+
+/* ===== OPERATIONS UI REFRESH ===== */
+:root {
+    --bg-main: #080C12;
+    --surface-1: #0F141C;
+    --surface-2: #151B24;
+    --line-soft: #242C38;
+    --text-main: #E8EDF5;
+    --text-muted: #8C98A8;
+    --blue: #4F9CF9;
+    --green: #31C48D;
+    --amber: #F6B44B;
+    --orange: #F08A3C;
+    --red: #EF5B5B;
+    --gray: #748091;
+}
+
+div[data-testid="metric-container"] {
+    background: var(--surface-1);
+    border: 1px solid var(--line-soft);
+    border-radius: 8px;
+    box-shadow: none;
+}
+
+div[data-testid="metric-container"]:hover {
+    transform: none;
+    border-color: #344255;
+    box-shadow: none;
+}
+
+.section-title {
+    margin: 2px 0 12px 0;
+    color: var(--text-main);
+    font-size: 18px;
+    font-weight: 750;
+}
+
+.section-subtitle {
+    margin: -8px 0 16px 0;
+    color: var(--text-muted);
+    font-size: 13px;
+}
+
+.monitor-list {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+.monitor-row {
+    background: var(--surface-1);
+    border: 1px solid var(--line-soft);
+    border-left: 4px solid var(--status-color, var(--blue));
+    border-radius: 8px;
+    padding: 12px 14px;
+}
+
+.monitor-row-head {
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 14px;
+}
+
+.monitor-id {
+    color: var(--text-main);
+    font-size: 16px;
+    font-weight: 800;
+    line-height: 1.2;
+}
+
+.monitor-owner {
+    color: var(--text-muted);
+    font-size: 11px;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    margin-bottom: 3px;
+}
+
+.monitor-object {
+    color: #B8C2D0;
+    font-size: 12px;
+    line-height: 1.35;
+    margin-top: 5px;
+}
+
+.monitor-meta {
+    display: flex;
+    justify-content: flex-end;
+    flex-wrap: wrap;
+    gap: 6px;
+    margin-top: 8px;
+}
+
+.status-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    background: color-mix(in srgb, var(--status-color, var(--blue)) 14%, transparent);
+    color: var(--status-color, var(--blue));
+    border: 1px solid color-mix(in srgb, var(--status-color, var(--blue)) 42%, transparent);
+    border-radius: 999px;
+    padding: 3px 9px;
+    font-size: 11px;
+    font-weight: 700;
+    white-space: nowrap;
+}
+
+.status-dot {
+    width: 7px;
+    height: 7px;
+    border-radius: 50%;
+    background: var(--status-color, var(--blue));
+}
+
+.mini-pill {
+    background: #0B1017;
+    border: 1px solid var(--line-soft);
+    border-radius: 999px;
+    color: var(--text-muted);
+    padding: 3px 9px;
+    font-size: 11px;
+    white-space: nowrap;
+}
+
+.sli-summary {
+    margin: 8px 0 10px 0;
+    background: #0B1017;
+    border: 1px solid var(--line-soft);
+    border-left: 3px solid var(--amber);
+    border-radius: 8px;
+    padding: 10px 12px;
+}
+
+.sli-summary-title {
+    color: var(--amber);
+    font-size: 11px;
+    font-weight: 800;
+    letter-spacing: 0.04em;
+    text-transform: uppercase;
+    margin-bottom: 4px;
+}
+
+.sli-summary-body {
+    color: #D9E2EF;
+    font-size: 12px;
+    line-height: 1.35;
+}
+
+.work-panel {
+    background: var(--surface-1);
+    border: 1px solid var(--line-soft);
+    border-radius: 8px;
+    padding: 14px;
+}
+
+.info-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+    gap: 8px;
+    margin-bottom: 14px;
+}
+
+.info-tile {
+    background: var(--surface-1);
+    border: 1px solid var(--line-soft);
+    border-radius: 8px;
+    padding: 12px;
+}
+
+.info-label {
+    color: var(--text-muted);
+    font-size: 10px;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: 5px;
+}
+
+.info-value {
+    color: var(--text-main);
+    font-size: 13px;
+    font-weight: 650;
+    line-height: 1.3;
+}
+
+.detail-card {
+    background: var(--surface-1);
+    border: 1px solid var(--line-soft);
+    border-left: 4px solid var(--blue);
+    border-radius: 8px;
+    padding: 18px;
+    box-shadow: none;
+}
+
+.provider-card, .email-card, .step-card {
+    border-radius: 8px;
+    background: var(--surface-1);
+    border-color: var(--line-soft);
+    box-shadow: none;
+}
+
+.stButton > button,
+.stDownloadButton > button,
+[data-testid="stBaseButton-secondary"],
+[data-testid="stBaseButton-primary"] {
+    border-radius: 7px !important;
+    min-height: 36px;
+    font-weight: 650;
+}
+
+.stButton > button[kind="primary"],
+[data-testid="stBaseButton-primary"] {
+    background: #2F7FD8 !important;
+    border-color: #2F7FD8 !important;
+}