Update app.py

app.py

@@ -1,14 +1,10 @@
 # -*- coding: utf-8 -*-
-import os
-import sys
-import platform
-import importlib
-from uuid import uuid4
-from datetime import date, datetime, time
-
 import streamlit as st
 from dotenv import load_dotenv
-from sqlalchemy import text, func
+from datetime import date, datetime, time
+
+# ⬇️ Import correto das utils de operação
+from utils_operacao import obter_grupos_disponiveis, obter_modulos_para_grupo
 
 # ✅ Usa toda a largura da página (chamar antes de qualquer outro st.*)
 st.set_page_config(layout="wide")
@@ -16,219 +12,92 @@ st.set_page_config(layout="wide")
 # Carrega variáveis de ambiente
 load_dotenv()
 
-# --------------------------------------------------------------------------------------
-# Utilitários de robustez / compatibilidade
-# --------------------------------------------------------------------------------------
-def _module_stub(name: str, hint: str = ""):
-    """Stub com .main() e .pagina() que exibe aviso amigável quando o módulo
-    não puder ser importado/usado no ambiente atual."""
-    class _Stub:
-        def __init__(self, _name, _hint):
-            self.__name = _name
-            self.__hint = _hint or "Módulo indisponível nesta hospedagem."
-        def main(self, *args, **kwargs):
-            st.warning(f"🔒 Módulo **{self.__name}** indisponível.\n\n{self.__hint}")
-        def pagina(self, *args, **kwargs):
-            self.main(*args, **kwargs)
-    return _Stub(name, hint)
-
-def _try_import(module_name: str, on_fail_hint: str = ""):
-    """Import 'seguro': caso falhe, retorna stub que não derruba o app."""
-    try:
-        return importlib.import_module(module_name)
-    except Exception as e:
-        return _module_stub(module_name, f"{on_fail_hint}\n\n**Detalhe técnico:** {e}")
-
-def _ensure_db_case_alias(expected_names=("load.db", "Load.db", "LOAD.DB")):
-    """Se existir um .db com caixa diferente, cria CÓPIA 'load.db' (Linux é case-sensitive)."""
-    base = os.path.abspath(os.getcwd())
-    candidates = [os.path.join(base, n) for n in expected_names]
-    lower = os.path.join(base, "load.db")
-    if os.path.exists(lower):
-        return lower
-    for path in candidates:
-        if os.path.exists(path):
-            try:
-                import shutil
-                shutil.copy(path, lower)
-                return lower
-            except Exception:
-                pass
-    return lower
-
-# Ajuste preventivo do case do banco (caso módulos internos usem 'load.db')
-_DB_ALIAS = _ensure_db_case_alias()
+# ===============================
+# IMPORTAÇÃO DOS MÓDULOS
+# ===============================
+import formulario
+import consulta
+import relatorio
+import administracao
+import quiz
+import ranking
+import quiz_admin
+import usuarios_admin
+import videos
+import auditoria
+import importar_excel
+import calendario
+import auditoria_cleanup
+import jogos
+import db_tools
+import db_admin
+import db_monitor
+import operacao
+import db_export_import
+import resposta                # 📬 Admin: Caixa de Entrada IOI‑RUN (módulo interno)
+import outlook_relatorio
+import repositorio_load
+import Produtividade_Especialista as produtividade_especialista
+import rnc
+import rnc_listagem
+import rnc_relatorio
+import sugestoes_usuario       # 💡 Usuário: Sugestões IOI‑RUN (módulo separado)
+import repo_rnc
+import recebimento
+
+# (Opcional) Calendário mensal — só se existir no projeto
+try:
+    import calendario_mensal
+    _HAS_CAL_MENSAL = True
+except Exception:
+    _HAS_CAL_MENSAL = False
 
-# --------------------------------------------------------------------------------------
-# Imports internos essenciais
-# --------------------------------------------------------------------------------------
-from utils_operacao import obter_grupos_disponiveis, obter_modulos_para_grupo
 from utils_info import INFO_CONTEUDO, INFO_MODULOS, INFO_MAP_PAGINA_ID
+from login import login
 from utils_permissoes import verificar_permissao
+from utils_layout import exibir_logo
 from modules_map import MODULES
 from banco import engine, Base, SessionLocal
-from models import QuizPontuacao, IOIRunSugestao, AvisoGlobal
+from models import QuizPontuacao
+from models import IOIRunSugestao
+from models import AvisoGlobal
 
-# ----- login / logo: import e “safe wrappers” -----------------------------------------
-# login()
-try:
-    from login import login as _login_orig
-except Exception as _e_login_import:
-    _login_orig = None
-    _login_import_err = _e_login_import
-
-def login_safe():
-    """Tenta usar o login normal; se falhar, permite autologin (DISABLE_AUTH=1)
-    ou opção emergencial (ALLOW_EMERGENCY_LOGIN=1)."""
-    # Autologin (debug)
-    if os.getenv("DISABLE_AUTH", "0") == "1":
-        st.session_state.logado = True
-        st.session_state.usuario = os.getenv("DEMO_USER", "demo")
-        st.session_state.perfil  = os.getenv("DEMO_PERFIL", "admin")
-        st.session_state.email   = os.getenv("DEMO_EMAIL", "demo@example.com")
-        st.info("🔓 Autologin ativado (DISABLE_AUTH=1). **Não use em produção.**")
-        return
-
-    # Fluxo normal
-    if _login_orig:
-        try:
-            _login_orig()
-            return
-        except Exception as e:
-            st.error(f"Falha ao carregar tela de login (login.py): {e}")
-
-    # Emergencial (opcional)
-    if os.getenv("ALLOW_EMERGENCY_LOGIN", "0") == "1":
-        with st.form("emergency_login"):
-            u = st.text_input("Usuário")
-            p = st.text_input("Senha", type="password")
-            ok = st.form_submit_button("Entrar (emergencial)")
-            if ok and u:
-                st.session_state.logado = True
-                st.session_state.usuario = u
-                st.session_state.perfil  = "admin"
-                st.session_state.email   = f"{u}@local"
-                st.warning("⚠️ Login emergencial ativo. Desative após os testes (ALLOW_EMERGENCY_LOGIN=0).")
-                st.rerun()
-    else:
-        st.info(
-            "Login temporariamente indisponível. "
-            "Para testar no Spaces, defina **DISABLE_AUTH=1** em *Settings → Secrets*."
-        )
-
-# exibir_logo()
-try:
-    from utils_layout import exibir_logo as _exibir_logo_orig
-except Exception as _e_layout_import:
-    _exibir_logo_orig = None
-    _exibir_logo_import_err = _e_layout_import
-
-def _resolve_logo_path() -> str | None:
-    """Procura a logo localmente; aceita LOGO_PATH absoluto ou relativo."""
-    cand = []
-    env_path = os.getenv("LOGO_PATH")
-    if env_path:
-        cand.append(env_path)
-    cand += ["logo.png", "assets/logo.png", "images/logo.png", "static/logo.png"]
-    base = os.path.abspath(os.getcwd())
-    for p in cand:
-        if not p:
-            continue
-        full = p if os.path.isabs(p) else os.path.join(base, p)
-        if os.path.exists(full):
-            return full
-    return None
-
-def exibir_logo_safe(top: bool = False, sidebar: bool = False):
-    """Usa sua função original; se falhar, exibe imagem local ou fallback de texto."""
-    try:
-        if _exibir_logo_orig:
-            return _exibir_logo_orig(top=top, sidebar=sidebar)
-    except Exception as e:
-        st.sidebar.warning(f"Logo padrão indisponível ({e}). Usando fallback.")
-    path = _resolve_logo_path()
-    if path:
-        if top:
-            st.image(path, use_column_width=False)
-        if sidebar:
-            st.sidebar.image(path, use_column_width=True)
-    else:
-        if top:
-            st.markdown("### IOI‑RUN")
-        if sidebar:
-            st.sidebar.markdown("### IOI‑RUN")
-
-# --------------------------------------------------------------------------------------
-# Imports de páginas/módulos com fallback
-# --------------------------------------------------------------------------------------
-formulario         = _try_import("formulario")
-consulta           = _try_import("consulta")
-relatorio          = _try_import("relatorio")
-administracao      = _try_import("administracao")
-quiz               = _try_import("quiz")
-ranking            = _try_import("ranking")
-quiz_admin         = _try_import("quiz_admin")
-usuarios_admin     = _try_import("usuarios_admin", "Adicione **bcrypt** ao requirements.txt.")
-videos             = _try_import("videos")
-auditoria          = _try_import("auditoria")
-importar_excel     = _try_import("importar_excel")
-calendario         = _try_import("calendario", "Instale **streamlit-calendar** no requirements.txt.")
-auditoria_cleanup  = _try_import("auditoria_cleanup")
-jogos              = _try_import("jogos")
-db_tools           = _try_import("db_tools")
-db_admin           = _try_import("db_admin")
-db_monitor         = _try_import("db_monitor")
-operacao           = _try_import("operacao")
-db_export_import   = _try_import("db_export_import")
-resposta           = _try_import("resposta")  # 📬 Admin
-repositorio_load   = _try_import("repositorio_load")
-produtividade_especialista = _try_import("Produtividade_Especialista")
-rnc                = _try_import("rnc")
-rnc_listagem       = _try_import("rnc_listagem")
-rnc_relatorio      = _try_import("rnc_relatorio")
-sugestoes_usuario  = _try_import("sugestoes_usuario")
-repo_rnc           = _try_import("repo_rnc")
-recebimento        = _try_import("recebimento")
-
-# Outlook/COM (somente Windows). Em Linux/Spaces: desativado ou stub.
-_DISABLE_OUTLOOK = os.getenv("DISABLE_OUTLOOK", "0") == "1"
-if platform.system().lower() != "windows" or _DISABLE_OUTLOOK:
-    outlook_relatorio = _module_stub(
-        "outlook_relatorio",
-        "Este módulo usa automação COM do Outlook (pywin32), disponível **apenas no Windows**.\n"
-        "No servidor Linux, ele foi desativado. Para manter essa função em nuvem, use **Microsoft Graph API**."
-    )
-else:
-    outlook_relatorio = _try_import("outlook_relatorio")
+# Extras p/ sessões ativas
+from uuid import uuid4
+from sqlalchemy import text, func, or_
 
-# --------------------------------------------------------------------------------------
-# Roteamento condicional de banco
-# --------------------------------------------------------------------------------------
+# 🗄️ Banco ativo (Produção/Teste/Treinamento)
 try:
     from db_router import current_db_choice, bank_label
     _HAS_ROUTER = True
 except Exception:
     _HAS_ROUTER = False
+
     def current_db_choice() -> str:
         return "prod"
+
     def bank_label(choice: str) -> str:
         return "🟢 Produção" if choice == "prod" else "🔴 Teste"
 
-# --------------------------------------------------------------------------------------
-# RERUN por querystring (?rr=1)
-# --------------------------------------------------------------------------------------
+# ===============================
+# RERUN por querystring (atalho ?rr=1)
+# ===============================
 def _get_query_params():
+    """Compat: retorna query params como dict (Streamlit novo/antigo)."""
     try:
-        return dict(st.query_params)  # Streamlit >= 1.32
+        # Streamlit >= 1.32
+        return dict(st.query_params)
     except Exception:
+        # Streamlit antigo (experimental)
         try:
             return dict(st.experimental_get_query_params())
         except Exception:
             return {}
 
 def _set_query_params(new_params: dict):
+    """Compat: define query params (Streamlit novo/antigo)."""
     try:
-        st.query_params = new_params
+        st.query_params = new_params  # Streamlit >= 1.32
     except Exception:
         try:
             st.experimental_set_query_params(**new_params)
@@ -236,12 +105,20 @@ def _set_query_params(new_params: dict):
             pass
 
 def _check_rerun_qs(pagina_atual: str = ""):
+    """
+    Se a URL contiver rr=1 (ou true), força um rerun e limpa o parâmetro para evitar loop.
+    ✅ Não dispara quando estiver na página 'resposta' (Inbox Admin).
+    ✅ Consome apenas uma vez por sessão.
+    ✅ (PATCH) Também não dispara quando estiver em 'outlook_relatorio' para não interromper leitura COM.
+    ✅ (PATCH) Não dispara quando estiver em 'formulario'.
+    """
     try:
         if st.session_state.get("__qs_rr_consumed__", False):
             return
-        # Não aplica RR dentro de módulos sensíveis
+        # 🔒 Evita rr=1 em módulos sensíveis a rerun/refresh
         if pagina_atual in ("resposta", "outlook_relatorio", "formulario"):
-            return
+            return  # não aplicar rr=1 dentro destes módulos (evita 'piscar' e cancelamentos)
+
         params = _get_query_params()
         rr_raw = params.get("rr", ["0"])
         rr = rr_raw[0] if isinstance(rr_raw, (list, tuple)) else str(rr_raw)
@@ -253,44 +130,62 @@ def _check_rerun_qs(pagina_atual: str = ""):
     except Exception:
         pass
 
-# --------------------------------------------------------------------------------------
-# Sessões / DB helpers
-# --------------------------------------------------------------------------------------
+# =========================================
+# DB helper — sessão ciente do ambiente
+# =========================================
 def _get_db_session():
+    """Retorna uma sessão de banco consistente com o ambiente atual."""
+    # 1) Se o router expuser get_session_for_current_db(), use
     try:
-        from db_router import get_session_for_current_db
-        return get_session_for_current_db()
+        from db_router import get_session_factory
+        return get_session_factory()()
     except Exception:
         pass
+
+    # 2) Se houver engine por ambiente
     try:
-        from db_router import get_engine_for_current_db
+        from db_router import get_engine
         from sqlalchemy.orm import sessionmaker
-        Eng = get_engine_for_current_db()
+        Eng = get_engine()
         return sessionmaker(bind=Eng)()
     except Exception:
         pass
-    from sqlalchemy.orm import sessionmaker
-    return sessionmaker(bind=engine)()
 
-Base.metadata.create_all(bind=engine)
+    # 3) Fallback
+    return SessionLocal()
+
+# ===============================
+# CONFIGURAÇÃO INICIAL
+# ===============================
+# Criação do schema (sem derrubar a app se o banco ainda não estiver pronto)
+try:
+    Base.metadata.create_all(bind=engine)
+except Exception as e:
+    st.sidebar.warning(f"Schema não foi criado automaticamente: {e}")
 
 def quiz_respondido_hoje(usuario: str) -> bool:
+    # ✅ Usar sessão ciente do ambiente
     db = _get_db_session()
     try:
         inicio_dia = datetime.combine(date.today(), time.min)
         return (
             db.query(QuizPontuacao)
-              .filter(
-                  QuizPontuacao.usuario == usuario,
-                  QuizPontuacao.data >= inicio_dia
-              )
-              .first()
-              is not None
+            .filter(
+                QuizPontuacao.usuario == usuario,
+                QuizPontuacao.data >= inicio_dia
+            )
+            .first()
+            is not None
         )
     finally:
-        try: db.close()
-        except Exception: pass
+        try:
+            db.close()
+        except Exception:
+            pass
 
+# ===============================
+# Sessões ativas (usuários logados agora)
+# ===============================
 _SESS_TTL_MIN = 5  # janela para considerar "online"
 
 def _get_session_id() -> str:
@@ -299,6 +194,7 @@ def _get_session_id() -> str:
     return st.session_state["_sid"]
 
 def _ensure_sessao_table(db) -> None:
+    """Cria a tabela sessao_web caso não exista (SQLite/Postgres/MySQL)."""
     dialect = db.bind.dialect.name
     if dialect == "sqlite":
         db.execute(text("""
@@ -333,6 +229,7 @@ def _ensure_sessao_table(db) -> None:
     db.commit()
 
 def _session_heartbeat(usuario: str) -> None:
+    """Atualiza/insere a sessão ativa do usuário com last_seen = now() e faz limpeza básica."""
     if not usuario:
         return
     db = _get_db_session()
@@ -340,6 +237,7 @@ def _session_heartbeat(usuario: str) -> None:
         _ensure_sessao_table(db)
         sid = _get_session_id()
         now_sql = "CURRENT_TIMESTAMP"
+
         upd = db.execute(
             text(f"UPDATE sessao_web SET last_seen = {now_sql}, ativo = 1 WHERE session_id = :sid"),
             {"sid": sid}
@@ -350,6 +248,7 @@ def _session_heartbeat(usuario: str) -> None:
                      f"VALUES (:usuario, :sid, {now_sql}, 1)"),
                 {"usuario": usuario, "sid": sid}
             )
+
         dialect = db.bind.dialect.name
         if dialect in ("postgresql", "postgres"):
             cleanup_sql = f"UPDATE sessao_web SET ativo = FALSE WHERE last_seen < (NOW() - INTERVAL '{_SESS_TTL_MIN * 2} minutes')"
@@ -362,10 +261,13 @@ def _session_heartbeat(usuario: str) -> None:
     except Exception:
         db.rollback()
     finally:
-        try: db.close()
-        except Exception: pass
+        try:
+            db.close()
+        except Exception:
+            pass
 
 def _get_active_users_count() -> int:
+    """Conta usuários distintos com last_seen dentro da janela (_SESS_TTL_MIN) e ativo=1."""
     db = _get_db_session()
     try:
         _ensure_sessao_table(db)
@@ -383,10 +285,13 @@ def _get_active_users_count() -> int:
     except Exception:
         return 0
     finally:
-        try: db.close()
-        except Exception: pass
+        try:
+            db.close()
+        except Exception:
+            pass
 
 def _mark_session_inactive() -> None:
+    """Marca a sessão atual como inativa (chamar no logout)."""
     sid = st.session_state.get("_sid")
     if not sid:
         return
@@ -398,12 +303,14 @@ def _mark_session_inactive() -> None:
     except Exception:
         db.rollback()
     finally:
-        try: db.close()
-        except Exception: pass
+        try:
+            db.close()
+        except Exception:
+            pass
 
-# --------------------------------------------------------------------------------------
-# Aviso Global (banner superior)
-# --------------------------------------------------------------------------------------
+# ===============================
+# Aviso Global — Util (leitura e sanitização)
+# ===============================
 def _sanitize_largura(largura_raw: str) -> str:
     val = (largura_raw or "").strip()
     if not val:
@@ -418,20 +325,24 @@ def obter_aviso_ativo(db):
     try:
         aviso = (
             db.query(AvisoGlobal)
-              .filter(AvisoGlobal.ativo == True)
-              .order_by(AvisoGlobal.updated_at.desc(), AvisoGlobal.created_at.desc())
-              .first()
+            .filter(AvisoGlobal.ativo == True)
+            .order_by(AvisoGlobal.updated_at.desc(), AvisoGlobal.created_at.desc())
+            .first()
         )
         return aviso
     except Exception:
         return None
 
+# ===============================
+# Aviso Global — Render do banner superior (robusto)
+# ===============================
 def _render_aviso_global_topbar():
     try:
         db = _get_db_session()
     except Exception as e:
         st.sidebar.warning(f"Aviso desativado: sessão indisponível ({e})")
         return
+
     aviso = None
     try:
         aviso = obter_aviso_ativo(db)
@@ -439,26 +350,31 @@ def _render_aviso_global_topbar():
         st.sidebar.warning(f"Aviso desativado: falha ao consultar ({e})")
         aviso = None
     finally:
-        try: db.close()
-        except Exception: pass
+        try:
+            db.close()
+        except Exception:
+            pass
 
     if not aviso:
         return
+
     try:
-        largura = _sanitize_largura(getattr(aviso, "largura", "100%"))
-        bg = getattr(aviso, "bg_color", "#FFF3CD") or "#FFF3CD"
-        fg = getattr(aviso, "text_color", "#664D03") or "#664D03"
-        efeito = (getattr(aviso, "efeito", "marquee") or "marquee").lower()
-        velocidade = int(getattr(aviso, "velocidade", 20) or 20)
+        largura = _sanitize_largura(aviso.largura)
+        bg = aviso.bg_color or "#FFF3CD"
+        fg = aviso.text_color or "#664D03"
+        efeito = (aviso.efeito or "marquee").lower()
+        velocidade = int(aviso.velocidade or 20)
         try:
             font_size = max(10, min(int(getattr(aviso, "font_size", 14)), 48))
         except Exception:
             font_size = 14
 
         altura = 52  # px
+
         st.markdown(
             f"""
 <style>
+/* Não derrube overlays do Streamlit */
 .stApp::before,
 header[data-testid="stHeader"],
 [data-testid="stToolbar"],
@@ -467,6 +383,7 @@ header[data-testid="stHeader"],
 .stApp [class*="stDialog"] {{
     z-index: 1 !important;
 }}
+/* Reserva espaço para a barra */
 [data-testid="stAppViewContainer"] {{
     padding-top: {altura + 8}px !important;
 }}
@@ -504,8 +421,12 @@ header[data-testid="stHeader"],
     0%   {{ transform: translateX(0); }}
     100% {{ transform: translateX(-100%); }}
 }}
+/* Acessibilidade: reduz movimento */
 @media (prefers-reduced-motion: reduce) {{
-    .ag-topbar-marquee > span {{ animation: none !important; padding-left: 0; }}
+    .ag-topbar-marquee > span {{
+        animation: none !important;
+        padding-left: 0;
+    }}
 }}
 @media (max-width: 500px) {{
     .ag-topbar-inner {{
@@ -513,13 +434,15 @@ header[data-testid="stHeader"],
         padding: 0 8px;
         height: 44px;
     }}
-    [data-testid="stAppViewContainer"] {{ padding-top: 52px !important; }}
+    [data-testid="stAppViewContainer"] {{
+        padding-top: 52px !important;
+    }}
 }}
 </style>
 
 <div class="ag-topbar-wrap">
   <div class="ag-topbar-inner {'ag-topbar-marquee' if efeito=='marquee' else ''}">
-    <span>{getattr(aviso, 'mensagem', '')}</span>
+    <span>{aviso.mensagem}</span>
   </div>
 </div>
 """,
@@ -529,11 +452,12 @@ header[data-testid="stHeader"],
         st.sidebar.warning(f"Aviso desativado: erro de render ({e})")
         return
 
-# --------------------------------------------------------------------------------------
-# Logout
-# --------------------------------------------------------------------------------------
+# ===============================
+# Logout (utilitário)
+# ===============================
 def logout():
-    _mark_session_inactive()
+    """Finaliza a sessão do usuário, limpa estados e recarrega a aplicação."""
+    _mark_session_inactive()  # marca esta sessão como inativa
     st.session_state.logado = False
     st.session_state.usuario = None
     st.session_state.perfil = None
@@ -542,9 +466,9 @@ def logout():
     st.session_state.quiz_verificado = False
     st.rerun()
 
-# --------------------------------------------------------------------------------------
+# ===============================
 # 🎂 Banner/efeito de aniversário
-# --------------------------------------------------------------------------------------
+# ===============================
 def _show_birthday_banner_if_needed():
     if st.session_state.get("__show_birthday__"):
         st.session_state["__show_birthday__"] = False
@@ -591,11 +515,11 @@ def _show_birthday_banner_if_needed():
         st.markdown(
             f"""
 <div style="display:flex;justify-content:center;align-items:center;text-align:center;width:100%;margin:40px 0;">
-  <div style="font-size: 36px; font-weight: 800; color:#A020F0;
-              background:linear-gradient(90deg,#FFF0F6,#F0E6FF);
-              padding:20px 30px; border-radius:16px; box-shadow:0 4px 10px rgba(0,0,0,.08);">
-    🎉 Feliz Aniversário, {nome}! 🎉
-  </div>
+    <div style="font-size: 36px; font-weight: 800; color:#A020F0;
+                background:linear-gradient(90deg,#FFF0F6,#F0E6FF);
+                padding:20px 30px; border-radius:16px; box-shadow:0 4px 10px rgba(0,0,0,.08);">
+        🎉 Feliz Aniversário, {nome}! 🎉
+    </div>
 </div>
             """,
             unsafe_allow_html=True
@@ -604,34 +528,41 @@ def _show_birthday_banner_if_needed():
         st.markdown(
             f"""
 <div style="display:flex;justify-content:center;align-items:center;text-align:center;width:100%;margin-top:10px;">
-  <div style="font-size: 20px; font-weight: 500; color:{COR_FRASE}; padding:10px;">
-    Desejamos a você muitas conquistas e bons embarques ao longo do ano! 💜
-  </div>
+    <div style="font-size: 20px; font-weight: 500; color:{COR_FRASE}; padding:10px;">
+        Desejamos a você muitas conquistas e bons embarques ao longo do ano! 💜
+    </div>
 </div>
             """,
             unsafe_allow_html=True
         )
 
-# --------------------------------------------------------------------------------------
+# ===============================
 # MAIN
-# --------------------------------------------------------------------------------------
+# ===============================
 def main():
     # Estados iniciais
-    st.session_state.setdefault("logado", False)
-    st.session_state.setdefault("usuario", None)
-    st.session_state.setdefault("quiz_verificado", False)
-    st.session_state.setdefault("user_responses_viewed", False)
-    st.session_state.setdefault("nav_target", None)
+    if "logado" not in st.session_state:
+        st.session_state.logado = False
+    if "usuario" not in st.session_state:
+        st.session_state.usuario = None
+    if "quiz_verificado" not in st.session_state:
+        st.session_state.quiz_verificado = False
+    if "user_responses_viewed" not in st.session_state:
+        st.session_state.user_responses_viewed = False
+    if "nav_target" not in st.session_state:
+        st.session_state.nav_target = None
+
+    # ✅ Estado do intervalo de autoatualização (padrão aumentado p/ 60s; 0 = desligado)
     st.session_state.setdefault("__auto_refresh_interval_sec__", 60)
 
     # LOGIN
     if not st.session_state.logado:
         st.session_state.quiz_verificado = False
-        exibir_logo_safe(top=True, sidebar=False)
-        login_safe()
+        exibir_logo(top=True, sidebar=False)
+        login()
         return
 
-    # Heartbeat + badge admin
+    # 👥 Heartbeat + Badge de usuários logados (APENAS ADMIN)
     _session_heartbeat(st.session_state.usuario)
     if (st.session_state.get("perfil") or "").strip().lower() == "admin":
         try:
@@ -649,12 +580,14 @@ def main():
             unsafe_allow_html=True
         )
 
-    # 🔄 Recarregar + Auto-refresh
+    # 🔄 Botão de Recarregar (mantém a sessão ativa) + ⏱️ Controle do intervalo
     st.sidebar.markdown("---")
+    # Linha com botão de recarregar e popover para o intervalo
     col_reload, col_interval = st.sidebar.columns([1, 1])
     if col_reload.button("🔄 Recarregar (sem sair)", key="__btn_reload_now__"):
         st.rerun()
 
+    # Popover (se disponível) para configurar intervalo; fallback para expander
     if hasattr(st, "popover"):
         with col_interval.popover("⏱️ Autoatualização"):
             new_val = st.number_input(
@@ -695,10 +628,10 @@ def main():
     usuario = st.session_state.usuario
     perfil = (st.session_state.get("perfil") or "usuario").strip().lower()
 
-    # QUIZ (gating)
+    # QUIZ
     if not st.session_state.quiz_verificado:
         if not quiz_respondido_hoje(usuario):
-            exibir_logo_safe(top=True, sidebar=False)
+            exibir_logo(top=True, sidebar=False)
             quiz.main()
             return
         else:
@@ -706,22 +639,129 @@ def main():
             st.rerun()
 
     # SISTEMA LIBERADO
-    exibir_logo_safe(top=True, sidebar=True)
+    exibir_logo(top=True, sidebar=True)
     _render_aviso_global_topbar()
     _show_birthday_banner_if_needed()
 
     st.sidebar.markdown("### Menu | 🎉 Carnaval 🎭 2026!")
 
-    # Banco ativo
+    # Banco ativo na sidebar
     try:
-        banco_lbl = bank_label(current_db_choice()) if _HAS_ROUTER else (
+        _b_label = bank_label(current_db_choice()) if _HAS_ROUTER else (
             "🟢 Produção" if current_db_choice() == "prod" else "🔴 Teste"
         )
-        st.sidebar.caption(f"🗄️ Banco ativo: {banco_lbl}")
+        st.sidebar.caption(f"🗄️ Banco ativo: {_b_label}")
     except Exception:
         pass
 
-    # ========================= Menu =========================
+    # =========================
+    # Notificações no sidebar
+    # =========================
+
+    # --- Admin: pendentes ---
+    if perfil == "admin":
+        try:
+            db = _get_db_session()
+            pendentes = db.query(IOIRunSugestao).filter(func.lower(IOIRunSugestao.status) == "pendente").count()
+        except Exception:
+            pendentes = 0
+        finally:
+            try:
+                db.close()
+            except Exception:
+                pass
+
+        if pendentes > 0:
+            st.sidebar.markdown(
+                """
+<div style="padding:8px 10px;border-radius:8px;background:#FFF3CD;color:#664D03;
+            border:1px solid #FFECB5;margin-bottom:6px;">
+    <b>🔔 {pendentes} sugestão(ões) pendente(s)</b><br>
+    <span style="font-size:12px;">Acesse a caixa de entrada para responder.</span>
+</div>
+                """.format(pendentes=pendentes),
+                unsafe_allow_html=True
+            )
+
+        # 👉 Direciona para o MESMO módulo do menu (resposta.main())
+        if st.sidebar.button("📬 Abrir Caixa de Entrada (Admin)"):
+            st.session_state.nav_target = "resposta"
+            st.rerun()
+
+    # --- Usuário: respostas novas (após último 'visto') ---
+    if perfil != "admin":
+        # Última vez que o usuário realmente abriu e visualizou as respostas
+        last_seen_dt = st.session_state.get("__user_last_answer_seen__")
+
+        try:
+            db = _get_db_session()
+
+            # Qual é a resposta mais recente existente
+            last_answer_dt_row = (
+                db.query(IOIRunSugestao.data_resposta)
+                .filter(
+                    IOIRunSugestao.usuario == usuario,
+                    func.lower(IOIRunSugestao.status) == "respondida",
+                    IOIRunSugestao.data_resposta != None
+                )
+                .order_by(IOIRunSugestao.data_resposta.desc())
+                .first()
+            )
+            last_answer_dt = last_answer_dt_row[0] if last_answer_dt_row else None
+
+            # Se há algo mais novo do que o 'visto', marcamos como não visto
+            if last_answer_dt and (not last_seen_dt or last_answer_dt > last_seen_dt):
+                st.session_state.user_responses_viewed = False
+
+            # ✅ Conta SOMENTE respostas novas (depois do 'last_seen_dt')
+            novas_respostas = (
+                db.query(IOIRunSugestao)
+                .filter(
+                    IOIRunSugestao.usuario == usuario,
+                    func.lower(IOIRunSugestao.status) == "respondida",
+                    (IOIRunSugestao.data_resposta > last_seen_dt) if last_seen_dt else (IOIRunSugestao.data_resposta != None)
+                )
+                .count()
+            )
+        except Exception:
+            novas_respostas = 0
+        finally:
+            try:
+                db.close()
+            except Exception:
+                pass
+
+        # ✅ Exibir card de nova mensagem até o usuário clicar em "Ver respostas"
+        if novas_respostas > 0 and not st.session_state.get("user_responses_viewed", False):
+            st.sidebar.markdown(
+                """
+<div style="padding:8px 10px;border-radius:8px;background:#D1E7DD;color:#0F5132;
+            border:1px solid #BADBCC;margin-bottom:6px;">
+    <b>🔔 {resps} resposta(s) nova(s) para suas sugestões</b><br>
+    <span style="font-size:12px;">Clique para ver suas respostas.</span>
+</div>
+                """.format(resps=novas_respostas),
+                unsafe_allow_html=True
+            )
+
+            # (Opcional) Toast discreto — aparece uma única vez por sessão enquanto houver novidade
+            if not st.session_state.get("__user_toast_shown__"):
+                try:
+                    st.toast("Você tem novas respostas do IOI‑RUN. Clique em '📥 Ver respostas'.", icon="💬")
+                except Exception:
+                    pass
+                st.session_state["__user_toast_shown__"] = True
+
+            if st.sidebar.button("📥 Ver respostas"):
+                # Não atualizamos last_seen aqui; isso é feito dentro do módulo do usuário
+                st.session_state.nav_target = "sugestoes_ioirun"
+                st.session_state.user_responses_viewed = True
+                st.rerun()
+        else:
+            # Se não há novidades, libera o toast para a próxima vez que houver
+            st.session_state["__user_toast_shown__"] = False
+
+    # ------------------------- Menu lateral -------------------------
     termo_busca = st.sidebar.text_input("Pesquisar módulo:").strip().lower()
 
     try:
@@ -753,19 +793,14 @@ def main():
     )
 
     with st.sidebar.expander("🔧 Diagnóstico do menu", expanded=False):
-        st.caption(
-            f"Perfil: **{st.session_state.get('perfil', '—')}** | "
-            f"Grupo: **{grupo_escolhido}** | "
-            f"Busca: **{termo_busca or '∅'}** | "
-            f"Ambiente: **{ambiente_atual}**"
-        )
+        st.caption(f"Perfil: **{st.session_state.get('perfil', '—')}** | Grupo: **{grupo_escolhido}** | Busca: **{termo_busca or '∅'}** | Ambiente: **{ambiente_atual}**")
         try:
             mods_dbg = [{"id": mid, "label": lbl} for mid, lbl in (opcoes or [])]
         except Exception:
             mods_dbg = []
         st.write("Módulos visíveis (após regras):", mods_dbg if mods_dbg else "—")
 
-    # Failsafe: Outlook
+    # Failsafe outlook_relatorio
     try:
         mod_outlook = MODULES.get("outlook_relatorio")
         if mod_outlook:
@@ -779,11 +814,11 @@ def main():
             ja_nas_opcoes = any(mid == "outlook_relatorio" for mid, _ in (opcoes or []))
             passa_busca = (not termo_busca) or (termo_busca in mod_outlook.get("label", "").strip().lower())
             if mesmo_grupo and perfil_ok and not ja_nas_opcoes and passa_busca:
-                opcoes = (opcoes or []) + [("outlook_relatorio", mod_outlook.get("label", "Relatorio portaria"))]
+                opcoes = (opcoes or []) + [("outlook_relatorio", mod_outlook.get("label", "Relatório portaria"))]
     except Exception:
         pass
 
-    # Failsafe: Repositório Load
+    # Failsafe repositorio_load
     try:
         mod_repo = MODULES.get("repositorio_load")
         if mod_repo:
@@ -806,9 +841,13 @@ def main():
         st.warning(f"A operação '{grupo_escolhido}' está em desenvolvimento.")
         return
 
-    # ------------------------- seleção -------------------------
+    # ============================================================
+    # 🔒 Fix: selectbox com 'key' + seleção forçada para 'resposta'
+    #     quando vier de nav_target (sidebar) ou quando já estivermos na página.
+    # ============================================================
     labels = [label for _, label in opcoes]
 
+    # Se foi solicitado nav_target, injeta a label alvo antes do selectbox
     if st.session_state.get("nav_target"):
         target = st.session_state["nav_target"]
         try:
@@ -817,6 +856,7 @@ def main():
         except StopIteration:
             pass
 
+    # Inicializa/persiste seleção
     if "mod_select_label" not in st.session_state or st.session_state["mod_select_label"] not in labels:
         st.session_state["mod_select_label"] = labels[0]
 
@@ -829,28 +869,35 @@ def main():
 
     pagina_id = next(mod_id for mod_id, label in opcoes if label == escolha_label)
 
+    # ✅ Navegação com lock (evita disputa com outros reruns)
     if st.session_state.get("nav_target"):
         pagina_id = st.session_state.nav_target
         st.session_state["__nav_lock__"] = True
     else:
         st.session_state["__nav_lock__"] = False
 
+    # 🔎 Agora que sabemos a página atual, tratamos rr=1 com segurança
     _check_rerun_qs(pagina_atual=pagina_id)
 
-    # Auto-refresh leve do sidebar — não em módulos sensíveis
+    # ⏱️ Auto-refresh leve do sidebar — NÃO quando em Inbox/Admin/Outlook/Formulário/Recebimento
     try:
         from streamlit_autorefresh import st_autorefresh
-        sensiveis = {"resposta", "outlook_relatorio", "formulario", "recebimento"}
+        is_inbox_admin = (pagina_id == "resposta")
+        is_outlook_rel = (pagina_id == "outlook_relatorio")
+        is_formulario = (pagina_id == "formulario")
+        is_recebimento = (pagina_id == "recebimento")
         interval_sec = int(st.session_state.get("__auto_refresh_interval_sec__", 60))
-        if (interval_sec > 0) and (pagina_id not in sensiveis):
+        if (interval_sec > 0) and not (is_inbox_admin or is_outlook_rel or is_formulario or is_recebimento):
+            # key dinâmica por intervalo evita conflitos ao trocar o valor
             st_autorefresh(interval=interval_sec * 1000, key=f"sidebar_autorefresh_{interval_sec}s")
     except Exception:
         pass
 
     # Logout
     st.sidebar.markdown("---")
-    if st.session_state.get("logado") and st.sidebar.button("🚪 Sair (Logout)"):
-        logout()
+    if st.session_state.get("logado"):
+        if st.sidebar.button("🚪 Sair (Logout)"):
+            logout()
 
     st.divider()
 
@@ -882,6 +929,8 @@ def main():
         importar_excel.main()
     elif pagina_id == "calendario":
         calendario.main()
+    elif pagina_id == "calendario_mensal" and _HAS_CAL_MENSAL:
+        calendario_mensal.main()
     elif pagina_id == "jogos":
         st.session_state.setdefault("pontuacao", 0)
         st.session_state.setdefault("rodadas", 0)
@@ -895,7 +944,7 @@ def main():
         db_monitor.main()
     elif pagina_id == "operacao":
         operacao.main()
-    elif pagina_id == "resposta":
+    elif pagina_id == "resposta":  # 📬 Admin
         resposta.main()
     elif pagina_id == "db_export_import":
         db_export_import.main()
@@ -903,7 +952,7 @@ def main():
         produtividade_especialista.main()
     elif pagina_id == "outlook_relatorio":
         outlook_relatorio.main()
-    elif pagina_id == "sugestoes_ioirun":
+    elif pagina_id == "sugestoes_ioirun":  # 💡 Usuário
         if st.session_state.get("perfil") == "admin":
             st.info("Use a **📬 Caixa de Entrada (Admin)** para responder sugestões.")
         else:
@@ -921,7 +970,9 @@ def main():
     elif pagina_id == "recebimento":
         recebimento.main()
 
-    # ------------------------- Info no sidebar -------------------------
+    # ------------------------------------------------------
+    # ℹ️ INFO — Guia passo a passo de uso (no sidebar)
+    # ------------------------------------------------------
     info_mod_default = INFO_MAP_PAGINA_ID.get(pagina_id, "Geral")
     with st.sidebar.expander("ℹ️ Info • Como usar o sistema", expanded=False):
         st.markdown("""
@@ -929,36 +980,42 @@ def main():
 Este painel reúne instruções rápidas para utilizar cada módulo e seus campos.
 Selecione o módulo abaixo ou navegue pelo menu — o conteúdo ajusta automaticamente.
 """)
-        try:
-            sel_index = INFO_MODULOS.index(info_mod_default) if info_mod_default in INFO_MODULOS else 0
-        except Exception:
-            sel_index = 0
-        mod_info_sel = st.selectbox("Escolha o módulo para ver instruções:", INFO_MODULOS, index=sel_index, key="info_mod_sel")
+        mod_info_sel = st.selectbox(
+            "Escolha o módulo para ver instruções:",
+            INFO_MODULOS,
+            index=INFO_MODULOS.index(info_mod_default) if info_mod_default in INFO_MODULOS else 0,
+            key="info_mod_sel"
+        )
         st.markdown(INFO_CONTEUDO.get(mod_info_sel, "_Conteúdo não disponível para este módulo._"))
 
-    # Libera nav_target após primeira render da página destino
+    # ✅ Libera o nav_target após a 1ª render da página de destino
     if st.session_state.get("__nav_lock__"):
         st.session_state["nav_target"] = None
         st.session_state["__nav_lock__"] = False
 
-# --------------------------------------------------------------------------------------
 if __name__ == "__main__":
     main()
-
-    # ------------------------- Rodapé do sidebar (limpo) -------------------------
+    # -------------------------
+    # Desenvolvedor e versão
+    # -------------------------
     if st.session_state.get("logado") and st.session_state.get("email"):
-        st.sidebar.markdown(f"**👤 {st.session_state.email}**")
-
-    st.sidebar.divider()
-    st.sidebar.markdown("Versão: **1.0.0** • Desenvolvedor: **Rodrigo Silva - Ideiasystem | 2026**")
-
-
-
-
-
-
-
-
-
-
+        st.sidebar.markdown(
+            f"""
+<div style="display:inline-flex;align-items:center;gap:8px; padding:4px 8px;border-radius:8px;
+            background:#e7f1ff;color:#0d6efd;font-size:13px;line-height:1.2;">
+    <span style="font-size:16px;">👤</span>
+    <span>{st.session_state.email}</span>
+</div>
+            """,
+            unsafe_allow_html=True
+        )
 
+    st.sidebar.markdown(
+        """
+<hr style="margin-top: 10px; margin-bottom: 6px;">
+<p style="font-size: 12px; color: #6c757d;">
+    Versão: <strong>1.0.0</strong> • Desenvolvedor: <strong>Rodrigo Silva - Ideiasystem | 2026</strong>
+</p>
+        """,
+        unsafe_allow_html=True
+    )