Upload 4 files

app.py

@@ -582,6 +582,33 @@ def get_usage_summary_cached(days, username, module):
 def get_api_pricing_cached():
     return db.get_api_pricing_df()
 
+@st.cache_data(ttl=60, show_spinner=False)
+def get_logistics_freight_rates_cached():
+    return db.get_logistics_freight_rates()
+
+@st.cache_data(ttl=60, show_spinner=False)
+def get_logistics_local_rates_cached():
+    return db.get_logistics_local_rates()
+
+@st.cache_data(ttl=60, show_spinner=False)
+def get_logistics_forwarders_cached():
+    return db.get_logistics_forwarders()
+
+@st.cache_data(ttl=300, show_spinner=False)
+def get_logistics_incoterms_cached():
+    return db.get_logistics_incoterms()
+
+@st.cache_data(ttl=30, show_spinner=False)
+def get_logistics_calculations_cached(limit=100):
+    return db.get_logistics_calculations(limit=limit)
+
+def clear_logistics_cache():
+    get_logistics_freight_rates_cached.clear()
+    get_logistics_local_rates_cached.clear()
+    get_logistics_forwarders_cached.clear()
+    get_logistics_incoterms_cached.clear()
+    get_logistics_calculations_cached.clear()
+
 @st.cache_data(ttl=20, show_spinner=False)
 def get_seguimientos_cached():
     return db.get_seguimientos()
@@ -1166,7 +1193,9 @@ def current_role_mode():
     username = str(st.session_state.get("username", "") or "").lower()
     if username == "admin" or role == "Admin":
         return "Admin"
-    if role in ["Supervisor", "Gerencia"]:
+    if role in ["Supervisor", "Gerencia", "Logística", "Logistica"]:
+        if role == "Logistica":
+            return "Logística"
         return role
     return "Analista"
 
@@ -1186,6 +1215,11 @@ ROLE_PROFILES = {
         "scope": "Visión operativa, Radar, histórico corporativo y configuración propia.",
         "badge": "Gerencia",
     },
+    "Logística": {
+        "title": "Centro Logístico",
+        "scope": "Tarifas, forwarders, incoterms, cálculos logísticos e histórico corporativo.",
+        "badge": "Logística",
+    },
     "Admin": {
         "title": "Administración Global",
         "scope": "Usuarios, roles, métricas, llaves y salud del sistema.",
@@ -1194,9 +1228,10 @@ ROLE_PROFILES = {
 }
 
 ROLE_PERMISSIONS = {
-    "Analista": {"dashboard", "rfq_upload", "providers", "monitor", "workspaces", "historico"},
-    "Supervisor": {"dashboard", "rfq_upload", "providers", "monitor", "workspaces", "historico", "radar"},
-    "Gerencia": {"dashboard", "rfq_upload", "providers", "monitor", "workspaces", "radar", "historico", "settings"},
+    "Analista": {"dashboard", "rfq_upload", "providers", "monitor", "workspaces", "historico", "logistics_calc"},
+    "Supervisor": {"dashboard", "rfq_upload", "providers", "monitor", "workspaces", "historico", "radar", "logistics_calc"},
+    "Gerencia": {"dashboard", "rfq_upload", "providers", "monitor", "workspaces", "radar", "historico", "settings", "logistics", "logistics_calc"},
+    "Logística": {"logistics", "historico"},
     "Admin": {"admin"},
 }
 
@@ -1210,11 +1245,12 @@ def get_role_profile():
 if current_role_mode() == "Admin":
     st.markdown("""<style>[data-testid="stSidebar"] { display: none !important; }</style>""", unsafe_allow_html=True)
     df_users_admin = get_all_users_cached()
-    role_admin_series = df_users_admin["role"] if "role" in df_users_admin.columns else pd.Series(dtype=str)
+    role_admin_series = df_users_admin["Nivel"] if "Nivel" in df_users_admin.columns else pd.Series(dtype=str)
     total_admin_users = len(df_users_admin)
     total_admin_supervisors = int((role_admin_series == "Supervisor").sum()) if not role_admin_series.empty else 0
     total_admin_analysts = int((role_admin_series == "Analista").sum()) if not role_admin_series.empty else 0
     total_admin_gerencia = int((role_admin_series == "Gerencia").sum()) if not role_admin_series.empty else 0
+    total_admin_logistica = int(role_admin_series.isin(["Logística", "Logistica"]).sum()) if not role_admin_series.empty else 0
 
     st.markdown("""
     <div class="admin-hero">
@@ -1227,11 +1263,12 @@ if current_role_mode() == "Admin":
     </div>
     """, unsafe_allow_html=True)
 
-    a1, a2, a3, a4 = st.columns(4)
+    a1, a2, a3, a4, a5 = st.columns(5)
     a1.metric("Usuarios", total_admin_users)
     a2.metric("Analistas", total_admin_analysts)
     a3.metric("Supervisores", total_admin_supervisors)
     a4.metric("Gerencia", total_admin_gerencia)
+    a5.metric("Logística", total_admin_logistica)
     
     admin_view = st.radio(
         "Vista admin",
@@ -1277,15 +1314,15 @@ if current_role_mode() == "Admin":
             st.markdown("---")
             st.subheader("Cambiar Rol de Usuario")
             role_col1, role_col2, role_col3 = st.columns([0.45, 0.35, 0.2])
-            role_users = df_users["username"].tolist() if "username" in df_users.columns else []
+            role_users = df_users["Usuario"].tolist() if "Usuario" in df_users.columns else []
             with role_col1:
                 role_user = st.selectbox("Usuario", role_users, key="admin_role_user")
             current_role = ""
             if role_user and not df_users.empty:
-                role_match = df_users[df_users["username"] == role_user]
+                role_match = df_users[df_users["Usuario"] == role_user]
                 if not role_match.empty:
-                    current_role = str(role_match.iloc[0].get("role", "Analista") or "Analista")
-            role_options = ["Analista", "Supervisor", "Gerencia"]
+                    current_role = str(role_match.iloc[0].get("Nivel", "Analista") or "Analista")
+            role_options = ["Analista", "Supervisor", "Gerencia", "Logística"]
             with role_col2:
                 role_index = role_options.index(current_role) if current_role in role_options else 0
                 new_role_admin = st.selectbox("Nuevo rol", role_options, index=role_index, key="admin_new_role")
@@ -1307,7 +1344,7 @@ if current_role_mode() == "Admin":
             """, 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", "Supervisor", "Gerencia"])
+            new_r = st.selectbox("Nivel de Acceso", ["Analista", "Supervisor", "Gerencia", "Logística"])
             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):
@@ -1429,6 +1466,15 @@ def get_navigation_items():
             "hint": "Busqueda global de proveedores, precios y evidencia",
             "permission": "providers",
         },
+        {
+            "group": "Operaciones",
+            "view": "🚚 Centro Logístico",
+            "key": "logistica",
+            "label": "Logística",
+            "icon": "▣",
+            "hint": "Tarifas, forwarders, incoterms y calculadora logística",
+            "permission": "logistics",
+        },
         {
             "group": "Seguimiento",
             "view": "🏛️ Monitor ACP",
@@ -1542,69 +1588,77 @@ with st.sidebar:
             st.rerun()
 
     st.divider()
-    
-    st.markdown('<div class="sidebar-section-label">Nuevo RFQ</div>', unsafe_allow_html=True)
-    st.markdown("""
-    <div class="sidebar-analysis-card">
-        <div class="analysis-card-title">Analizar pliego</div>
-        <div class="analysis-card-copy">PDF principal y anexos.</div>
-        <div class="sidebar-flow">
-            <span>1 RFQ</span>
-            <span>2 Renglones</span>
-            <span>3 Proveedores</span>
-            <span>4 Seguimiento</span>
+
+    if role_can("rfq_upload"):
+        st.markdown('<div class="sidebar-section-label">Nuevo RFQ</div>', unsafe_allow_html=True)
+        st.markdown("""
+        <div class="sidebar-analysis-card">
+            <div class="analysis-card-title">Analizar pliego</div>
+            <div class="analysis-card-copy">PDF principal y anexos.</div>
+            <div class="sidebar-flow">
+                <span>1 RFQ</span>
+                <span>2 Renglones</span>
+                <span>3 Proveedores</span>
+                <span>4 Seguimiento</span>
+            </div>
         </div>
-    </div>
-    """, unsafe_allow_html=True)
-    archivos_pdf = st.file_uploader("Archivos PDF", type=["pdf"], label_visibility="collapsed", accept_multiple_files=True)
-    if archivos_pdf:
-        st.caption(f"{len(archivos_pdf)} archivo(s) listo(s) para analizar")
-    
-    if st.button("Procesar RFQ", 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,
-                        "username": st.session_state.username,
-                        "role": st.session_state.role
-                    }
-                    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 = normalize_item_codes(normalize_technical_fields(pd.DataFrame(datos_crudos.get("items", []))))
-
-                        try:
-                            df_historico_match = load_historical_prices()
-                            if df_historico_match is None:
-                                st.warning("⚠️ El histórico de Supabase aún no tiene datos. Procesando sin precios base.")
-                            else:
-                                # El código ACP válido usa formato AAA-AAA-00000; se normaliza antes del cruce histórico.
-                                df_exportar['codigo_match'] = df_exportar['codigo_articulo'].apply(acp_code_match)
-                                
-                                df_cruzado = pd.merge(df_exportar, df_historico_match, 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 = normalize_history_columns(df_cruzado)
-                        except Exception as hist_e: 
-                            st.warning(f"⚠️ Error consultando histórico en Supabase: {hist_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.toast("Analisis completado. Resultados listos.")
-                    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")
+        """, unsafe_allow_html=True)
+        archivos_pdf = st.file_uploader("Archivos PDF", type=["pdf"], label_visibility="collapsed", accept_multiple_files=True)
+        if archivos_pdf:
+            st.caption(f"{len(archivos_pdf)} archivo(s) listo(s) para analizar")
+
+        if st.button("Procesar RFQ", 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,
+                            "username": st.session_state.username,
+                            "role": st.session_state.role
+                        }
+                        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 = normalize_item_codes(normalize_technical_fields(pd.DataFrame(datos_crudos.get("items", []))))
+
+                            try:
+                                df_historico_match = load_historical_prices()
+                                if df_historico_match is None:
+                                    st.warning("⚠️ El histórico de Supabase aún no tiene datos. Procesando sin precios base.")
+                                else:
+                                    # El código ACP válido usa formato AAA-AAA-00000; se normaliza antes del cruce histórico.
+                                    df_exportar['codigo_match'] = df_exportar['codigo_articulo'].apply(acp_code_match)
+
+                                    df_cruzado = pd.merge(df_exportar, df_historico_match, 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 = normalize_history_columns(df_cruzado)
+                            except Exception as hist_e:
+                                st.warning(f"⚠️ Error consultando histórico en Supabase: {hist_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.toast("Analisis completado. Resultados listos.")
+                        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")
+    else:
+        st.markdown("""
+        <div class="sidebar-analysis-card">
+            <div class="analysis-card-title">Centro Logístico</div>
+            <div class="analysis-card-copy">Tarifas, forwarders e histórico corporativo.</div>
+        </div>
+        """, unsafe_allow_html=True)
     
     st.divider()
     
@@ -2227,6 +2281,389 @@ def build_radar_table_view(radar_df):
     view["Estado"] = radar_df["estado_radar"].fillna("").astype(str) if "estado_radar" in radar_df.columns else ""
     return view
 
+def logistics_local_cost(local_row, peso_kg):
+    if local_row is None or local_row.empty:
+        return 0.0
+    if peso_kg <= 400:
+        return float(local_row.get("hasta_400kg", 0) or 0)
+    if peso_kg <= 1000:
+        return float(local_row.get("kg_500_1000", 0) or 0)
+    return float(local_row.get("mayor_1000kg", 0) or 0)
+
+LOGISTICS_ROUTE_ORIGIN = "USA / Miami"
+LOGISTICS_ROUTE_DESTINATION = "Panamá / ACP"
+LOGISTICS_ROUTE_LABEL = f"{LOGISTICS_ROUTE_ORIGIN} → {LOGISTICS_ROUTE_DESTINATION}"
+LOGISTICS_ROUTE_SCOPE = (
+    "Las tarifas actuales están calibradas para envíos desde USA/Miami hacia Panamá/ACP. "
+    "Para otros orígenes como China, Europa o México se debe cargar una ruta logística distinta."
+)
+
+def logistics_calc_summary(freight_row, local_row, peso_libras, incoterm="FOB",
+                           largo=0, ancho=0, alto=0, unidad_dimensional="in", bultos=1):
+    peso_libras = float(peso_libras or 0)
+    largo = float(largo or 0)
+    ancho = float(ancho or 0)
+    alto = float(alto or 0)
+    bultos = max(float(bultos or 1), 1.0)
+    unidad_dimensional = (unidad_dimensional or "in").lower()
+    peso_volumetrico_libras = 0.0
+    volumen_pies_cubicos = 0.0
+    if largo > 0 and ancho > 0 and alto > 0:
+        if unidad_dimensional == "cm":
+            volumen_pies_cubicos = ((largo / 2.54) * (ancho / 2.54) * (alto / 2.54) * bultos) / 1728
+            peso_volumetrico_libras = ((largo * ancho * alto * bultos) / 6000) * 2.20462
+        else:
+            volumen_pies_cubicos = (largo * ancho * alto * bultos) / 1728
+            peso_volumetrico_libras = (largo * ancho * alto * bultos) / 166
+    peso_facturable_libras = max(peso_libras, peso_volumetrico_libras)
+    peso_kg = peso_libras * 0.453592
+    peso_facturable_kg = peso_facturable_libras * 0.453592
+    tarifa = float(freight_row.get("tarifa_por_libra", 0) or 0)
+    minimo = float(freight_row.get("minimo_envio", 0) or 0)
+    costo_internacional = max(peso_facturable_libras * tarifa, minimo)
+    costo_local = logistics_local_cost(local_row, peso_facturable_kg)
+    total = costo_internacional + costo_local
+    dias = int(freight_row.get("tiempo_transito_dias", 0) or 0)
+    return {
+        "peso_libras": peso_libras,
+        "peso_kg": peso_kg,
+        "peso_facturable_libras": peso_facturable_libras,
+        "peso_facturable_kg": peso_facturable_kg,
+        "peso_volumetrico_libras": peso_volumetrico_libras,
+        "largo": largo,
+        "ancho": ancho,
+        "alto": alto,
+        "unidad_dimensional": unidad_dimensional,
+        "bultos": bultos,
+        "volumen_pies_cubicos": volumen_pies_cubicos,
+        "costo_internacional": costo_internacional,
+        "costo_local": costo_local,
+        "costo_total": total,
+        "tiempo_transito_dias": dias,
+        "incoterm": incoterm,
+    }
+
+if active_view == "🚚 Centro Logístico":
+    render_page_header(
+        "Operación logística",
+        "Centro Logístico",
+        "Tarifas, forwarders, incoterms y cálculos para estimar costos antes de cotizar.",
+        ["Supabase", "Tarifas ACP", "Beta logística"]
+    )
+
+    freight_df = get_logistics_freight_rates_cached()
+    local_df = get_logistics_local_rates_cached()
+    forwarders_df = get_logistics_forwarders_cached()
+    incoterms_df = get_logistics_incoterms_cached()
+
+    render_summary_strip([
+        {"label": "Tarifas flete", "value": len(freight_df), "tone": "green" if len(freight_df) else "orange"},
+        {"label": "Destinos locales", "value": len(local_df), "tone": "green" if len(local_df) else "orange"},
+        {"label": "Forwarders", "value": len(forwarders_df), "tone": "blue"},
+        {"label": "Incoterms", "value": len(incoterms_df), "tone": "amber"},
+    ])
+
+    st.markdown("""
+    <div class="work-panel">
+        <div class="panel-label">Uso operativo</div>
+        <div class="panel-copy">
+            Logística mantiene las tarifas y rutas. Analistas y supervisores usarán estos datos para estimar costo logístico,
+            lead time y margen real de participación.
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    st.markdown(f"""
+    <div class="work-panel">
+        <div class="panel-label">Ruta activa</div>
+        <div class="panel-copy">
+            <strong>{escape(LOGISTICS_ROUTE_LABEL)}</strong><br>
+            {escape(LOGISTICS_ROUTE_SCOPE)}
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    tab_calc, tab_rates, tab_local, tab_forwarders, tab_incoterms, tab_history = st.tabs([
+        "Calculadora", "Flete internacional", "Entrega local", "Forwarders", "Incoterms", "Cálculos guardados"
+    ])
+
+    with tab_calc:
+        if freight_df.empty:
+            render_empty_state("Sin tarifas", "Aún no hay tarifas internacionales cargadas para calcular.")
+        else:
+            calc_left, calc_right = st.columns([0.58, 0.42])
+            with calc_left:
+                st.markdown("#### Parámetros del cálculo")
+                route_a, route_b = st.columns(2)
+                with route_a:
+                    st.text_input("Origen tarifario", value=LOGISTICS_ROUTE_ORIGIN, disabled=True, key="log_calc_origin")
+                with route_b:
+                    st.text_input("Destino tarifario", value=LOGISTICS_ROUTE_DESTINATION, disabled=True, key="log_calc_route_dest")
+                modo_peso_log = st.radio(
+                    "Forma de cálculo",
+                    ["Envío completo", "Por paquete"],
+                    horizontal=True,
+                    key="log_calc_modo_peso",
+                )
+                c1, c2 = st.columns(2)
+                with c1:
+                    tipo_flete_calc = st.selectbox("Tipo de flete", sorted(freight_df["tipo_flete"].dropna().unique().tolist()), key="log_calc_tipo")
+                filtered_freight = freight_df[freight_df["tipo_flete"] == tipo_flete_calc].copy()
+                with c2:
+                    agente_calc = st.selectbox("Agente internacional", filtered_freight["agente"].dropna().unique().tolist(), key="log_calc_agente")
+                freight_row = filtered_freight[filtered_freight["agente"] == agente_calc].iloc[0]
+
+                if modo_peso_log == "Por paquete":
+                    c3, c4, c5, c6 = st.columns([0.24, 0.24, 0.24, 0.28])
+                    with c3:
+                        peso_paquete_log = st.number_input("Peso por paquete (lb)", min_value=0.0, value=10.0, step=1.0, key="log_calc_pkg_lb")
+                    with c4:
+                        bultos_log = st.number_input("Paquetes", min_value=1, value=1, step=1, key="log_calc_pkg_count")
+                    with c5:
+                        incoterm_calc = st.selectbox("Incoterm base", incoterms_df["sigla"].tolist() if not incoterms_df.empty else ["FOB"], key="log_calc_incoterm")
+                    with c6:
+                        lic_log = st.text_input("Licitación", value=str(st.session_state.get("cg", {}).get("numero_licitacion", "")), key="log_calc_lic")
+                    peso_libras = peso_paquete_log * bultos_log
+                else:
+                    c3, c4, c5, c6 = st.columns([0.24, 0.24, 0.24, 0.28])
+                    with c3:
+                        peso_libras = st.number_input("Peso total (lb)", min_value=0.0, value=10.0, step=1.0, key="log_calc_lb")
+                    with c4:
+                        bultos_log = st.number_input("Paquetes / bultos", min_value=1, value=1, step=1, key="log_calc_bultos")
+                    with c5:
+                        incoterm_calc = st.selectbox("Incoterm base", incoterms_df["sigla"].tolist() if not incoterms_df.empty else ["FOB"], key="log_calc_incoterm")
+                    with c6:
+                        lic_log = st.text_input("Licitación", value=str(st.session_state.get("cg", {}).get("numero_licitacion", "")), key="log_calc_lic")
+                    peso_paquete_log = peso_libras / bultos_log if bultos_log else peso_libras
+
+                st.caption("Dimensiones por paquete/bulto para calcular peso volumétrico. Si no aplican, déjalas en cero.")
+                d1, d2, d3, d4, d5 = st.columns([0.2, 0.2, 0.2, 0.18, 0.22])
+                with d1:
+                    largo_log = st.number_input("Largo", min_value=0.0, value=0.0, step=1.0, key="log_calc_largo")
+                with d2:
+                    ancho_log = st.number_input("Ancho", min_value=0.0, value=0.0, step=1.0, key="log_calc_ancho")
+                with d3:
+                    alto_log = st.number_input("Alto", min_value=0.0, value=0.0, step=1.0, key="log_calc_alto")
+                with d4:
+                    unidad_log = st.selectbox("Unidad", ["in", "cm"], key="log_calc_unidad_dim")
+                with d5:
+                    st.metric("Peso total", f"{peso_libras:,.2f} lb")
+
+                local_row = pd.Series(dtype=object)
+                destino_calc = "Sin entrega local"
+                if not local_df.empty:
+                    destino_calc = st.selectbox("Destino ACP / entrega local", ["Sin entrega local"] + local_df["destino"].dropna().unique().tolist(), key="log_calc_destino")
+                    if destino_calc != "Sin entrega local":
+                        local_candidates = local_df[local_df["destino"] == destino_calc]
+                        if not local_candidates.empty:
+                            local_row = local_candidates.iloc[0]
+                renglon_log = st.text_input("Renglón / referencia", placeholder="Opcional", key="log_calc_renglon")
+
+                calc = logistics_calc_summary(
+                    freight_row,
+                    local_row,
+                    peso_libras,
+                    incoterm=incoterm_calc,
+                    largo=largo_log,
+                    ancho=ancho_log,
+                    alto=alto_log,
+                    unidad_dimensional=unidad_log,
+                    bultos=bultos_log,
+                )
+                if st.button("Guardar cálculo logístico", type="primary", use_container_width=True):
+                    db.save_logistics_calculation(
+                        username=st.session_state.username,
+                        licitacion=lic_log,
+                        renglon=renglon_log,
+                        agente=agente_calc,
+                        tipo_flete=tipo_flete_calc,
+                        incoterm=incoterm_calc,
+                        peso_libras=calc["peso_libras"],
+                        peso_kg=calc["peso_kg"],
+                        costo_internacional=calc["costo_internacional"],
+                        costo_local=calc["costo_local"],
+                        costo_total=calc["costo_total"],
+                        tiempo_transito_dias=calc["tiempo_transito_dias"],
+                        peso_facturable_libras=calc["peso_facturable_libras"],
+                        peso_volumetrico_libras=calc["peso_volumetrico_libras"],
+                        largo=calc["largo"],
+                        ancho=calc["ancho"],
+                        alto=calc["alto"],
+                        unidad_dimensional=calc["unidad_dimensional"],
+                        metadata={
+                            "destino": destino_calc,
+                            "ruta": LOGISTICS_ROUTE_LABEL,
+                            "origen_tarifario": LOGISTICS_ROUTE_ORIGIN,
+                            "destino_tarifario": LOGISTICS_ROUTE_DESTINATION,
+                            "modo_calculo": modo_peso_log,
+                            "peso_por_paquete_lb": peso_paquete_log,
+                            "tarifa_por_libra": float(freight_row.get("tarifa_por_libra", 0) or 0),
+                            "bultos": calc["bultos"],
+                            "volumen_pies_cubicos": calc["volumen_pies_cubicos"],
+                        }
+                    )
+                    clear_logistics_cache()
+                    st.success("Cálculo logístico guardado.")
+
+            with calc_right:
+                st.markdown("#### Resultado estimado")
+                st.metric("Costo total", f"$ {calc['costo_total']:,.2f}")
+                st.metric("Flete internacional", f"$ {calc['costo_internacional']:,.2f}")
+                st.metric("Entrega local", f"$ {calc['costo_local']:,.2f}")
+                st.metric("Peso convertido", f"{calc['peso_kg']:,.2f} kg")
+                st.metric("Peso volumétrico", f"{calc['peso_volumetrico_libras']:,.2f} lb")
+                st.metric("Peso facturable", f"{calc['peso_facturable_libras']:,.2f} lb")
+                st.metric("Volumen", f"{calc['volumen_pies_cubicos']:,.2f} ft³")
+                render_notice_panel(
+                    "Ruta y lead time",
+                    f"{LOGISTICS_ROUTE_LABEL}. {agente_calc} / {tipo_flete_calc}: {calc['tiempo_transito_dias']} día(s) estimados. Día de corte: {freight_row.get('dia_corte', 'N/A') or 'N/A'}.",
+                    "blue",
+                )
+
+    with tab_rates:
+        st.dataframe(
+            freight_df,
+            use_container_width=True,
+            hide_index=True,
+            column_config={
+                "tarifa_por_libra": st.column_config.NumberColumn("Tarifa/lb", format="$ %.2f"),
+                "minimo_envio": st.column_config.NumberColumn("Mínimo", format="$ %.2f"),
+                "tiempo_transito_dias": st.column_config.NumberColumn("Días", format="%d"),
+            },
+        )
+        with st.expander("Agregar o actualizar tarifa internacional"):
+            f1, f2, f3 = st.columns(3)
+            with f1:
+                agente = st.text_input("Agente", key="log_rate_agente")
+                tipo_servicio = st.text_input("Tipo de servicio", value="Door-To-Door", key="log_rate_servicio")
+            with f2:
+                tipo_flete = st.selectbox("Tipo flete", ["Aereo", "Maritimo"], key="log_rate_tipo")
+                tarifa = st.number_input("Tarifa por libra", min_value=0.0, step=0.5, key="log_rate_tarifa")
+            with f3:
+                dias = st.number_input("Tiempo tránsito días", min_value=0, step=1, key="log_rate_dias")
+                minimo = st.number_input("Mínimo por envío", min_value=0.0, step=5.0, key="log_rate_minimo")
+            dia_corte = st.text_input("Día de corte", value="-", key="log_rate_corte")
+            salidas = st.text_input("Salidas", value="Según disponibilidad", key="log_rate_salidas")
+            if st.button("Guardar tarifa internacional", type="primary"):
+                if agente.strip():
+                    db.upsert_logistics_freight_rate(agente, tipo_servicio, tipo_flete, tarifa, dias, minimo, dia_corte, salidas)
+                    clear_logistics_cache()
+                    st.success("Tarifa internacional guardada.")
+                    st.rerun()
+                else:
+                    st.warning("Indica el agente.")
+
+    with tab_local:
+        st.dataframe(
+            local_df,
+            use_container_width=True,
+            hide_index=True,
+            column_config={
+                "hasta_400kg": st.column_config.NumberColumn("Hasta 400 kg", format="$ %.2f"),
+                "kg_500_1000": st.column_config.NumberColumn("500 a 1000 kg", format="$ %.2f"),
+                "mayor_1000kg": st.column_config.NumberColumn("> 1000 kg", format="$ %.2f"),
+            },
+        )
+        with st.expander("Agregar o actualizar entrega local"):
+            l1, l2, l3 = st.columns(3)
+            with l1:
+                agente_local = st.text_input("Agente local", value="Ariel Nunez", key="log_local_agente")
+                destino_local = st.text_input("Destino", key="log_local_destino")
+            with l2:
+                hasta_400 = st.number_input("Hasta 400 kg", min_value=0.0, step=10.0, key="log_local_400")
+                de_500_1000 = st.number_input("500 a 1000 kg", min_value=0.0, step=10.0, key="log_local_1000")
+            with l3:
+                mayor_1000 = st.number_input("Mayor a 1000 kg", min_value=0.0, step=10.0, key="log_local_mayor")
+                tipo_local = st.text_input("Tipo", value="Terrestre", key="log_local_tipo")
+            if st.button("Guardar entrega local", type="primary"):
+                if destino_local.strip():
+                    db.upsert_logistics_local_rate(agente_local, destino_local, tipo_local, hasta_400, de_500_1000, mayor_1000)
+                    clear_logistics_cache()
+                    st.success("Tarifa local guardada.")
+                    st.rerun()
+                else:
+                    st.warning("Indica el destino.")
+
+    with tab_forwarders:
+        st.dataframe(forwarders_df, use_container_width=True, hide_index=True)
+        with st.expander("Agregar o actualizar forwarder"):
+            nombre_fwd = st.text_input("Nombre", key="log_fwd_nombre")
+            direccion_fwd = st.text_area("Dirección", key="log_fwd_direccion")
+            obs_fwd = st.text_area("Observación", key="log_fwd_obs")
+            if st.button("Guardar forwarder", type="primary"):
+                if nombre_fwd.strip():
+                    db.upsert_logistics_forwarder(nombre_fwd, direccion_fwd, obs_fwd)
+                    clear_logistics_cache()
+                    st.success("Forwarder guardado.")
+                    st.rerun()
+                else:
+                    st.warning("Indica el nombre.")
+
+    with tab_incoterms:
+        if incoterms_df.empty:
+            render_empty_state("Sin incoterms", "No hay incoterms cargados.")
+        else:
+            incoterm_view = incoterms_df[["sigla", "incoterm"]].copy()
+            st.dataframe(incoterm_view, use_container_width=True, hide_index=True)
+            render_notice_panel(
+                "Cómo usar esta matriz",
+                "El incoterm define qué costos asume el proveedor y qué costos debe estimar Proyelec. La tabla inferior muestra el responsable por tramo.",
+                "blue",
+            )
+            selected_inc = st.selectbox("Ver responsabilidad por incoterm", incoterms_df["sigla"].tolist())
+            inc_row = incoterms_df[incoterms_df["sigla"] == selected_inc].iloc[0]
+            responsabilidades = inc_row.get("responsabilidades", {}) or {}
+            if isinstance(responsabilidades, str):
+                try:
+                    responsabilidades = json.loads(responsabilidades)
+                except Exception:
+                    responsabilidades = {}
+            resp_df = pd.DataFrame([
+                {"Tramo": key.replace("_", " ").title(), "Responsable": value}
+                for key, value in responsabilidades.items()
+            ])
+            st.dataframe(resp_df, use_container_width=True, hide_index=True)
+
+    with tab_history:
+        calc_df = get_logistics_calculations_cached(100)
+        if calc_df.empty:
+            render_empty_state("Sin cálculos guardados", "Los cálculos logísticos guardados aparecerán aquí.")
+        else:
+            st.dataframe(
+                calc_df,
+                use_container_width=True,
+                hide_index=True,
+                column_config={
+                    "costo_internacional": st.column_config.NumberColumn("Internacional", format="$ %.2f"),
+                    "costo_local": st.column_config.NumberColumn("Local", format="$ %.2f"),
+                    "costo_total": st.column_config.NumberColumn("Total", format="$ %.2f"),
+                    "peso_libras": st.column_config.NumberColumn("lb", format="%.2f"),
+                    "peso_kg": st.column_config.NumberColumn("kg", format="%.2f"),
+                    "peso_facturable_libras": st.column_config.NumberColumn("Peso facturable lb", format="%.2f"),
+                    "peso_volumetrico_libras": st.column_config.NumberColumn("Peso volumétrico lb", format="%.2f"),
+                },
+            )
+            st.divider()
+            delete_options = calc_df["id"].tolist()
+            selected_delete = st.selectbox(
+                "Cálculo guardado a borrar",
+                delete_options,
+                format_func=lambda calc_id: (
+                    f"#{calc_id} | "
+                    f"{calc_df.loc[calc_df['id'] == calc_id, 'licitacion'].iloc[0] or 'Sin licitación'} | "
+                    f"$ {float(calc_df.loc[calc_df['id'] == calc_id, 'costo_total'].iloc[0] or 0):,.2f}"
+                ),
+                key="log_delete_calc_id",
+            )
+            if st.button("Borrar cálculo seleccionado", type="secondary", use_container_width=True):
+                deleted = db.delete_logistics_calculation(selected_delete)
+                clear_logistics_cache()
+                if deleted:
+                    st.success("Cálculo borrado.")
+                    st.rerun()
+                else:
+                    st.warning("No se encontró el cálculo seleccionado.")
+
 if active_view == "🌐 Proveedores":
     render_page_header(
         "Sourcing global",
@@ -3674,9 +4111,13 @@ if active_view == "🚀 Tablero de Operaciones":
         if "acepta_equivalente" in df_render.columns:
             df_render["equivalente_txt"] = df_render["acepta_equivalente"].apply(bool_label)
 
+        result_views = ["📋 1. Matriz de Productos", "📨 2. Emisión de RFQs", "🤖 3. Centro de Mando AI", "📈 4. Análisis de Costos"]
+        if role_can("logistics_calc"):
+            result_views.append("🚚 5. Costos Logísticos")
+
         result_view = st.radio(
             "Vista de licitacion",
-            ["📋 1. Matriz de Productos", "📨 2. Emisión de RFQs", "🤖 3. Centro de Mando AI", "📈 4. Análisis de Costos"],
+            result_views,
             horizontal=True,
             label_visibility="collapsed",
             key="result_view",
@@ -4532,5 +4973,172 @@ Responde de forma clara y profesional. Si puedes dar un número o dato exacto de
                 
                 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)
+                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)
+
+        if result_view == "🚚 5. Costos Logísticos":
+            st.markdown("### 🚚 Cálculo logístico por renglón")
+            render_notice_panel(
+                "Ruta tarifaria vigente",
+                f"{LOGISTICS_ROUTE_LABEL}. Estas tarifas no estiman costos desde China, Europa u otros orígenes hasta que Logística cargue una ruta específica.",
+                "blue",
+            )
+            freight_df = get_logistics_freight_rates_cached()
+            local_df = get_logistics_local_rates_cached()
+            incoterms_df = get_logistics_incoterms_cached()
+            if freight_df.empty:
+                render_empty_state("Sin tarifas logísticas", "Solicita a Logística cargar las tarifas base antes de calcular costos.")
+            else:
+                log_left, log_right = st.columns([0.58, 0.42])
+                with log_left:
+                    def _log_item_label(idx):
+                        row = df_render.iloc[idx]
+                        return f"Renglón {row.get('renglon', idx + 1)} · {row.get('codigo_articulo', 'S/C')} · {str(row.get('termino_de_busqueda_corto', ''))[:55]}"
+
+                    route_a, route_b = st.columns(2)
+                    with route_a:
+                        st.text_input("Origen tarifario", value=LOGISTICS_ROUTE_ORIGIN, disabled=True, key="rfq_log_origin")
+                    with route_b:
+                        st.text_input("Destino tarifario", value=LOGISTICS_ROUTE_DESTINATION, disabled=True, key="rfq_log_route_dest")
+
+                    item_idx = st.selectbox(
+                        "Renglón",
+                        list(range(len(df_render))),
+                        format_func=_log_item_label,
+                        key="rfq_log_item_idx",
+                    )
+                    selected_item = df_render.iloc[item_idx]
+                    qty_for_hint = pd.to_numeric(selected_item.get("cantidad", 1), errors="coerce")
+                    qty_for_hint = float(qty_for_hint) if pd.notna(qty_for_hint) and float(qty_for_hint) > 0 else 1.0
+                    modo_peso_rfq = st.radio(
+                        "Forma de cálculo",
+                        ["Por unidad del renglón", "Por paquete"],
+                        horizontal=True,
+                        key="rfq_log_modo_peso",
+                    )
+
+                    c1, c2 = st.columns(2)
+                    with c1:
+                        tipo_flete = st.selectbox("Tipo de flete", sorted(freight_df["tipo_flete"].dropna().unique().tolist()), key="rfq_log_tipo")
+                    freight_filtered = freight_df[freight_df["tipo_flete"] == tipo_flete].copy()
+                    with c2:
+                        agente_flete = st.selectbox("Agente", freight_filtered["agente"].dropna().unique().tolist(), key="rfq_log_agente")
+                    freight_row = freight_filtered[freight_filtered["agente"] == agente_flete].iloc[0]
+
+                    if modo_peso_rfq == "Por paquete":
+                        c3, c4, c5, c6 = st.columns([0.24, 0.24, 0.24, 0.28])
+                        with c3:
+                            peso_paquete_rfq = st.number_input("Peso por paquete lb", min_value=0.0, value=1.0, step=0.5, key="rfq_log_pkg_lb")
+                        with c4:
+                            bultos_rfq = st.number_input("Paquetes", min_value=1, value=1, step=1, key="rfq_log_pkg_count")
+                        with c5:
+                            cantidad_log = st.number_input("Cantidad renglón", min_value=1.0, value=max(qty_for_hint, 1.0), step=1.0, key="rfq_log_qty")
+                        with c6:
+                            incoterm_log = st.selectbox("Incoterm", incoterms_df["sigla"].tolist() if not incoterms_df.empty else ["FOB"], key="rfq_log_incoterm")
+                        peso_unit_lb = peso_paquete_rfq
+                        peso_total_lb = peso_paquete_rfq * bultos_rfq
+                    else:
+                        c3, c4, c5, c6 = st.columns([0.24, 0.24, 0.24, 0.28])
+                        with c3:
+                            peso_unit_lb = st.number_input("Peso unitario lb", min_value=0.0, value=1.0, step=0.5, key="rfq_log_unit_lb")
+                        with c4:
+                            cantidad_log = st.number_input("Cantidad", min_value=1.0, value=max(qty_for_hint, 1.0), step=1.0, key="rfq_log_qty")
+                        with c5:
+                            bultos_rfq = st.number_input("Paquetes / bultos", min_value=1, value=1, step=1, key="rfq_log_bultos")
+                        with c6:
+                            incoterm_log = st.selectbox("Incoterm", incoterms_df["sigla"].tolist() if not incoterms_df.empty else ["FOB"], key="rfq_log_incoterm")
+                        peso_paquete_rfq = peso_unit_lb
+                        peso_total_lb = peso_unit_lb * cantidad_log
+
+                    st.caption("Dimensiones por paquete/bulto para estimar peso volumétrico.")
+                    d1, d2, d3, d4, d5 = st.columns([0.2, 0.2, 0.2, 0.18, 0.22])
+                    with d1:
+                        largo_rfq = st.number_input("Largo", min_value=0.0, value=0.0, step=1.0, key="rfq_log_largo")
+                    with d2:
+                        ancho_rfq = st.number_input("Ancho", min_value=0.0, value=0.0, step=1.0, key="rfq_log_ancho")
+                    with d3:
+                        alto_rfq = st.number_input("Alto", min_value=0.0, value=0.0, step=1.0, key="rfq_log_alto")
+                    with d4:
+                        unidad_rfq = st.selectbox("Unidad", ["in", "cm"], key="rfq_log_unidad_dim")
+                    with d5:
+                        st.metric("Peso total", f"{peso_total_lb:,.2f} lb")
+
+                    local_row = pd.Series(dtype=object)
+                    destino_log = "Sin entrega local"
+                    if not local_df.empty:
+                        destino_log = st.selectbox("Entrega local", ["Sin entrega local"] + local_df["destino"].dropna().unique().tolist(), key="rfq_log_destino")
+                        if destino_log != "Sin entrega local":
+                            local_candidates = local_df[local_df["destino"] == destino_log]
+                            if not local_candidates.empty:
+                                local_row = local_candidates.iloc[0]
+
+                    calc = logistics_calc_summary(
+                        freight_row,
+                        local_row,
+                        peso_total_lb,
+                        incoterm=incoterm_log,
+                        largo=largo_rfq,
+                        ancho=ancho_rfq,
+                        alto=alto_rfq,
+                        unidad_dimensional=unidad_rfq,
+                        bultos=bultos_rfq,
+                    )
+                    costo_unit_log = calc["costo_total"] / cantidad_log if cantidad_log else 0
+
+                    if st.button("Guardar costo logístico del renglón", type="primary", use_container_width=True):
+                        db.save_logistics_calculation(
+                            username=st.session_state.username,
+                            licitacion=str(cg_render.get("numero_licitacion", "")),
+                            renglon=str(selected_item.get("renglon", "")),
+                            agente=agente_flete,
+                            tipo_flete=tipo_flete,
+                            incoterm=incoterm_log,
+                            peso_libras=calc["peso_libras"],
+                            peso_kg=calc["peso_kg"],
+                            costo_internacional=calc["costo_internacional"],
+                            costo_local=calc["costo_local"],
+                            costo_total=calc["costo_total"],
+                            tiempo_transito_dias=calc["tiempo_transito_dias"],
+                            peso_facturable_libras=calc["peso_facturable_libras"],
+                            peso_volumetrico_libras=calc["peso_volumetrico_libras"],
+                            largo=calc["largo"],
+                            ancho=calc["ancho"],
+                            alto=calc["alto"],
+                            unidad_dimensional=calc["unidad_dimensional"],
+                            metadata={
+                                "destino": destino_log,
+                                "ruta": LOGISTICS_ROUTE_LABEL,
+                                "origen_tarifario": LOGISTICS_ROUTE_ORIGIN,
+                                "destino_tarifario": LOGISTICS_ROUTE_DESTINATION,
+                                "modo_calculo": modo_peso_rfq,
+                                "cantidad": cantidad_log,
+                                "peso_unitario_lb": peso_unit_lb,
+                                "peso_por_paquete_lb": peso_paquete_rfq,
+                                "bultos": calc["bultos"],
+                                "volumen_pies_cubicos": calc["volumen_pies_cubicos"],
+                                "codigo_articulo": str(selected_item.get("codigo_articulo", "")),
+                            }
+                        )
+                        clear_logistics_cache()
+                        st.success("Costo logístico guardado para trazabilidad.")
+
+                with log_right:
+                    st.metric("Costo logístico total", f"$ {calc['costo_total']:,.2f}")
+                    st.metric("Costo logístico unitario", f"$ {costo_unit_log:,.2f}")
+                    st.metric("Flete internacional", f"$ {calc['costo_internacional']:,.2f}")
+                    st.metric("Entrega local", f"$ {calc['costo_local']:,.2f}")
+                    render_notice_panel(
+                        "Lead time calculado",
+                        f"{LOGISTICS_ROUTE_LABEL}. {agente_flete} / {tipo_flete}: {calc['tiempo_transito_dias']} día(s). Peso real: {calc['peso_libras']:,.2f} lb. Peso facturable: {calc['peso_facturable_libras']:,.2f} lb.",
+                        "blue",
+                    )
+
+                calc_df = get_logistics_calculations_cached(50)
+                if not calc_df.empty:
+                    st.caption("Últimos cálculos logísticos guardados")
+                    st.dataframe(
+                        calc_df[["created_at", "licitacion", "renglon", "agente", "tipo_flete", "incoterm", "costo_total", "tiempo_transito_dias"]].head(10),
+                        use_container_width=True,
+                        hide_index=True,
+                        column_config={"costo_total": st.column_config.NumberColumn("Total", format="$ %.2f")},
+                    )

database.py

@@ -265,16 +265,89 @@ def init_db():
     )''')
 
     # Log de escaneos del radar
-    c.execute('''CREATE TABLE IF NOT EXISTS radar_escaneos (
-        id SERIAL PRIMARY KEY,
-        fecha TEXT,
-        total_encontradas INTEGER DEFAULT 0,
-        nuevas INTEGER DEFAULT 0,
-        errores TEXT
-    )''')
-
-    conn.commit()
-    conn.close()
+    c.execute('''CREATE TABLE IF NOT EXISTS radar_escaneos (
+        id SERIAL PRIMARY KEY,
+        fecha TEXT,
+        total_encontradas INTEGER DEFAULT 0,
+        nuevas INTEGER DEFAULT 0,
+        errores TEXT
+    )''')
+
+    # === MODULO LOGISTICO ===
+    c.execute('''CREATE TABLE IF NOT EXISTS logistics_incoterms (
+        sigla TEXT PRIMARY KEY,
+        incoterm TEXT,
+        responsabilidades JSONB DEFAULT '{}'::jsonb,
+        notas TEXT,
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+    )''')
+    c.execute('''CREATE TABLE IF NOT EXISTS logistics_freight_rates (
+        id SERIAL PRIMARY KEY,
+        agente TEXT NOT NULL,
+        tipo_servicio TEXT,
+        tipo_flete TEXT NOT NULL,
+        tarifa_por_libra NUMERIC(12, 4) DEFAULT 0,
+        tiempo_transito_dias INTEGER DEFAULT 0,
+        minimo_envio NUMERIC(12, 4) DEFAULT 0,
+        dia_corte TEXT,
+        salidas TEXT,
+        activo BOOLEAN DEFAULT TRUE,
+        updated_at TIMESTAMPTZ DEFAULT NOW(),
+        UNIQUE(agente, tipo_flete, tipo_servicio)
+    )''')
+    c.execute('''CREATE TABLE IF NOT EXISTS logistics_local_delivery_rates (
+        id SERIAL PRIMARY KEY,
+        agente TEXT NOT NULL,
+        destino TEXT NOT NULL,
+        tipo_flete TEXT DEFAULT 'Terrestre',
+        hasta_400kg NUMERIC(12, 4) DEFAULT 0,
+        kg_500_1000 NUMERIC(12, 4) DEFAULT 0,
+        mayor_1000kg NUMERIC(12, 4) DEFAULT 0,
+        activo BOOLEAN DEFAULT TRUE,
+        updated_at TIMESTAMPTZ DEFAULT NOW(),
+        UNIQUE(agente, destino)
+    )''')
+    c.execute('''CREATE TABLE IF NOT EXISTS logistics_forwarders (
+        id SERIAL PRIMARY KEY,
+        nombre TEXT UNIQUE NOT NULL,
+        direccion TEXT,
+        observacion TEXT,
+        activo BOOLEAN DEFAULT TRUE,
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+    )''')
+    c.execute('''CREATE TABLE IF NOT EXISTS logistics_calculations (
+        id SERIAL PRIMARY KEY,
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        username TEXT,
+        licitacion TEXT,
+        renglon TEXT,
+        agente TEXT,
+        tipo_flete TEXT,
+        incoterm TEXT,
+        peso_libras NUMERIC(14, 4) DEFAULT 0,
+        peso_kg NUMERIC(14, 4) DEFAULT 0,
+        costo_internacional NUMERIC(14, 4) DEFAULT 0,
+        costo_local NUMERIC(14, 4) DEFAULT 0,
+        costo_total NUMERIC(14, 4) DEFAULT 0,
+        tiempo_transito_dias INTEGER DEFAULT 0,
+        metadata JSONB DEFAULT '{}'::jsonb
+    )''')
+    for ddl in [
+        "ALTER TABLE logistics_calculations ADD COLUMN IF NOT EXISTS peso_facturable_libras NUMERIC(14, 4) DEFAULT 0",
+        "ALTER TABLE logistics_calculations ADD COLUMN IF NOT EXISTS peso_volumetrico_libras NUMERIC(14, 4) DEFAULT 0",
+        "ALTER TABLE logistics_calculations ADD COLUMN IF NOT EXISTS largo NUMERIC(14, 4) DEFAULT 0",
+        "ALTER TABLE logistics_calculations ADD COLUMN IF NOT EXISTS ancho NUMERIC(14, 4) DEFAULT 0",
+        "ALTER TABLE logistics_calculations ADD COLUMN IF NOT EXISTS alto NUMERIC(14, 4) DEFAULT 0",
+        "ALTER TABLE logistics_calculations ADD COLUMN IF NOT EXISTS unidad_dimensional TEXT DEFAULT 'in'",
+    ]:
+        c.execute(ddl)
+    c.execute("CREATE INDEX IF NOT EXISTS idx_logistics_calculations_created ON logistics_calculations(created_at DESC)")
+    c.execute("CREATE INDEX IF NOT EXISTS idx_logistics_calculations_licitacion ON logistics_calculations(licitacion)")
+
+    _seed_logistics_defaults(c)
+
+    conn.commit()
+    conn.close()
 
 # =============================================
 # WORKSPACES (MÚLTIPLES POR USUARIO)
@@ -428,6 +501,210 @@ def get_historico_licitaciones_df(limit=5000, search=None, anio=None):
     conn.close()
     return df
 
+
+# =============================================
+# LOGISTICA
+# =============================================
+
+INCOTERM_STEPS = [
+    "embalaje_verificacion",
+    "carga_almacen",
+    "transporte_interno_origen",
+    "tramites_aduaneros_exportacion",
+    "costo_terminal_origen",
+    "transporte_principal",
+    "seguro_transporte",
+    "costo_terminal_destino",
+    "tramites_aduaneros_importacion",
+    "transporte_interior_destino",
+    "descarga_almacen_comprador",
+]
+
+def _seed_logistics_defaults(c):
+    incoterms = {
+        "EXW": ("Ex Works", ["Vendedor", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador"]),
+        "FCA": ("Free Carrier", ["Vendedor", "Vendedor", "Vendedor", "Vendedor", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador"]),
+        "FAS": ("Free Alongside Ship", ["Vendedor", "Vendedor", "Vendedor", "Vendedor", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador"]),
+        "FOB": ("Free On Board", ["Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador"]),
+        "CPT": ("Carriage Paid To", ["Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador"]),
+        "CFR": ("Cost and Freight", ["Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Comprador", "Comprador", "Comprador", "Comprador", "Comprador"]),
+        "CIP": ("Carriage and Insurance Paid To", ["Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Comprador", "Comprador", "Comprador", "Comprador"]),
+        "CIF": ("Cost, Insurance and Freight", ["Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Comprador", "Comprador", "Comprador", "Comprador"]),
+        "DAP": ("Delivered at Place", ["Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Comprador", "Vendedor", "Comprador"]),
+        "DPU": ("Delivered at Place Unloaded", ["Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Vendedor", "Comprador", "Vendedor", "Vendedor"]),
+    }
+    for sigla, (nombre, valores) in incoterms.items():
+        responsabilidades = dict(zip(INCOTERM_STEPS, valores))
+        c.execute("""INSERT INTO logistics_incoterms (sigla, incoterm, responsabilidades, notas)
+            VALUES (%s, %s, %s::jsonb, %s)
+            ON CONFLICT (sigla) DO NOTHING""",
+            (sigla, nombre, json.dumps(responsabilidades, ensure_ascii=False), ""))
+
+    freight_rows = [
+        ("Southcargo", "Door-To-Door", "Aereo", 3, 3, 10, "-", "Segun disponibilidad de la aerolinea"),
+        ("ABMCARGO", "Door-To-Door", "Aereo", 50, 3, 35, "-", "Segun disponibilidad de la aerolinea"),
+        ("Southcargo", "Door-To-Door", "Maritimo", 3, 6, 55, "Martes", "Semanales"),
+        ("ABMCARGO", "Door-To-Door", "Maritimo", 50, 6, 90, "Martes", "Semanales"),
+    ]
+    for row in freight_rows:
+        c.execute("""INSERT INTO logistics_freight_rates
+            (agente, tipo_servicio, tipo_flete, tarifa_por_libra, tiempo_transito_dias, minimo_envio, dia_corte, salidas)
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+            ON CONFLICT (agente, tipo_flete, tipo_servicio) DO NOTHING""", row)
+
+    local_rows = [
+        ("Ariel Nunez", "Corozal", "Terrestre", 50, 200, 230),
+        ("Ariel Nunez", "Miraflores", "Terrestre", 50, 200, 230),
+        ("Ariel Nunez", "Balboa", "Terrestre", 50, 200, 230),
+        ("Ariel Nunez", "Gamboa", "Terrestre", 70, 200, 230),
+        ("Ariel Nunez", "Colon", "Terrestre", 110, 200, 230),
+        ("Ariel Nunez", "Atlantico Panama Pacifico", "Terrestre", 60, 200, 450),
+    ]
+    for row in local_rows:
+        c.execute("""INSERT INTO logistics_local_delivery_rates
+            (agente, destino, tipo_flete, hasta_400kg, kg_500_1000, mayor_1000kg)
+            VALUES (%s, %s, %s, %s, %s, %s)
+            ON CONFLICT (agente, destino) DO NOTHING""", row)
+
+    forwarders = [
+        ("SOUTH CARGO", "6708 NW 82ND AVE. MIAMI, FL. 33166", "Agente de envio / Centro de inspeccion."),
+        ("ABM LOGISTICS", "9372 NW 101 ST MEDLEY, FL 33178 UNITED STATES", "Agente de envio / Centro de inspeccion."),
+        ("MERCOSTAR", "8012 NW 68th Street Miami - FL 33166", "Centro de inspeccion."),
+        ("ARIEL NUNEZ", "LAS CUMBRES CAIMITILLO CALLE SEGOVIA OESTE CASA 35J", "Entrega a cliente / Inspector."),
+        ("DHL", "AV CENTENARIO, PANAMA CITY", "Agente de envio / Centro de inspeccion."),
+    ]
+    for row in forwarders:
+        c.execute("""INSERT INTO logistics_forwarders (nombre, direccion, observacion)
+            VALUES (%s, %s, %s)
+            ON CONFLICT (nombre) DO NOTHING""", row)
+
+def get_logistics_freight_rates():
+    conn = get_connection()
+    try:
+        return pd.read_sql_query("SELECT * FROM logistics_freight_rates ORDER BY tipo_flete, agente", conn)
+    finally:
+        conn.close()
+
+def get_logistics_local_rates():
+    conn = get_connection()
+    try:
+        return pd.read_sql_query("SELECT * FROM logistics_local_delivery_rates ORDER BY agente, destino", conn)
+    finally:
+        conn.close()
+
+def get_logistics_forwarders():
+    conn = get_connection()
+    try:
+        return pd.read_sql_query("SELECT * FROM logistics_forwarders ORDER BY nombre", conn)
+    finally:
+        conn.close()
+
+def get_logistics_incoterms():
+    conn = get_connection()
+    try:
+        return pd.read_sql_query("SELECT sigla, incoterm, responsabilidades, notas FROM logistics_incoterms ORDER BY sigla", conn)
+    finally:
+        conn.close()
+
+def upsert_logistics_freight_rate(agente, tipo_servicio, tipo_flete, tarifa_por_libra,
+                                  tiempo_transito_dias, minimo_envio, dia_corte, salidas, activo=True):
+    conn = get_connection()
+    try:
+        c = conn.cursor()
+        c.execute("""INSERT INTO logistics_freight_rates
+            (agente, tipo_servicio, tipo_flete, tarifa_por_libra, tiempo_transito_dias, minimo_envio, dia_corte, salidas, activo)
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
+            ON CONFLICT (agente, tipo_flete, tipo_servicio) DO UPDATE SET
+                tarifa_por_libra=EXCLUDED.tarifa_por_libra,
+                tiempo_transito_dias=EXCLUDED.tiempo_transito_dias,
+                minimo_envio=EXCLUDED.minimo_envio,
+                dia_corte=EXCLUDED.dia_corte,
+                salidas=EXCLUDED.salidas,
+                activo=EXCLUDED.activo,
+                updated_at=NOW()""",
+            (agente, tipo_servicio, tipo_flete, tarifa_por_libra, tiempo_transito_dias, minimo_envio, dia_corte, salidas, activo))
+        conn.commit()
+    finally:
+        conn.close()
+
+def upsert_logistics_local_rate(agente, destino, tipo_flete, hasta_400kg, kg_500_1000, mayor_1000kg, activo=True):
+    conn = get_connection()
+    try:
+        c = conn.cursor()
+        c.execute("""INSERT INTO logistics_local_delivery_rates
+            (agente, destino, tipo_flete, hasta_400kg, kg_500_1000, mayor_1000kg, activo)
+            VALUES (%s, %s, %s, %s, %s, %s, %s)
+            ON CONFLICT (agente, destino) DO UPDATE SET
+                tipo_flete=EXCLUDED.tipo_flete,
+                hasta_400kg=EXCLUDED.hasta_400kg,
+                kg_500_1000=EXCLUDED.kg_500_1000,
+                mayor_1000kg=EXCLUDED.mayor_1000kg,
+                activo=EXCLUDED.activo,
+                updated_at=NOW()""",
+            (agente, destino, tipo_flete, hasta_400kg, kg_500_1000, mayor_1000kg, activo))
+        conn.commit()
+    finally:
+        conn.close()
+
+def upsert_logistics_forwarder(nombre, direccion, observacion, activo=True):
+    conn = get_connection()
+    try:
+        c = conn.cursor()
+        c.execute("""INSERT INTO logistics_forwarders (nombre, direccion, observacion, activo)
+            VALUES (%s, %s, %s, %s)
+            ON CONFLICT (nombre) DO UPDATE SET
+                direccion=EXCLUDED.direccion,
+                observacion=EXCLUDED.observacion,
+                activo=EXCLUDED.activo,
+                updated_at=NOW()""",
+            (nombre, direccion, observacion, activo))
+        conn.commit()
+    finally:
+        conn.close()
+
+def save_logistics_calculation(username="", licitacion="", renglon="", agente="", tipo_flete="", incoterm="",
+                                peso_libras=0, peso_kg=0, costo_internacional=0, costo_local=0,
+                                costo_total=0, tiempo_transito_dias=0, metadata=None,
+                                peso_facturable_libras=0, peso_volumetrico_libras=0,
+                                largo=0, ancho=0, alto=0, unidad_dimensional="in"):
+    metadata = metadata or {}
+    conn = get_connection()
+    try:
+        c = conn.cursor()
+        c.execute("""INSERT INTO logistics_calculations
+             (username, licitacion, renglon, agente, tipo_flete, incoterm, peso_libras, peso_kg,
+             costo_internacional, costo_local, costo_total, tiempo_transito_dias, metadata,
+             peso_facturable_libras, peso_volumetrico_libras, largo, ancho, alto, unidad_dimensional)
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s::jsonb, %s, %s, %s, %s, %s, %s)""",
+            (username, licitacion, renglon, agente, tipo_flete, incoterm, peso_libras, peso_kg,
+             costo_internacional, costo_local, costo_total, tiempo_transito_dias,
+             json.dumps(metadata, ensure_ascii=False), peso_facturable_libras, peso_volumetrico_libras,
+             largo, ancho, alto, unidad_dimensional))
+        conn.commit()
+    finally:
+        conn.close()
+
+def get_logistics_calculations(limit=100):
+    conn = get_connection()
+    try:
+        return pd.read_sql_query(
+            f"SELECT * FROM logistics_calculations ORDER BY created_at DESC LIMIT {int(limit)}",
+            conn
+        )
+    finally:
+        conn.close()
+
+def delete_logistics_calculation(calculation_id):
+    conn = get_connection()
+    try:
+        c = conn.cursor()
+        c.execute("DELETE FROM logistics_calculations WHERE id = %s", (int(calculation_id),))
+        deleted = c.rowcount
+        conn.commit()
+        return deleted
+    finally:
+        conn.close()
+
 def get_historico_anios():
     conn = get_connection()
     df = pd.read_sql_query("""